const agentState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: safeMessagesStateReducer,
    default: () => [],
  })
});

const toolNodeForGraph = new ToolNode(tools)

const shouldContinue = (state: typeof agentState.State) => {
  const { messages } = state;
  const lastMessage = messages[messages.length - 1];
  if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
      return"tools";
  }
  return END;
}

const callModel = async (state: typeof agentState.State) => {
  const { messages } = state;
  const response = await modelWithTools.invoke(messages);
  return { messages: response };
}


const workflow = new StateGraph(agentState)
  .addNode("llm", callModel)
  .addNode("tools", toolNodeForGraph)
  .addEdge(START, "llm")
  .addConditionalEdges("llm", shouldContinue, ["tools", END])
  .addEdge("tools", "llm");

const agent = workflow.compile()

const config = {
  configurable: { thread_id: this.sessionId },
  streamMode: ['values', 'messages', 'updates'],
  version: 'v2' as const,
}
const stream = agent.streamEvents({messages: [inputMessage]}, config);

// 添加人工审查节点的workflow
const workflowWithReview = new StateGraph(MessagesAnnotation)
  .addNode("agent", callModel)
  .addNode("tools", toolNodeForGraph)
  .addNode("human_review", humanReviewNode)  // 新增：人工审查节点
  .addEdge(START, "agent")
  .addConditionalEdges("agent", shouldContinueWithReview, ["human_review", END])  // 修改：路由到审查节点
  .addConditionalEdges("human_review", checkUserApproval, ["tools", "agent"])  // 新增：审查结果路由
  .addEdge("tools", "agent");

// 人工审查节点的具体实现
const humanReviewNode = async (state: typeof MessagesAnnotation.State) => {
  const lastMessage = state.messages[state.messages.length - 1];
  const humanAnswer = interrupt("确认是否执行");
  if(humanAnswer === "同意"){
    returnnew Command({
      goto: "tool",
      update: {
        messages: [new HumanMessage("确认执行")]
      }
    })
  }
  
  if(humanAnswer === "拒绝"){
    returnnew Command({
      goto: "agent",
      update: {
        messages: [new HumanMessage("xxxx")]
      }
    })
  }
};

function createHumanLoopTool(){
    const executor = (arg, config) => {
      const msgs: BaseMessage[] = [
        new ToolMessage({
          content: 'Successfully askHuman,',
          name: 'askHuman',
          tool_call_id: config.toolCall.id,
        }),
      ];
      const state = getCurrentTaskInput();
      returnnew Command({
        goto: 'askHuman',
        graph: Command.PARENT,
        update: {
          messages: state.messages.concat(msgs),
        },
      });
    };
    return tool(executor, {
      name: 'ashHuman',
      description: '当需要向用户确认需求、询问补充信息、向用户提问时, 务必调用此工具',
      schema,
    });
  }

import { MemorySaver } from "@langchain/langgraph";

const app = workflow.compile({
  checkpointer: new MemorySaver(),  // 状态持久化
});

// 使用示例
const config = { configurable: { thread_id: "review-session-1" } };
await app.invoke(initialState, config);

// 在用户审查后继续执行
await app.invoke(null, config);  // 从中断点继续

// Task工具对象结构 (p_2)
p_2 = {
    name: "Task",
    async call({ prompt }, context, globalConfig, parentMessage) {
        // 核心：通过Task工具内部创建和管理SubAgent
        if (config.parallelTasksCount > 1) {
            // 多Agent并发执行模式
            const agentTasks = Array(config.parallelTasksCount)
                .fill(`${prompt}\n\nProvide a thorough and complete analysis.`)
                .map((taskPrompt, index) => I2A(taskPrompt, index, executionContext, parentMessage, globalConfig));
        } else {
            // 单Agent执行模式
        }
    }
}

// SubAgent启动函数
async function* I2A(taskPrompt, agentIndex, parentContext, globalConfig, options = {}){
    // 1. 生成唯一Agent ID
    const agentId = VN5();
    
    // 2. 创建隔离的执行上下文
    const executionContext = {
        abortController: parentContext.abortController,
        options: { ...parentContext.options },
        getToolPermissionContext: parentContext.getToolPermissionContext,
        readFileState: parentContext.readFileState,
        setInProgressToolUseIDs: parentContext.setInProgressToolUseIDs,
        tools: parentContext.tools.filter(tool => tool.name !== "Task") // 防止递归
    };
    
    // 3. 执行主Agent循环
    forawait(let agentResponse of nO(/* 主Agent循环 */)){
        // 处理Agent响应和工具调用
    }
    
    // 4. 返回最终结果
    yield { type: "result", data: { /* 结果数据 */ } };
}

// 并发执行调度器
async function* UH1(generators, maxConcurrency = Infinity){
    const wrapGenerator = (generator) => {
        const promise = generator.next().then(({ done, value }) => ({
            done, value, generator, promise
        }));
        return promise;
    };
    
    const remainingGenerators = [...generators];
    const activePromises = new Set();
    
    // 启动初始并发任务
    while (activePromises.size < maxConcurrency && remainingGenerators.length > 0) {
        const generator = remainingGenerators.shift();
        activePromises.add(wrapGenerator(generator));
    }
    
    // 并发执行循环
    while (activePromises.size > 0) {
        const { done, value, generator, promise } = await Promise.race(activePromises);
        activePromises.delete(promise);
        
        if (!done) {
            activePromises.add(wrapGenerator(generator));
            if (value !== undefined) yield value;
        } elseif (remainingGenerators.length > 0) {
            const nextGenerator = remainingGenerators.shift();
            activePromises.add(wrapGenerator(nextGenerator));
        }
    }
}

// 多Agent结果合成器
function KN5(originalTask, agentResults){
    const sortedResults = agentResults.sort((a, b) => a.agentIndex - b.agentIndex);
    
    const agentResponses = sortedResults.map((result, index) => {
        const textContent = result.content
            .filter(content => content.type === "text")
            .map(content => content.text)
            .join("\n\n");
        
        return `== AGENT ${index + 1} RESPONSE ==\n${textContent}`;
    }).join("\n\n");
    
    return `Original task: ${originalTask}

I've assigned multiple agents to tackle this task. Each agent has analyzed the problem and provided their findings.

${agentResponses}

Based on all the information provided by these agents, synthesize a comprehensive and cohesive response...`;
}

function createTaskTool(baseTools: any[ ], model: any, subAgentConfigs: SubAgentConfig[ ]){
  return tool(
    async (args: { description: string; subagent_type: string }, config) => {
      // 具体工具内部实现，下文重点介绍
    },
    {
      name: "TaskTool",
      description: `Launch specialized SubAgents to autonomously handle complex multi-step tasks.

Available Agent types:
- general-purpose: General agent suitable forcomplex queries, file searches, and multi-step task execution (Tools: *)
- code-analyzer: Code analysis expert for code review, architecture analysis, performance optimization
- document-writer: Documentation expert for technical docs, user manuals, API documentation

Usage rules:
1. Use this tool when tasks are complexand require specialized handling
2. Each SubAgent invocation is independent and stateless  
3. Provide detailed task descriptions; SubAgents will complete autonomously
4. After SubAgent completion, summarize key information for the user

When to use SubAgents:
- Complex multi-step analysis tasks
- Tasks requiring specialized skills (code analysis, documentation)
- Large-scale file search and processing
- Independent tasks that can be processed in parallel`,
      schema: z.object({
        description: z.string().describe("Detailed task description for the SubAgent"),
        subagent_type: z.enum(["general-purpose", "code-analyzer", "document-writer"]).describe("SubAgent type to use")
      })
    }
  );
}

function createTaskTool(baseTools: any[ ], model: any, subAgentConfigs: SubAgentConfig[ ]){
  // 为每种类型创建专门的ReActAgent实例
  const agentInstances = new Map<string, any>();
  
  // 初始化预定义的SubAgent类型
  subAgentConfigs.forEach(config => {
    const filteredTools = config.allowedTools 
      ? baseTools.filter(tool => config.allowedTools.includes(tool.name))
      : baseTools.filter(tool => tool.name !== "TaskTool"); // 防止递归
      
    agentInstances.set(config.type, createReactAgent({
      llm: model,
      tools: filteredTools,
      systemMessage: config.systemPrompt
    }));
  });
  
  return tool(
    async (args: { description: string; subagent_type: string }, config) => {
      const { description, subagent_type } = args;
      
      // 获取指定类型的Agent
      const agent = agentInstances.get(subagent_type);
      if (!agent) {
        thrownew Error(`Unknown SubAgent type: ${subagent_type}`);
      }
      
      // 执行SubAgent
      try {
        console.log(`🤖 Launching SubAgent [${subagent_type}]: ${description}`);
        
        // 创建隔离的执行上下文
        const subAgentState = {
          messages: [{ role: "user", content: description }]
        };
        
        // 执行Agent并获取结果
        const result = await agent.invoke(subAgentState);
        
        // 提取最终响应
        const finalMessage = result.messages[result.messages.length - 1];
        const responseContent = finalMessage.content;
        
        console.log(`✅ SubAgent [${subagent_type}] completed`);
        
        // 返回格式化结果 - 模拟claude-code的结果格式
        return `SubAgent [${subagent_type}] execution completed:

Task: ${description}

Result:
${responseContent}

Note: This result was generated by a specialized SubAgent. Please summarize key information for the user as needed.`;
        
      } catch (error) {
        console.error(`❌ SubAgent [${subagent_type}] failed:`, error);
        return `SubAgent [${subagent_type}] execution failed: ${error.message}`;
      }
    },
    {
      name: "TaskTool",
      description: `提示词 略过`,
      schema: z.object({
        description: z.string().describe("Detailed task description for the SubAgent"),
        subagentType: z.enum(["general-purpose", "code-analyzer", "document-writer"]).describe("SubAgent type to use")
      })
    }
  );
}

// SubAgent配置定义const subAgentConfigs: SubAgentConfig[ ] = [  {    type: "general-purpose",    systemPrompt: `You are a general-purpose AI assistant specialized in handling complex multi-step tasks.- Excel at file searches, content analysis, and code understanding- Approach complex problems systematically andbreak them down- Always provide detailed and accurate analysis results`,    allowedTools: null  },  {    type: "code-analyzer",     systemPrompt: `You are a code analysis expert focused on:- Code quality assessment and improvement recommendations- Architecture design analysis and optimization- Performance bottleneck identification and solutions- Security vulnerability detection and fix suggestionsPlease provide specific, actionable technical recommendations`,    allowedTools: ["Read", "Edit", "Grep", "Glob", "LS"]  },  {    type: "document-writer",    systemPrompt: `You are a technical writing expert focused on:- Clear and accurate technical documentation- User-friendly operation guides  - Complete API documentation and examples- Structured project documentationEnsure readability and practicality of documentation`,    allowedTools: ["Read", "Write", "Edit"]  }];

// SubAgent配置定义
const subAgentConfigs: SubAgentConfig[ ] = [

  {
    type: "general-purpose",
    systemPrompt: `You are a general-purpose AI assistant specialized in handling complex multi-step tasks.
- Excel at file searches, content analysis, and code understanding
- Approach complex problems systematically andbreak them down
- Always provide detailed and accurate analysis results`,
    allowedTools: null
  },
  {
    type: "code-analyzer", 
    systemPrompt: `You are a code analysis expert focused on:
- Code quality assessment and improvement recommendations
- Architecture design analysis and optimization
- Performance bottleneck identification and solutions
- Security vulnerability detection and fix suggestions
Please provide specific, actionable technical recommendations`,
    allowedTools: ["Read", "Edit", "Grep", "Glob", "LS"]
  },
  {
    type: "document-writer",
    systemPrompt: `You are a technical writing expert focused on:
- Clear and accurate technical documentation
- User-friendly operation guides  
- Complete API documentation and examples
- Structured project documentation
Ensure readability and practicality of documentation`,
    allowedTools: ["Read", "Write", "Edit"]
  }
];

// 将之前的tools节点调整为safeConcurrencyTools和unsafeConcurrencyTools
const graph = new StateGraph(agentState)
    .addNode("llm", callModel)
    // 主要改动
    .addNode("safeConcurrencyTools", safeConcurrencyToolNode)
    .addNode("unsafeConcurrencyTools", unsafeConcurrencyToolNode)


const shouldContinue = (state: typeof agentState.State) => {
  const { messages } = state;
  const lastMessage = messages[messages.length - 1];
  if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
    if (isSafeConcurrencyTool(lastToolMessage)) {
      return"safeConcurrencyTools";
    } else {
      return"unsafeConcurrencyTools";
    }
      return"tools";
  }
  return END;
}

export interface TodoItem {
  id: string;
  name: string;
  desc: string;
  status: TaskStatus;
  startTime?: string;
  endTime?: string;
  error?: string;
}
const agentState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: safeMessagesStateReducer,
    default: () => [],
  }),
  todoList: Annotation<TodoItem[]>({
    reducer: (x, y) => y,
    default: () => [],
  }),
});

export function createTaskWriteTool(){
  const executor = (args, config) => {
    const state = getCurrentTaskInput() as (typeof MessagesAnnotation)['State'];
    const { todoLit } = args;
    
    // 一些任务处理加工逻辑
    
    returnnew Command({
      update: {
        todoLit: todoList,
        messages: state.messages.concat(responseMsgs),
      },
    });
  };

  return tool(executor, {
    name: TASK_TOOL_NAME_MAP.taskWrite,
    description: TODO_WRITE_PROMPT,
    schema: z.object({
      todoList: z
        .array(
          z.object({
            id: z.string().describe('任务唯一标识'),
            name: z.string().describe('任务名称'),
            desc: z.string().describe('任务具体描述'),
            status: z
              .nativeEnum(TaskStatus)
              .describe('任务状态：pending(待执行)、in_progress(执行中)、completed(已完成)、failed(失败)'),
            startTime: z.string().describe('任务开始时间').optional(),
            endTime: z.string().describe('任务结束时间').optional(),
            error: z.string().describe('失败原因(当状态为failed时必填)').optional(),
          }),
        )
        .describe('更新后的完整任务列表'),
    }),
  });
}

Use this tool to create and manage a structured task listfor your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
It also helps the user understand the progress of the task and overall progress of their requests.

## When to Use This Tool
Use this tool proactively in these scenarios:
1. Complex multi-step tasks - When a task requires3or more distinct steps or actions
2. Non-trivial andcomplex tasks - Tasks that require careful planning or multiple operations
3. User explicitly requests todo list - When the user directly asks you to use the todo list
4. User provides multiple tasks - When users provide a list of things to be done(numbered or comma-separated)
5. After receiving new instructions - Immediately capture user requirements as todos
6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
## When NOT to Use This Tool
Skip usingthis tool when:
1. There is only a single, straightforward task
2. The task is trivial and tracking it provides no organizational benefit
3. The task can be completed in less than 3 trivial steps
4. The task is purely conversational or informational
NOTE that you should not use this tool if there is only one trivial task to do. In thiscase you are better off just doing the task directly.
## Examples of When to Use the Todo List
<example>
User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
*Creates todo list with the following items:*
1. Create dark mode toggle component in Settings page
2. Add dark mode state management(context/store)
3. Implement CSS-in-JS styles for dark theme
4. Update existing components to support theme switching
5. Run tests and build process, addressing any failures or errors that occur
*Begins working on the first task*
<reasoning>
The assistant used the todo list because:
1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
2. The user explicitly requested tests and build be run afterward
3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
</reasoning>
</example>
<example>
User: Help me plan a comprehensive marketing campaign for our new product launch, including social media, email marketing, and press releases.
Assistant: I'll help you plan a comprehensive marketing campaign for your product launch. Let me create a todo list to organize all the components.
*Creates todo list with the following items:*
1. Define target audience and key messaging
2. Create social media content calendar and posting schedule
3. Design email marketing sequence and automation flows
4. Draft press release and identify media contacts
5. Set up tracking and analytics for campaign performance
6. Create visual assets and brand materials
7. Coordinate launch timeline and deliverables
*Begins working on the first task*
<reasoning>
The assistant used the todo list because:
1. Marketing campaign planning involves multiple distinct channels and activities
2. Each component requires careful coordination and planning
3. The systematic approach ensures all aspects of the launch are covered
4. Progress tracking helps maintain timeline and deliverables
</reasoning>
</example>
<example>
User: Help me rename the function getCwd to getCurrentWorkingDirectory across my project
Assistant: Let me first search through your codebase to find all occurrences of 'getCwd'.
*Uses search tools to locate all instances of getCwd in the codebase*
Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.
*Creates todo list with specific items for each file that needs updating*
<reasoning>
The assistant used the todo list because:
1. First, the assistant searched to understand the scope of the task
2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
3. The todo list helps ensure every instance is tracked and updated systematically
4. This approach prevents missing any occurrences and maintains consistency
</reasoning>
</example>
<example>
User: I need help organizing my home office: decluttering the desk, setting up a filing system, organizing digital files, and creating a daily workflow.
Assistant: I'll help you organize your home office systematically. Let me create a todo list to track each area of organization.
*Creates todo list with items like: 1) Sort and declutter desk items, 2) Set up physical filing system for documents, 3) Organize digital files and folders, 4) Create daily workflow and productivity systems, 5) Establish maintenance routines*
Let's start with decluttering your desk space to create a clean foundation for the other organizational systems.
<reasoning>
The assistant used the todo list because:
1. The user provided multiple distinct organizational tasks
2. Each area requires different approaches and careful planning
3. Home organization benefits from systematic, step-by-step completion
4. Progress tracking ensures all areas are addressed thoroughly
</reasoning>
</example>
## Examples of When NOT to Use the Todo List
<example>
User: How do I print 'Hello World' in Python?
Assistant: In Python, you can print "Hello World" with this simple code:
python
print("Hello World")
This will output the text "Hello World" to the console when executed.</assistant>
<reasoning>
The assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.
</reasoning>
</example>
<example>
User: What's the best way to water houseplants?
Assistant: The best way to water houseplants depends on the specific plant type, but here are some general guidelines:
- Check soil moisture by inserting your finger about 1-2 inches into the soil
- Water thoroughly when the top inch feels dry, allowing water to drain from the bottom
- Use room temperature water and water in the morning when possible
- Avoid overwatering, which is more harmful than underwatering for most plants
Different plants have different needs, so it's important to research your specific varieties for optimal care.
<reasoning>
The assistant did not use the todo list because this is an informational request with no actual tasks to complete. The user is simply asking for advice and explanation, notfor the assistant to perform multiple steps or activities.
</reasoning>
</example>
<example>
User: Can you add a comment to the calculateTotal function to explain what it does?
Assistant: Sure, let me add a comment to the calculateTotal function to explain what it does.
* Uses the Edit tool to add a comment to the calculateTotal function *
<reasoning>
The assistant did not use the todo list because this is a single, straightforward task confined to one location. Adding a comment doesn't require tracking multiple steps or systematic organization.
</reasoning>
</example>
<example>
User: What time is it in Tokyo right now?
Assistant: I'll check the current time in Tokyo for you.
*Searches for current time in Tokyo*
The current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time(JST) zone, which is UTC+9.
<reasoning>
The assistant did not use the todo list because this is a single information lookup with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary forthis straightforward request.
</reasoning>
</example>

更新当前会话的任务列表。主动使用此工具来跟踪进度和管理任务执行。

## 何时使用此工具
在以下场景中主动使用此工具：

1. 开始任务时 - 将任务标记为in_progress（可单个或批量，但每批最多5个）
2. 完成任务后 - 将任务标记为completed（可单个或批量完成）
3. 任务失败时 - 将任务标记为failed并包含错误详情
4. 需要更新任务进度或添加详情时

## 任务状态和管理

1. **任务状态**：使用这些状态来跟踪进度：
   - pending: 任务尚未开始
   - in_progress: 当前正在执行（同一时间最多5个任务）
   - completed: 任务成功完成
   - failed: 任务遇到错误

2. **任务管理规则**：
   - 实时更新任务状态
   - 支持批量执行：可以将多个相似简单任务同时标记为in_progress或completed
   - 批量限制：同一时间最多5个任务处于in_progress状态
   - 顺序执行：必须按任务列表顺序处理，不能跳跃
   - 任务失败时，将其标记为failed并包含错误详情

3. **任务完成要求**：
   - 只有在完全完成任务时才标记为completed
   - 如果遇到错误，将任务标记为failed并包含错误详情
   - 在以下情况下绝不要将任务标记为completed：
     - 实现不完整
     - 遇到未解决的错误
     - 找不到必要的文件或依赖项

如有疑问，请使用此工具。主动进行任务管理可以展现专业性并确保您完成所有要求。


对应的英文版

export function createTaskReadTool(){
  const executor = (args, config) => {
    const state = getCurrentTaskInput() as any;
    const currentTasks = state.taskList || [];

    const content = `请继续使用任务列表更新和读取功能来跟踪您的进度。当前任务列表: ${JSON.stringify(currentTasks)}`;

    returnnew ToolMessage({
      content,
      name: TASK_TOOL_NAME_MAP.taskRead,
      tool_call_id: config.toolCall.id,
    });
  };

  return tool(executor, {
    name: TASK_TOOL_NAME_MAP.taskRead,
    description:
      '读取当前会话的任务列表。主动且频繁地使用此工具，以确保您了解当前任务列表的状态。您应该尽可能多地使用此工具，特别是在开始工作、完成任务后或不确定下一步做什么时。',
    schema: z.object({}),
  });
}

const todoPrompt = `
You are an AI assistant with task management capabilities. Follow these guidelines:

1. **Task Management Rules**:
   - Use TodoRead to check current tasks before starting new work
   - Use TodoWrite to create tasks forcomplex requests (3+ steps)
   - Mark tasks as 'in_progress' when you start working on them
   - Mark tasks as 'completed' when you finish them
   - Break down complex requests into smaller, manageable tasks

2. **Task Organization**:
   - High priority: Urgent or blocking issues
   - Medium priority: Normal feature work
   - Low priority: Nice-to-have improvements

3. **Status Updates**:
   - Always update task status as you work
   - If you encounter issues, mark tasks as 'blocked'and explain why
   - Keep task descriptions clear and actionable

Current task context: ${state.taskList?.length || 0} tasks tracked
`
const systemPrompt = `
  // 原有提示词
  ${todoPrompt}
`

// VE函数：反向遍历Token监控机制
getCurrentUsage() {
    console.log('🔍 检查记忆使用情况...');
    
    let totalTokens = 0;
    // 聪明的地方：从最新消息开始找，因为usage信息通常在最近的消息里
    for (let i = this.messages.length - 1; i >= 0; i--) {
      const message = this.messages[i];
      if (message.usage) {
        totalTokens += this.calculateTotalTokens(message.usage);
        break; // 找到就停止，不浪费时间
      }
    }
    
    return {
      used: totalTokens,
      total: this.maxTokens,
      percentage: totalTokens / this.maxTokens
    };
}

const agentState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: messagesStateReducer,
    default: () => [],
  }),
  todoList: Annotation<TodoItem[]>({
    reducer: (x, y) => y,
    default: () => [],
  }),
  // 新增：压缩历史记录
  compressionHistory: {
    value: (x: CompressionRecord[ ], y: CompressionRecord[ ]) => [...(x || [ ]), ...(y || [ ])],
    default: () => [ ],
  },
});

const workflow = new StateGraph(newAgentState)
  // 新增：压缩检查节点
  .addNode("compressionNode", compressionNode)  
  // 原有节点
  .addNode("llm", callModel)

function compressionNode(state){
  // 1. 倒序查找统计token使用
   const currentTokens = getLatestTokenUsage(state.messages);
  
  // 2. token可用性检查，判断是否需要压缩
  if(!needsCompress(state)){
    return {}
  }
  
  // 3. 生成8段式压缩提示词
  const compressionPrompt = this.generateCompressPrompt();
  
  // 4. 执行压缩LLM调用
  const compressedSummary = await this.callCompressionModel(
    compressionPrompt, 
    state.messages
  );

  // 5. 压缩结果评估
  
  // 6. 删除历史消息（保留策略），并生成摘要及新上下文
  const summaryMsg = new AIMessage(compressedSummary);
    const messages = [...compressionResult.removeMessages, summaryMsg];
  return {
    messages,
  };
}

export function getLatestTokenUsage(messages: BaseMessage[]): number {
  // 倒序扫描，找到最新的usage信息
  for (let i = messages.length - 1; i >= 0; i--) {
    const msg = messages[i];
    if (isAIMessage(msg) && (msg as AIMessage)?.response_metadata?.usage) {
      const usage = msg.response_metadata.usage;
      return (usage.total_tokens || 0) + (usage.cache_creation_tokens || 0);
    }
  }
  // 如果没有usage信息，回退到估算
  return estimateTokens(messages);
}

Your task is to create a detailed summary of the conversation so far, 
paying close attention to the user's explicit requests and your previous actions.
This summary should be thorough in capturing technical details, code patterns, 
and architectural decisions that would be essential for continuing development 
work without losing context.

Before providing your final summary, wrap your analysis in <analysis> tags to 
organize your thoughts and ensure you've covered all necessary points.

Your summary should include the following sections:

1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable.
4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback.
5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
8. Current Work: Describe in detail precisely what was being worked on immediately before this summary request.
9. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing.


对应中文版为：
你的任务是创建到目前为止对话的详细摘要，密切关注用户的明确请求和你之前的行动。此摘要应彻底捕获技术细节、代码模式和架构决策，这些对于在不丢失上下文的情况下继续开发工作至关重要。
在提供最终摘要之前，将你的分析包装在<analysis>标签中，以组织你的思考并确保你涵盖了所有必要的要点。

你的摘要应包括以下部分 
**1. 主要请求和意图**：详细捕获用户的所有明确请求和意图
**2. 关键技术概念**：列出讨论的所有重要技术概念、技术和框架
**3. 文件和代码段**：枚举检查、修改或创建的特定文件和代码段。特别注意最近的消息，并在适用时包含完整的代码片段
**4. 错误和修复**：列出你遇到的所有错误以及修复方法。特别注意特定的用户反馈
**5. 问题解决**：记录已解决的问题和任何正在进行的故障排除工作
**6. 所有用户消息**：列出所有非工具结果的用户消息。这些对于理解用户的反馈和变化的意图至关重要
**7. 待处理任务**：概述你明确被要求处理的任何待处理任务
**8. 当前工作**：详细描述在此摘要请求之前正在进行的确切工作
**9. 可选的下一步**：列出与你最近正在做的工作相关的下一步

const config = {
  configurable: { thread_id: this.sessionId },
  streamMode: ['values', 'messages', 'updates'] as any,
  version: 'v2' as const,
  // 传入fetch请求的abortSignal, 若前端中断, 会透传到图中。
  signal: abortSignal,
}
const stream = agent.streamEvents({messages: [inputMessage]}, config);

const response = await fetch(api, {
  method: 'POST',
  body: JSON.stringify({}),
  headers: {
    'Content-Type': 'application/json',
  },
  signal: abortController.signal,
})