┌─────────────────────────────────────────────┐
│                  AgentFlow                   │
│                                              │
│  ┌──────┐    ┌──────┐    ┌──────┐           │
│  │ Node │───▶│ Node │───▶│ Node │           │
│  └──────┘    └──────┘    └──────┘           │
│       │            │                         │
│       │     ┌──────▼──────┐                  │
│       │     │ Conditional │                  │
│       │     │    Edge     │                  │
│       │     └──────┬──────┘                  │
│       │            │                         │
│  ┌────▼────────────▼────┐                    │
│  │       State          │                    │
│  │  (共享上下文数据)      │                    │
│  └──────────────────────┘                    │
└─────────────────────────────────────────────┘

import { AgentFlow, Agent, State } from '@agentflow/core';
 
// 定义状态类型
interface WorkflowState extends State {
  userQuery: string;
  intent: string;
  response: string;
}
 
// 创建 Agent
const intentAgent = new Agent({
  name: 'intent-recognizer',
  model: 'gpt-4',
  prompt: '分析用户意图，输出: question / complaint / request',
});
 
const responseAgent = new Agent({
  name: 'response-generator',
  model: 'gpt-4',
  prompt: '根据用户意图和查询内容，生成专业回复',
});
 
// 构建工作流
const flow = new AgentFlow<WorkflowState>({
  nodes: {
    recognize: intentAgent.asNode(),
    respond: responseAgent.asNode(),
  },
  edges: [
    { from: 'START', to: 'recognize' },
    { from: 'recognize', to: 'respond' },
    { from: 'respond', to: 'END' },
  ],
});
 
// 执行
const result = await flow.run({
  userQuery: '我的订单怎么还没发货？',
});

import { AgentFlow, Agent, ConditionalEdge } from '@agentflow/core';
 
interface CustomerServiceState extends State {
  userQuery: string;
  intent: 'question' | 'complaint' | 'refund' | 'unknown';
  context: string;
  response: string;
  needHuman: boolean;
}
 
// 1. 意图识别 Agent
const intentAgent = new Agent({
  name: 'intent-agent',
  model: 'gpt-4',
  systemPrompt: `你是一个意图分类器，将用户输入分类为：
    - question: 产品咨询
    - complaint: 投诉
    - refund: 退款请求
    - unknown: 无法识别
    只输出分类结果，不要其他内容。`,
});
 
// 2. 知识检索 Agent
const knowledgeAgent = new Agent({
  name: 'knowledge-agent',
  model: 'gpt-4',
  tools: [vectorSearchTool], // 接入向量数据库
  systemPrompt: '根据用户问题检索相关知识库，返回相关信息',
});
 
// 3. 回复生成 Agent
const responseAgent = new Agent({
  name: 'response-agent',
  model: 'gpt-4',
  systemPrompt: '基于检索到的知识，生成友好、专业的客服回复',
});
 
// 4. 人工升级 Agent
const escalateAgent = new Agent({
  name: 'escalate-agent',
  model: 'gpt-4',
  systemPrompt: '生成转人工话术，并创建工单',
});
 
// 条件路由：根据意图决定下一步
const routeByIntent = (state: CustomerServiceState): string => {
  if (state.intent === 'unknown') return 'escalate';
  if (state.intent === 'complaint') return 'escalate';
  return 'knowledge'; // question 和 refund 走知识检索
};
 
// 构建工作流
const customerServiceFlow = new AgentFlow<CustomerServiceState>({
  nodes: {
    intent: intentAgent.asNode(),
    knowledge: knowledgeAgent.asNode(),
    response: responseAgent.asNode(),
    escalate: escalateAgent.asNode(),
  },
  edges: [
    { from: 'START', to: 'intent' },
    // 条件边：根据意图动态路由
    ConditionalEdge.from('intent', routeByIntent, {
      knowledge: 'knowledge',
      escalate: 'escalate',
    }),
    { from: 'knowledge', to: 'response' },
    { from: 'response', to: 'END' },
    { from: 'escalate', to: 'END' },
  ],
});
 
// 执行工作流
const result = await customerServiceFlow.run({
  userQuery: '我买的手机屏幕碎了，要退款',
});

const flow = new AgentFlow({
  nodes: {
    analyze: analyzeAgent.asNode(),
    summarize: summarizeAgent.asNode(),
    translate: translateAgent.asNode(),
    merge: mergeAgent.asNode(),
  },
  edges: [
    { from: 'START', to: 'analyze' },
    // 并行分支
    { from: 'analyze', to: 'summarize' },
    { from: 'analyze', to: 'translate' },
    // 等待两个分支都完成后再合并
    { from: 'summarize', to: 'merge' },
    { from: 'translate', to: 'merge' },
    { from: 'merge', to: 'END' },
  ],
});

// 定义子流程：内容审核
const contentReviewSubflow = new SubFlow({
  nodes: {
    check: checkAgent.asNode(),
    filter: filterAgent.asNode(),
  },
  edges: [
    { from: 'START', to: 'check' },
    { from: 'check', to: 'filter' },
    { from: 'filter', to: 'END' },
  ],
});
 
// 在主流程中使用
const mainFlow = new AgentFlow({
  nodes: {
    generate: generateAgent.asNode(),
    review: contentReviewSubflow.asNode(), // 子流程作为节点
    publish: publishAgent.asNode(),
  },
  edges: [
    { from: 'START', to: 'generate' },
    { from: 'generate', to: 'review' },
    { from: 'review', to: 'publish' },
    { from: 'publish', to: 'END' },
  ],
});

const flow = new AgentFlow({
  nodes: {
    fetch: fetchAgent.asNode({
      retry: {
        maxAttempts: 3,
        delay: 1000,
        backoff: 'exponential',
      },
      onError: async (error, state) => {
        // 降级处理：使用缓存数据
        state.response = await cache.get(state.userQuery);
        return 'END'; // 跳过后续步骤
      },
    }),
  },
});

flow.on('node:start', (event) => {
  console.log(`[${event.timestamp}] 节点 ${event.nodeId} 开始执行`);
});
 
flow.on('node:complete', (event) => {
  console.log(`[${event.timestamp}] 节点 ${event.nodeId} 完成，耗时 ${event.duration}ms`);
});
 
flow.on('edge:traverse', (event) => {
  console.log(`边 ${event.from} → ${event.to} 被触发`);
});
 
flow.on('error', (event) => {
  console.error(`节点 ${event.nodeId} 出错: ${event.error.message}`);
});