// multi-agent.ts
import { createAgent } from "langchain";
import { ChatAnthropic } from "@langchain/anthropic";
import { tool } from "@langchain/core/tools";
import { z } from "zod";
 
// 工具：订单查询
const queryOrder = tool(
  async ({ orderId }) => `订单 ${orderId} 状态：已发货，预计明天送达`,
  {
    name: "query_order",
    description: "根据订单号查询订单状态、物流",
    schema: z.object({ orderId: z.string() }),
  }
);
 
// 工具：退款发起
const initiateRefund = tool(
  async ({ orderId, reason }) =>
    `订单 ${orderId} 退款已发起（原因：${reason}），3-5 个工作日到账`,
  {
    name: "initiate_refund",
    description: "为指定订单发起退款",
    schema: z.object({ orderId: z.string(), reason: z.string() }),
  }
);
 
// 工具：技术故障排查
const diagnose = tool(
  async ({ symptom }) =>
    `针对症状"${symptom}"的建议：1) 重启设备 2) 检查网络 3) 重置应用缓存`,
  {
    name: "diagnose",
    description: "诊断常见技术故障并给出排查步骤",
    schema: z.object({ symptom: z.string() }),
  }
);
 
// 三个专科 Agent
const orderAgent = createAgent({
  model: new ChatAnthropic({ model: "claude-haiku-4-5", temperature: 0 }),
  tools: [queryOrder],
  systemPrompt: "你是订单专员。只回答订单查询、物流追踪相关问题。",
  name: "order_agent",
});
 
const refundAgent = createAgent({
  model: new ChatAnthropic({ model: "claude-sonnet-4-6", temperature: 0 }),
  tools: [initiateRefund],
  systemPrompt:
    "你是退款专员。处理退款申请前，先确认订单号和退款原因，然后调用工具发起。",
  name: "refund_agent",
});
 
const techAgent = createAgent({
  model: new ChatAnthropic({ model: "claude-sonnet-4-6", temperature: 0 }),
  tools: [diagnose],
  systemPrompt:
    "你是技术支持专员。先询问具体故障现象，再调用 diagnose 给出排查步骤。",
  name: "tech_agent",
});

import {
  StateGraph,
  START,
  END,
  MessagesAnnotation,
  Command,
} from "@langchain/langgraph";
 
const routeSchema = z.object({
  next: z
    .enum(["order_agent", "refund_agent", "tech_agent", "FINISH"])
    .describe("路由目标，FINISH 表示直接给用户回复"),
  reason: z.string().describe("路由理由（用于日志）"),
});
 
const supervisorModel = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  temperature: 0,
}).withStructuredOutput(routeSchema);
 
async function supervisorNode(state: typeof MessagesAnnotation.State) {
  const decision = await supervisorModel.invoke([
    {
      role: "system",
      content: `你是客服分诊主管。根据用户的最新问题，路由到合适的专员：
- order_agent：订单查询、物流追踪
- refund_agent：退款、退货
- tech_agent：技术故障、使用问题
- FINISH：问题已解决，可以给用户最终回复
 
如果同一问题已经被某个专员回答过且用户没有追问，选 FINISH。`,
    },
    ...state.messages.map((m) => ({
      role: m.getType() === "human" ? ("user" as const) : ("assistant" as const),
      content: typeof m.content === "string" ? m.content : "",
    })),
  ]);
 
  console.log(`[supervisor] → ${decision.next} (${decision.reason})`);
 
  if (decision.next === "FINISH") {
    return new Command({ goto: END });
  }
 
  return new Command({ goto: decision.next });
}

async function runOrderAgent(state: typeof MessagesAnnotation.State) {
  const result = await orderAgent.invoke({ messages: state.messages });
  // 只把新产生的消息追加回主 state，不重复已有消息
  const newMessages = result.messages.slice(state.messages.length);
  return new Command({
    goto: "supervisor",
    update: { messages: newMessages },
  });
}
 
async function runRefundAgent(state: typeof MessagesAnnotation.State) {
  const result = await refundAgent.invoke({ messages: state.messages });
  const newMessages = result.messages.slice(state.messages.length);
  return new Command({
    goto: "supervisor",
    update: { messages: newMessages },
  });
}
 
async function runTechAgent(state: typeof MessagesAnnotation.State) {
  const result = await techAgent.invoke({ messages: state.messages });
  const newMessages = result.messages.slice(state.messages.length);
  return new Command({
    goto: "supervisor",
    update: { messages: newMessages },
  });
}

import { MemorySaver } from "@langchain/langgraph";
 
const graph = new StateGraph(MessagesAnnotation)
  .addNode("supervisor", supervisorNode, {
    ends: ["order_agent", "refund_agent", "tech_agent", END],
  })
  .addNode("order_agent", runOrderAgent, { ends: ["supervisor"] })
  .addNode("refund_agent", runRefundAgent, { ends: ["supervisor"] })
  .addNode("tech_agent", runTechAgent, { ends: ["supervisor"] })
  .addEdge(START, "supervisor");
 
const app = graph.compile({ checkpointer: new MemorySaver() });

const cfg = { configurable: { thread_id: "customer-001" } };
 
const result = await app.invoke(
  {
    messages: [
      {
        role: "user",
        content: "我订单 ORD-1234 还没收到，帮我查一下",
      },
    ],
  },
  cfg
);
 
// 看完整对话
for (const m of result.messages) {
  const tag = m.getType() === "human" ? "用户" : `AI (${m.name ?? "?"})`;
  const text = typeof m.content === "string" ? m.content : "";
  console.log(`[${tag}] ${text}`);
}

[supervisor] → order_agent (查询订单物流)
[用户] 我订单 ORD-1234 还没收到，帮我查一下
[AI (order_agent)] 订单 ORD-1234 状态：已发货，预计明天送达
[supervisor] → FINISH (订单状态已告知)

const r2 = await app.invoke(
  { messages: [{ role: "user", content: "那我不要了，能退款吗" }] },
  cfg
);
// supervisor 会路由到 refund_agent

// 售前 supervisor 子图
const presaleGraph = new StateGraph(MessagesAnnotation)
  .addNode("supervisor", presaleSupervisorNode, { ends: ["guide", "config", END] })
  .addNode("guide", runGuideAgent, { ends: ["supervisor"] })
  .addNode("config", runConfigAgent, { ends: ["supervisor"] })
  .addEdge(START, "supervisor");
 
const presale = presaleGraph.compile();
 
// 售后 supervisor 子图
const aftersaleGraph = new StateGraph(MessagesAnnotation)
  .addNode("supervisor", aftersaleSupervisorNode, { ends: ["refund", "warranty", END] })
  .addNode("refund", runRefundAgent, { ends: ["supervisor"] })
  .addNode("warranty", runWarrantyAgent, { ends: ["supervisor"] })
  .addEdge(START, "supervisor");
 
const aftersale = aftersaleGraph.compile();
 
// 顶层 supervisor 把请求路由到子图
const topGraph = new StateGraph(MessagesAnnotation)
  .addNode("top", topSupervisorNode, { ends: ["presale", "aftersale", END] })
  .addNode("presale", async (state) => {
    const r = await presale.invoke({ messages: state.messages });
    return new Command({ goto: "top", update: { messages: r.messages.slice(state.messages.length) } });
  }, { ends: ["top"] })
  .addNode("aftersale", async (state) => {
    const r = await aftersale.invoke({ messages: state.messages });
    return new Command({ goto: "top", update: { messages: r.messages.slice(state.messages.length) } });
  }, { ends: ["top"] })
  .addEdge(START, "top");

function createHandoffTool(targetAgent: string, description: string) {
  return tool(
    async (_input, config) => {
      // 工具返回值不重要，关键是抛出 Command 让 graph 跳转
      // 1.x 的 ToolNode 会识别返回的 Command 并执行路由
      return new Command({
        goto: targetAgent,
        update: {
          messages: [
            {
              role: "tool",
              content: `已转接到 ${targetAgent}`,
              // 此字段来自 LangGraph 工具调用上下文，如遇 undefined 检查 LangGraph 版本
              tool_call_id: config?.toolCall?.id,
            },
          ],
        },
      });
    },
    {
      name: `handoff_to_${targetAgent}`,
      description,
      schema: z.object({}),
    }
  );
}
 
const handoffToRefund = createHandoffTool("refund_agent", "把对话转交给退款专员");
const handoffToTech = createHandoffTool("tech_agent", "把对话转交给技术专员");
 
const orderAgent = createAgent({
  model: new ChatAnthropic({ model: "claude-haiku-4-5" }),
  tools: [queryOrder, handoffToRefund, handoffToTech],
  systemPrompt:
    "你是订单专员。如果用户问的是退款，调 handoff_to_refund；如果问技术问题，调 handoff_to_tech；否则用 query_order 自己处理。",
  name: "order_agent",
});