使用交接构建客户支持

import { StateSchema } from "@langchain/langgraph";
import { z } from "zod";

// 定义可能的流程步骤
const SupportStepSchema = z.enum(["warranty_collector", "issue_classifier", "resolution_specialist"]);
const WarrantyStatusSchema = z.enum(["in_warranty", "out_of_warranty"]);
const IssueTypeSchema = z.enum(["hardware", "software"]);

// 客户支持工作流的状态
const SupportState = new StateSchema({
  currentStep: SupportStepSchema.optional(),
  warrantyStatus: WarrantyStatusSchema.optional(),
  issueType: IssueTypeSchema.optional(),
});

import { z } from "zod";
import { tool, ToolMessage, type ToolRuntime } from "langchain";
import { Command } from "@langchain/langgraph";

const recordWarrantyStatus = tool(
  async (input, config: ToolRuntime<typeof SupportState.State>) => {
    return new Command({
      update: {
        messages: [
          new ToolMessage({
            content: `保修状态已记录为: ${input.status}`,
            tool_call_id: config.toolCallId,
          }),
        ],
        warrantyStatus: input.status,
        currentStep: "issue_classifier",
      },
    });
  },
  {
    name: "record_warranty_status",
    description:
      "记录客户的保修状态并过渡到问题分类。",
    schema: z.object({
      status: WarrantyStatusSchema,
    }),
  }
);

const recordIssueType = tool(
  async (input, config: ToolRuntime<typeof SupportState.State>) => {
    return new Command({
      update: {
        messages: [
          new ToolMessage({
            content: `问题类型已记录为: ${input.issueType}`,
            tool_call_id: config.toolCallId,
          }),
        ],
        issueType: input.issueType,
        currentStep: "resolution_specialist",
      },
    });
  },
  {
    name: "record_issue_type",
    description:
      "记录问题类型并过渡到解决方案专家。",
    schema: z.object({
      issueType: IssueTypeSchema,
    }),
  }
);

const escalateToHuman = tool(
  async (input) => {
    // 在实际系统中，这将创建工单、通知员工等。
    return `正在升级到人工支持。原因: ${input.reason}`;
  },
  {
    name: "escalate_to_human",
    description: "将案例升级到人工支持专家。",
    schema: z.object({
      reason: z.string(),
    }),
  }
);

const provideSolution = tool(
  async (input) => {
    return `已提供解决方案: ${input.solution}`;
  },
  {
    name: "provide_solution",
    description: "为客户提供问题的解决方案。",
    schema: z.object({
      solution: z.string(),
    }),
  }
);

// 步骤配置：将步骤名称映射到（提示词、工具、必需状态）
const STEP_CONFIG = {
  warranty_collector: {
    prompt: WARRANTY_COLLECTOR_PROMPT,
    tools: [recordWarrantyStatus],
    requires: [],
  },
  issue_classifier: {
    prompt: ISSUE_CLASSIFIER_PROMPT,
    tools: [recordIssueType],
    requires: ["warrantyStatus"],
  },
  resolution_specialist: {
    prompt: RESOLUTION_SPECIALIST_PROMPT,
    tools: [provideSolution, escalateToHuman],
    requires: ["warrantyStatus", "issueType"],
  },
} as const;

import { createMiddleware } from "langchain";

const applyStepMiddleware = createMiddleware({
  name: "applyStep",
  stateSchema: SupportState,
  wrapModelCall: async (request, handler) => {
    // 获取当前步骤（首次交互默认为 warranty_collector）
    const currentStep = request.state.currentStep ?? "warranty_collector";

    // 查找步骤配置
    const stepConfig = STEP_CONFIG[currentStep];

    // 验证必需的状态是否存在
    for (const key of stepConfig.requires) {
      if (request.state[key] === undefined) {
        throw new Error(`在达到 ${currentStep} 之前必须设置 ${key}`);
      }
    }

    // 用状态值格式化提示词（支持 {warrantyStatus}、{issueType} 等）
    let systemPrompt: string = stepConfig.prompt;
    for (const [key, value] of Object.entries(request.state)) {
      systemPrompt = systemPrompt.replace(`{${key}}`, String(value ?? ""));
    }

    // 注入系统提示词和特定于步骤的工具
    return handler({
      ...request,
      systemPrompt,
      tools: [...stepConfig.tools],
    });
  },
});

import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
import { ChatOpenAI } from "@langchain/openai";

// 从所有步骤配置中收集所有工具
const allTools = [
  recordWarrantyStatus,
  recordIssueType,
  provideSolution,
  escalateToHuman,
];

// 初始化模型
const model = new ChatOpenAI({
  model: "gpt-5.4-mini",
  temperature: 0.7,
});

// 创建具有基于步骤配置的智能体
const agent = createAgent({
  model,
  tools: allTools,
  stateSchema: SupportState,
  middleware: [applyStepMiddleware],
  checkpointer: new MemorySaver(),
});

import { HumanMessage } from "@langchain/core/messages";
import { v7 as uuid7 } from "uuid";

// 此对话线程的配置
const threadId = uuid7();
const config = { configurable: { thread_id: threadId } };

// 轮次 1: 初始消息 - 从 warranty_collector 步骤开始
console.log("=== 轮次 1: 保修信息收集 ===");
let result = await agent.invoke(
  { messages: [new HumanMessage("你好，我的手机屏幕碎了")] },
  config
);
for (const msg of result.messages) {
  console.log(msg.content);
}

// 轮次 2: 用户回应保修信息
console.log("\n=== 轮次 2: 保修回应 ===");
result = await agent.invoke(
  { messages: [new HumanMessage("是的，还在保修期内")] },
  config
);
for (const msg of result.messages) {
  console.log(msg.content);
}
console.log(`当前步骤: ${result.currentStep}`);

// 轮次 3: 用户描述问题
console.log("\n=== 轮次 3: 问题描述 ===");
result = await agent.invoke(
  { messages: [new HumanMessage("屏幕因为摔落而物理性碎裂")] },
  config
);
for (const msg of result.messages) {
  console.log(msg.content);
}
console.log(`当前步骤: ${result.currentStep}`);

// 轮次 4: 解决方案
console.log("\n=== 轮次 4: 解决方案 ===");
result = await agent.invoke(
  { messages: [new HumanMessage("我该怎么办？")] },
  config
);
for (const msg of result.messages) {
  console.log(msg.content);
}

{
  messages: [new HumanMessage("你好，我的手机屏幕碎了")],
  currentStep: "warranty_collector"  // 默认值
}

new Command({
  update: {
    warrantyStatus: "in_warranty",
    currentStep: "issue_classifier"  // 状态转换！
  }
})

new Command({
  update: {
    issueType: "hardware",
    currentStep: "resolution_specialist"  // 状态转换！
  }
})

import { createAgent, SummarizationMiddleware } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const agent = createAgent({
  model,
  tools: allTools,
  stateSchema: SupportState,
  middleware: [
    applyStepMiddleware,
    new SummarizationMiddleware({
      model: "gpt-5.4-mini",
      trigger: { tokens: 4000 },
      keep: { messages: 10 },
    }),
  ],
  checkpointer: new MemorySaver(),
});

import { tool } from "langchain";
import { Command } from "@langchain/langgraph";
import { z } from "zod";

const goBackToWarranty = tool(  
  async () => {
    return new Command({ update: { currentStep: "warranty_collector" } });
  },
  {
    name: "go_back_to_warranty",
    description: "返回保修验证步骤。",
    schema: z.object({}),
  }
);

const goBackToClassification = tool(  
  async () => {
    return new Command({ update: { currentStep: "issue_classifier" } });
  },
  {
    name: "go_back_to_classification",
    description: "返回问题分类步骤。",
    schema: z.object({}),
  }
);

// 更新 resolution_specialist 配置以包含这些工具
STEP_CONFIG.resolution_specialist.tools.push(
  goBackToWarranty,
  goBackToClassification
);

const RESOLUTION_SPECIALIST_PROMPT = `你是一位帮助解决设备问题的客户支持代理。

当前阶段: 解决方案
客户信息: 保修状态为 {warrantyStatus}，问题类型为 {issueType}

在此步骤中，你需要：
1. 对于软件问题：使用 provide_solution 提供故障排除步骤
2. 对于硬件问题：
   - 如果在保修期内：使用 provide_solution 解释保修维修流程
   - 如果超出保修期：escalate_to_human 处理付费维修选项

如果客户表示任何信息有误，请使用：
- go_back_to_warranty 更正保修状态
- go_back_to_classification 更正问题类型

提供具体且有帮助的解决方案。`;

const result = await agent.invoke(
  { messages: [new HumanMessage("实际上，我搞错了——我的设备超出保修期了")] },
  config
);
// 智能体将调用 go_back_to_warranty 并重新开始保修验证步骤