interface IntentService {
  // 创建采购意图
  async createIntent(data: CreateIntentRequest): Promise<Intent>;
  
  // 提交并验证采购意图
  async submitIntent(
    intentId: string,
    options: SubmitOptions
  ): Promise<SubmitResult>;
  
  // 开始处理采购意图
  async processIntent(
    intentId: string,
    processor: string
  ): Promise<ProcessResult>;
  
  // 完成处理
  async completeIntent(
    intentId: string,
    notes: string
  ): Promise<void>;
  
  // 标记失败
  async failIntent(
    intentId: string,
    error: ProcessError
  ): Promise<void>;
  
  // 查询采购意图
  async getIntent(intentId: string): Promise<Intent>;
  async queryIntents(filter: QueryFilter): Promise<Intent[]>;
}
 
// 数据类型定义
interface CreateIntentRequest {
  platform: string;
  productUrl: string;
  title: string;
  price: number;
  quantity: number;
  recipientInfo: RecipientInfo;
  remarks?: string;
}
 
interface SubmitOptions {
  submitNotes: string;
  validationRules: string[];
}
 
interface SubmitResult {
  success: boolean;
  validationErrors?: ValidationError[];
  intentId?: string;
}

interface OrderService {
  // 创建执行工单
  async createOrder(
    intentId: string,
    agentId: string,
    tolerance: number
  ): Promise<Order>;
  
  // 开始执行
  async startExecution(
    orderId: string,
    executionPlan: string[]
  ): Promise<ExecutionResult>;
  
  // 记录执行步骤
  async logStep(
    orderId: string,
    step: ExecutionStep
  ): Promise<void>;
  
  // 完成执行
  async completeExecution(
    orderId: string,
    orderDetails: OrderDetails
  ): Promise<void>;
  
  // 执行失败
  async failExecution(
    orderId: string,
    error: ExecutionError
  ): Promise<void>;
}
 
// 执行步骤数据结构
interface ExecutionStep {
  stepName: string;
  status: 'success' | 'failed' | 'pending';
  timestamp: Date;
  details: string;
  metadata?: Record<string, any>;
}
 
interface OrderDetails {
  orderNumber: string;
  paidAmount: number;
  completionDetails: string;
}

// L1层 → L2层服务调用示例
class L1IntentCollector {
  constructor(
    private intentService: IntentService,
    private orderService: OrderService
  ) {}
 
  async handleUserSubmission(data: UserIntentData): Promise<void> {
    // 1. 创建采购意图
    const intent = await this.intentService.createIntent({
      platform: data.platform,
      productUrl: data.url,
      title: data.title,
      price: data.price,
      quantity: data.quantity,
      recipientInfo: data.recipient,
      remarks: data.remarks
    });
 
    // 2. 提交并验证
    const result = await this.intentService.submitIntent(intent.id, {
      submitNotes: "用户确认提交",
      validationRules: ["price_check", "address_format"]
    });
 
    if (!result.success) {
      throw new ValidationError(result.validationErrors);
    }
 
    // 3. 自动开始处理
    await this.intentService.processIntent(intent.id, "system_auto");
  }
}

// L2层处理完成后调用L3层执行
class L2IntentProcessor {
  constructor(
    private executionService: L3ExecutionService,
    private orderService: OrderService
  ) {}
 
  async onIntentProcessing(intentId: string): Promise<void> {
    // 创建执行工单
    const order = await this.orderService.createOrder(
      intentId,
      "agent_taobao_01",
      0.1
    );
 
    // 触发L3层执行
    await this.executionService.executeOrder(order.id);
  }
}