@axiom-lattice/core 2.0.3 → 2.1.0

package/dist/index.mjs

@@ -601,245 +601,6 @@ registerToolLattice(
   }
 );
 
-// src/tool_lattice/write_todos/index.ts
-import z3 from "zod";
-import { ToolMessage } from "@langchain/core/messages";
-import { Command } from "@langchain/langgraph";
-var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for 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:
-
-Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-User explicitly requests todo list - When the user directly asks you to use the todo list
-User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-After receiving new instructions - Immediately capture user requirements as todos
-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
-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 using this tool when:
-
-There is only a single, straightforward task
-The task is trivial and tracking it provides no organizational benefit
-The task can be completed in less than 3 trivial steps
-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 this case you are better off just doing the task directly.`;
-registerToolLattice(
-  "write_todos",
-  {
-    name: "write_todos",
-    description: WRITE_TODOS_DESCRIPTION,
-    needUserApprove: false,
-    schema: z3.object({
-      todos: z3.array(
-        z3.object({
-          content: z3.string().describe("Content of the todo item"),
-          status: z3.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
-        })
-      ).describe("List of todo items to update")
-    })
-  },
-  ((input, config) => {
-    return new Command({
-      update: {
-        todos: input.todos,
-        messages: [
-          new ToolMessage({
-            content: genUIMarkdown("todo_list", input.todos),
-            tool_call_id: config.toolCall?.id
-          })
-        ]
-      }
-    });
-  })
-);
-
-// src/tool_lattice/read_file/index.ts
-import z4 from "zod";
-import { getCurrentTaskInput } from "@langchain/langgraph";
-var READ_FILE_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool. Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-Usage:
-
-The file_path parameter must be an absolute path, not a relative path
-By default, it reads up to 2000 lines starting from the beginning of the file
-You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-Any lines longer than 2000 characters will be truncated
-Results are returned using cat -n format, with line numbers starting at 1
-You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
-If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;
-registerToolLattice(
-  "read_file",
-  {
-    name: "read_file",
-    description: READ_FILE_DESCRIPTION,
-    needUserApprove: false,
-    schema: z4.object({
-      file_path: z4.string().describe("Absolute path to the file to read"),
-      offset: z4.number().optional().default(0).describe("Line offset to start reading from"),
-      limit: z4.number().optional().default(2e3).describe("Maximum number of lines to read")
-    })
-  },
-  ((input) => {
-    const state = getCurrentTaskInput();
-    const mockFilesystem = state.files || {};
-    const { file_path, offset = 0, limit = 2e3 } = input;
-    if (!(file_path in mockFilesystem)) {
-      return `Error: File '${file_path}' not found`;
-    }
-    const content = mockFilesystem[file_path];
-    if (!content || content.trim() === "") {
-      return "System reminder: File exists but has empty contents";
-    }
-    const lines = content.split("\n");
-    const startIdx = offset;
-    const endIdx = Math.min(startIdx + limit, lines.length);
-    if (startIdx >= lines.length) {
-      return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
-    }
-    const resultLines = [];
-    for (let i = startIdx; i < endIdx; i++) {
-      let lineContent = lines[i];
-      if (lineContent.length > 2e3) {
-        lineContent = lineContent.substring(0, 2e3);
-      }
-      const lineNumber = i + 1;
-      resultLines.push(`${lineNumber.toString().padStart(6)}	${lineContent}`);
-    }
-    return resultLines.join("\n");
-  })
-);
-
-// src/tool_lattice/write_file/index.ts
-import z5 from "zod";
-import { ToolMessage as ToolMessage2 } from "@langchain/core/messages";
-import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2 } from "@langchain/langgraph";
-registerToolLattice(
-  "write_file",
-  {
-    name: "write_file",
-    description: "Write content to a file in the mock filesystem",
-    needUserApprove: false,
-    schema: z5.object({
-      file_path: z5.string().describe("Absolute path to the file to write"),
-      content: z5.string().describe("Content to write to the file")
-    })
-  },
-  ((input, config) => {
-    const state = getCurrentTaskInput2();
-    const files = { ...state.files || {} };
-    files[input.file_path] = input.content;
-    return new Command2({
-      update: {
-        files,
-        messages: [
-          new ToolMessage2({
-            content: `Updated file ${input.file_path}`,
-            tool_call_id: config.toolCall?.id
-          })
-        ]
-      }
-    });
-  })
-);
-
-// src/tool_lattice/edit_file/index.ts
-import z6 from "zod";
-import { ToolMessage as ToolMessage3 } from "@langchain/core/messages";
-import { Command as Command3, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
-var EDIT_FILE_DESCRIPTION = `Performs exact string replacements in files.
-Usage:
-
-You must use your Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
-When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
-ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
-Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string.
-Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
-registerToolLattice(
-  "edit_file",
-  {
-    name: "edit_file",
-    description: EDIT_FILE_DESCRIPTION,
-    needUserApprove: false,
-    schema: z6.object({
-      file_path: z6.string().describe("Absolute path to the file to edit"),
-      old_string: z6.string().describe("String to be replaced (must match exactly)"),
-      new_string: z6.string().describe("String to replace with"),
-      replace_all: z6.boolean().optional().default(false).describe("Whether to replace all occurrences")
-    })
-  },
-  ((input, config) => {
-    const state = getCurrentTaskInput3();
-    const mockFilesystem = { ...state.files || {} };
-    const { file_path, old_string, new_string, replace_all = false } = input;
-    if (!(file_path in mockFilesystem)) {
-      return `Error: File '${file_path}' not found`;
-    }
-    const content = mockFilesystem[file_path];
-    if (!content.includes(old_string)) {
-      return `Error: String not found in file: '${old_string}'`;
-    }
-    if (!replace_all) {
-      const escapedOldString = old_string.replace(
-        /[.*+?^${}()|[\]\\]/g,
-        "\\$&"
-      );
-      const occurrences = (content.match(new RegExp(escapedOldString, "g")) || []).length;
-      if (occurrences > 1) {
-        return `Error: String '${old_string}' appears ${occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context.`;
-      } else if (occurrences === 0) {
-        return `Error: String not found in file: '${old_string}'`;
-      }
-    }
-    let newContent;
-    if (replace_all) {
-      const escapedOldString = old_string.replace(
-        /[.*+?^${}()|[\]\\]/g,
-        "\\$&"
-      );
-      newContent = content.replace(
-        new RegExp(escapedOldString, "g"),
-        new_string
-      );
-    } else {
-      newContent = content.replace(old_string, new_string);
-    }
-    mockFilesystem[file_path] = newContent;
-    return new Command3({
-      update: {
-        files: mockFilesystem,
-        messages: [
-          new ToolMessage3({
-            content: `Updated file ${file_path}`,
-            tool_call_id: config.toolCall?.id
-          })
-        ]
-      }
-    });
-  })
-);
-
-// src/tool_lattice/ls/index.ts
-import z7 from "zod";
-import { getCurrentTaskInput as getCurrentTaskInput4 } from "@langchain/langgraph";
-registerToolLattice(
-  "ls",
-  {
-    name: "ls",
-    description: "List all files in the mock filesystem",
-    needUserApprove: false,
-    schema: z7.object({})
-  },
-  (() => {
-    const state = getCurrentTaskInput4();
-    const files = state.files || {};
-    return Object.keys(files);
-  })
-);
-
 // src/agent_lattice/types.ts
 import {
   AgentType,
@@ -856,9 +617,6 @@ import {
   getSubAgentsFromConfig
 } from "@axiom-lattice/protocols";
 
-// src/agent_lattice/builders/ReActAgentGraphBuilder.ts
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
-
 // src/memory_lattice/DefaultMemorySaver.ts
 import { MemorySaver } from "@langchain/langgraph";
 
@@ -942,17 +700,12 @@ registerCheckpointSaver("default", memory);
 // src/agent_lattice/builders/state.ts
 import "@langchain/langgraph/zod";
 import { MessagesZodState } from "@langchain/langgraph";
-import { z as z8 } from "zod";
-var ReActAgentState = MessagesZodState.extend({
-  files: z8.object({
-    final_output: z8.record(z8.any())
-  })
-});
 var createReactAgentSchema = (schema) => {
   return schema ? MessagesZodState.extend(schema.shape) : void 0;
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
+import { createAgent } from "langchain";
 var ReActAgentGraphBuilder = class {
   /**
    * 构建ReAct Agent Graph
@@ -966,1230 +719,1490 @@ var ReActAgentGraphBuilder = class {
       const tool5 = getToolClient(t.key);
       return tool5;
     }).filter((tool5) => tool5 !== void 0);
-    const stateSchema = createReactAgentSchema(params.stateSchema);
-    return createReactAgent({
-      llm: params.model,
+    const stateSchema2 = createReactAgentSchema(params.stateSchema);
+    return createAgent({
+      model: params.model,
       tools,
-      prompt: params.prompt,
+      systemPrompt: params.prompt,
       name: agentLattice.config.name,
       checkpointer: getCheckpointSaver("default"),
-      stateSchema
+      stateSchema: stateSchema2
     });
   }
 };
 
-// src/deep_agent/subAgent.ts
-import { tool as tool2 } from "@langchain/core/tools";
-import { ToolMessage as ToolMessage4 } from "@langchain/core/messages";
+// src/deep_agent_new/agent.ts
 import {
-  Command as Command4,
-  getCurrentTaskInput as getCurrentTaskInput5,
-  GraphInterrupt
-} from "@langchain/langgraph";
-import { z as z9 } from "zod";
-
-// src/deep_agent/prompts.ts
-var WRITE_TODOS_DESCRIPTION2 = `Use this tool to create and manage a structured task list for 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:
-
-Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-User explicitly requests todo list - When the user directly asks you to use the todo list
-User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-After receiving new instructions - Immediately capture user requirements as todos
-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
-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 using this tool when:
-
-There is only a single, straightforward task
-The task is trivial and tracking it provides no organizational benefit
-The task can be completed in less than 3 trivial steps
-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 this case 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.
-<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, not for 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 for this straightforward request.
-</reasoning>
-</example>
-Task States and Management
-Task States: Use these states to track progress:
-
-pending: Task not yet started
-in_progress: Currently working on (limit to ONE task at a time)
-completed: Task finished successfully
-Task Management:
-
-Update task status in real-time as you work
-Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-Only have ONE task in_progress at any time
-Complete current tasks before starting new ones
-Remove tasks that are no longer relevant from the list entirely
-Task Completion Requirements:
-
-ONLY mark a task as completed when you have FULLY accomplished it
-If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-When blocked, create a new task describing what needs to be resolved
-Never mark a task as completed if:
-There are unresolved issues or errors
-Work is partial or incomplete
-You encountered blockers that prevent completion
-You couldn't find necessary resources or dependencies
-Quality standards haven't been met
-Task Breakdown:
-
-Create specific, actionable items
-Break complex tasks into smaller, manageable steps
-Use clear, descriptive task names
-When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.`;
-var TASK_DESCRIPTION_PREFIX = `Launch a new agent to handle complex, multi-step tasks autonomously.
-
-Available agent types and the tools they have access to:
-
-general-purpose: General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
-{other_agents}
-`;
-var TASK_DESCRIPTION_SUFFIX = `When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
-
-When to use the Agent tool:
-
-When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
-When NOT to use the Agent tool:
-
-If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
-If you are searching for a specific term or definition within a known location, use the Glob tool instead, to find the match more quickly
-If you are searching for content within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
-Other tasks that are not related to the agent descriptions above
-Usage notes:
-
-Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-The agent's outputs should generally be trusted
-Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
-If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
-Example usage:
-
-<example_agent_descriptions>
-"content-reviewer": use this agent after you are done creating significant content or documents
-"greeting-responder": use this agent when to respond to user greetings with a friendly joke
-"research-analyst": use this agent to conduct thorough research on complex topics
-</example_agent_description>
+  createAgent as createAgent3,
+  humanInTheLoopMiddleware as humanInTheLoopMiddleware2,
+  anthropicPromptCachingMiddleware,
+  summarizationMiddleware
+} from "langchain";
+
+// src/deep_agent_new/middleware/fs.ts
+import { createMiddleware, tool as tool2, ToolMessage } from "langchain";
+import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
+import { z as z3 } from "zod/v3";
+import { withLangGraph } from "@langchain/langgraph/zod";
 
-<example>
-user: "Please write a function that checks if a number is prime"
-assistant: Sure let me write a function that checks if a number is prime
-assistant: First let me use the Write tool to write a function that checks if a number is prime
-assistant: I'm going to use the Write tool to write the following code:
-<code>
-function isPrime(n) {
-  if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
-    if (n % i === 0) return false
-  }
-  return true
+// src/deep_agent_new/backends/utils.ts
+import micromatch from "micromatch";
+import { basename } from "path";
+var EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents";
+var MAX_LINE_LENGTH = 1e4;
+var LINE_NUMBER_WIDTH = 6;
+function sanitizeToolCallId(toolCallId) {
+  return toolCallId.replace(/\./g, "_").replace(/\//g, "_").replace(/\\/g, "_");
 }
-</code>
-<commentary>
-Since significant content was created and the task was completed, now use the content-reviewer agent to review the work
-</commentary>
-assistant: Now let me use the content-reviewer agent to review the code
-assistant: Uses the Task tool to launch with the content-reviewer agent
-</example>
-<example>
-user: "Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?"
-<commentary>
-This is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis
-</commentary>
-assistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.
-assistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take
-</example>
-<example>
-user: "Hello"
-<commentary>
-Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
-</commentary>
-assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
-</example>`;
-var EDIT_DESCRIPTION = `Performs exact string replacements in files.
-Usage:
-
-You must use your Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
-When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
-ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
-Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string.
-Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
-var TOOL_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool. Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-Usage:
-
-The file_path parameter must be an absolute path, not a relative path
-By default, it reads up to 2000 lines starting from the beginning of the file
-You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-Any lines longer than 2000 characters will be truncated
-Results are returned using cat -n format, with line numbers starting at 1
-You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
-If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;
-
-// src/deep_agent/subAgent.ts
-import {
-  getToolsFromConfig as getToolsFromConfig2,
-  hasTools as hasTools2
-} from "@axiom-lattice/protocols";
-var BUILTIN_TOOL_NAMES = [
-  "write_todos",
-  "read_file",
-  "write_file",
-  "edit_file",
-  "ls"
-];
-function getBuiltinTools() {
-  const tools = {};
-  for (const name of BUILTIN_TOOL_NAMES) {
-    try {
-      tools[name] = getToolClient(name);
-    } catch {
+function formatContentWithLineNumbers(content, startLine = 1) {
+  let lines;
+  if (typeof content === "string") {
+    lines = content.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+      lines = lines.slice(0, -1);
     }
-  }
-  return tools;
-}
-function createTaskTool(inputs) {
-  const {
-    subagents,
-    tools = {},
-    model = getModelLattice("default")?.client,
-    stateSchema,
-    postModelHook
-  } = inputs;
-  if (!model) {
-    throw new Error("Model not found");
-  }
-  const allTools = { ...getBuiltinTools(), ...tools };
-  const agentsMap = /* @__PURE__ */ new Map();
-  for (const subagent of subagents) {
-    let reactAgent;
-    const agentLattice = getAgentLattice(subagent.key);
-    if (agentLattice) {
-      reactAgent = agentLattice.client;
+  } else {
+    lines = content;
+  }
+  const resultLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + startLine;
+    if (line.length <= MAX_LINE_LENGTH) {
+      resultLines.push(
+        `${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}	${line}`
+      );
     } else {
-      const subagentTools = [];
-      if (hasTools2(subagent)) {
-        for (const toolName of getToolsFromConfig2(subagent)) {
-          const resolvedTool = allTools[toolName];
-          if (resolvedTool) {
-            subagentTools.push(resolvedTool);
-          } else {
-            console.warn(
-              `Warning: Tool '${toolName}' not found for agent '${subagent.name}'`
-            );
-          }
+      const numChunks = Math.ceil(line.length / MAX_LINE_LENGTH);
+      for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+        const start = chunkIdx * MAX_LINE_LENGTH;
+        const end = Math.min(start + MAX_LINE_LENGTH, line.length);
+        const chunk = line.substring(start, end);
+        if (chunkIdx === 0) {
+          resultLines.push(
+            `${lineNum.toString().padStart(LINE_NUMBER_WIDTH)}	${chunk}`
+          );
+        } else {
+          const continuationMarker = `${lineNum}.${chunkIdx}`;
+          resultLines.push(
+            `${continuationMarker.padStart(LINE_NUMBER_WIDTH)}	${chunk}`
+          );
         }
-      } else {
-        subagentTools.push(...Object.values(allTools));
       }
-      reactAgent = createAgentClientFromAgentLattice({ config: subagent });
     }
-    agentsMap.set(subagent.name, reactAgent);
   }
-  return tool2(
-    async (input, config) => {
-      const { description, subagent_type } = input;
-      const reactAgent = agentsMap.get(subagent_type);
-      if (!reactAgent) {
-        return `Error: Agent '${subagent_type}' not found. Available agents: ${Array.from(
-          agentsMap.keys()
-        ).join(", ")}`;
-      }
-      try {
-        const currentState = getCurrentTaskInput5();
-        const modifiedState = {
-          ...currentState,
-          messages: [
-            {
-              role: "user",
-              content: description
-            }
-          ]
-        };
-        const result = await reactAgent.invoke(modifiedState, config);
-        return new Command4({
-          update: {
-            files: result.files || {},
-            messages: [
-              new ToolMessage4({
-                content: result.messages?.slice(-1)[0]?.content || "Task completed",
-                tool_call_id: config.toolCall?.id
-              })
-            ]
-          }
-        });
-      } catch (error) {
-        if (error instanceof GraphInterrupt) {
-          throw error;
-        }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return new Command4({
-          update: {
-            messages: [
-              new ToolMessage4({
-                content: `Error executing task '${description}' with agent '${subagent_type}': ${errorMessage}`,
-                tool_call_id: config.toolCall?.id
-              })
-            ]
-          }
-        });
-      }
-    },
-    {
-      name: "task",
-      description: TASK_DESCRIPTION_PREFIX.replace(
-        "{other_agents}",
-        subagents.map((a) => `- ${a.name}: ${a.description}`).join("\n")
-      ) + TASK_DESCRIPTION_SUFFIX,
-      schema: z9.object({
-        description: z9.string().describe("The task to execute with the selected agent"),
-        subagent_type: z9.string().describe(
-          `Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`
-        )
-      })
-    }
-  );
+  return resultLines.join("\n");
 }
-
-// src/deep_agent/tools.ts
-import { tool as tool3 } from "@langchain/core/tools";
-import { ToolMessage as ToolMessage5 } from "@langchain/core/messages";
-import { Command as Command5, getCurrentTaskInput as getCurrentTaskInput6 } from "@langchain/langgraph";
-import { z as z10 } from "zod";
-var writeTodos = tool3(
-  (input, config) => {
-    return new Command5({
-      update: {
-        todos: input.todos,
-        messages: [
-          new ToolMessage5({
-            content: genUIMarkdown("todo_list", input.todos),
-            tool_call_id: config.toolCall?.id
-          })
-        ]
-      }
-    });
-  },
-  {
-    name: "write_todos",
-    description: WRITE_TODOS_DESCRIPTION2,
-    schema: z10.object({
-      todos: z10.array(
-        z10.object({
-          content: z10.string().describe("Content of the todo item"),
-          status: z10.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
-        })
-      ).describe("List of todo items to update")
-    })
+function checkEmptyContent(content) {
+  if (!content || content.trim() === "") {
+    return EMPTY_CONTENT_WARNING;
   }
-);
-var ls = tool3(
-  () => {
-    const state = getCurrentTaskInput6();
-    const files = state.files || {};
-    return Object.keys(files);
-  },
-  {
-    name: "ls",
-    description: "List all files in the mock filesystem",
-    schema: z10.object({})
+  return null;
+}
+function fileDataToString(fileData) {
+  return fileData.content.join("\n");
+}
+function createFileData(content, createdAt) {
+  const lines = typeof content === "string" ? content.split("\n") : content;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    content: lines,
+    created_at: createdAt || now,
+    modified_at: now
+  };
+}
+function updateFileData(fileData, content) {
+  const lines = typeof content === "string" ? content.split("\n") : content;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    content: lines,
+    created_at: fileData.created_at,
+    modified_at: now
+  };
+}
+function formatReadResponse(fileData, offset, limit) {
+  const content = fileDataToString(fileData);
+  const emptyMsg = checkEmptyContent(content);
+  if (emptyMsg) {
+    return emptyMsg;
+  }
+  const lines = content.split("\n");
+  const startIdx = offset;
+  const endIdx = Math.min(startIdx + limit, lines.length);
+  if (startIdx >= lines.length) {
+    return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
+  }
+  const selectedLines = lines.slice(startIdx, endIdx);
+  return formatContentWithLineNumbers(selectedLines, startIdx + 1);
+}
+function performStringReplacement(content, oldString, newString, replaceAll) {
+  const occurrences = content.split(oldString).length - 1;
+  if (occurrences === 0) {
+    return `Error: String not found in file: '${oldString}'`;
   }
-);
-var readFile = tool3(
-  (input) => {
-    const state = getCurrentTaskInput6();
-    const mockFilesystem = state.files || {};
-    const { file_path, offset = 0, limit = 2e3 } = input;
-    if (!(file_path in mockFilesystem)) {
-      return `Error: File '${file_path}' not found`;
-    }
-    const content = mockFilesystem[file_path];
-    if (!content || content.trim() === "") {
-      return "System reminder: File exists but has empty contents";
-    }
-    const lines = content.split("\n");
-    const startIdx = offset;
-    const endIdx = Math.min(startIdx + limit, lines.length);
-    if (startIdx >= lines.length) {
-      return `Error: Line offset ${offset} exceeds file length (${lines.length} lines)`;
-    }
-    const resultLines = [];
-    for (let i = startIdx; i < endIdx; i++) {
-      let lineContent = lines[i];
-      if (lineContent.length > 2e3) {
-        lineContent = lineContent.substring(0, 2e3);
+  if (occurrences > 1 && !replaceAll) {
+    return `Error: String '${oldString}' appears ${occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context.`;
+  }
+  const newContent = content.split(oldString).join(newString);
+  return [newContent, occurrences];
+}
+function validatePath(path) {
+  const pathStr = path || "/";
+  if (!pathStr || pathStr.trim() === "") {
+    throw new Error("Path cannot be empty");
+  }
+  let normalized = pathStr.startsWith("/") ? pathStr : "/" + pathStr;
+  if (!normalized.endsWith("/")) {
+    normalized += "/";
+  }
+  return normalized;
+}
+function globSearchFiles(files, pattern, path = "/") {
+  let normalizedPath;
+  try {
+    normalizedPath = validatePath(path);
+  } catch {
+    return "No files found";
+  }
+  const filtered = Object.fromEntries(
+    Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath))
+  );
+  const effectivePattern = pattern;
+  const matches = [];
+  for (const [filePath, fileData] of Object.entries(filtered)) {
+    let relative = filePath.substring(normalizedPath.length);
+    if (relative.startsWith("/")) {
+      relative = relative.substring(1);
+    }
+    if (!relative) {
+      const parts = filePath.split("/");
+      relative = parts[parts.length - 1] || "";
+    }
+    if (micromatch.isMatch(relative, effectivePattern, {
+      dot: true,
+      nobrace: false
+    })) {
+      matches.push([filePath, fileData.modified_at]);
+    }
+  }
+  matches.sort((a, b) => b[1].localeCompare(a[1]));
+  if (matches.length === 0) {
+    return "No files found";
+  }
+  return matches.map(([fp]) => fp).join("\n");
+}
+function grepMatchesFromFiles(files, pattern, path = null, glob = null) {
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (e) {
+    return `Invalid regex pattern: ${e.message}`;
+  }
+  let normalizedPath;
+  try {
+    normalizedPath = validatePath(path);
+  } catch {
+    return [];
+  }
+  let filtered = Object.fromEntries(
+    Object.entries(files).filter(([fp]) => fp.startsWith(normalizedPath))
+  );
+  if (glob) {
+    filtered = Object.fromEntries(
+      Object.entries(filtered).filter(
+        ([fp]) => micromatch.isMatch(basename(fp), glob, { dot: true, nobrace: false })
+      )
+    );
+  }
+  const matches = [];
+  for (const [filePath, fileData] of Object.entries(filtered)) {
+    for (let i = 0; i < fileData.content.length; i++) {
+      const line = fileData.content[i];
+      const lineNum = i + 1;
+      if (regex.test(line)) {
+        matches.push({ path: filePath, line: lineNum, text: line });
       }
-      const lineNumber = i + 1;
-      resultLines.push(`${lineNumber.toString().padStart(6)}	${lineContent}`);
     }
-    return resultLines.join("\n");
-  },
-  {
-    name: "read_file",
-    description: TOOL_DESCRIPTION,
-    schema: z10.object({
-      file_path: z10.string().describe("Absolute path to the file to read"),
-      offset: z10.number().optional().default(0).describe("Line offset to start reading from"),
-      limit: z10.number().optional().default(2e3).describe("Maximum number of lines to read")
-    })
   }
-);
-var writeFile = tool3(
-  (input, config) => {
-    const state = getCurrentTaskInput6();
-    const files = { ...state.files || {} };
-    files[input.file_path] = input.content;
-    return new Command5({
-      update: {
-        files,
-        messages: [
-          new ToolMessage5({
-            content: `Updated file ${input.file_path}`,
-            tool_call_id: config.toolCall?.id
-          })
-        ]
+  return matches;
+}
+
+// src/deep_agent_new/backends/state.ts
+var StateBackend = class {
+  constructor(stateAndStore) {
+    this.stateAndStore = stateAndStore;
+  }
+  /**
+   * Get files from current state.
+   */
+  getFiles() {
+    return this.stateAndStore.state.files || {};
+  }
+  /**
+   * List files and directories in the specified directory (non-recursive).
+   *
+   * @param path - Absolute path to directory
+   * @returns List of FileInfo objects for files and directories directly in the directory.
+   *          Directories have a trailing / in their path and is_dir=true.
+   */
+  lsInfo(path) {
+    const files = this.getFiles();
+    const infos = [];
+    const subdirs = /* @__PURE__ */ new Set();
+    const normalizedPath = path.endsWith("/") ? path : path + "/";
+    for (const [k, fd] of Object.entries(files)) {
+      if (!k.startsWith(normalizedPath)) {
+        continue;
       }
-    });
-  },
-  {
-    name: "write_file",
-    description: "Write content to a file in the mock filesystem",
-    schema: z10.object({
-      file_path: z10.string().describe("Absolute path to the file to write"),
-      content: z10.string().describe("Content to write to the file")
-    })
+      const relative = k.substring(normalizedPath.length);
+      if (relative.includes("/")) {
+        const subdirName = relative.split("/")[0];
+        subdirs.add(normalizedPath + subdirName + "/");
+        continue;
+      }
+      const size = fd.content.join("\n").length;
+      infos.push({
+        path: k,
+        is_dir: false,
+        size,
+        modified_at: fd.modified_at
+      });
+    }
+    for (const subdir of Array.from(subdirs).sort()) {
+      infos.push({
+        path: subdir,
+        is_dir: true,
+        size: 0,
+        modified_at: ""
+      });
+    }
+    infos.sort((a, b) => a.path.localeCompare(b.path));
+    return infos;
   }
-);
-var editFile = tool3(
-  (input, config) => {
-    const state = getCurrentTaskInput6();
-    const mockFilesystem = { ...state.files || {} };
-    const { file_path, old_string, new_string, replace_all = false } = input;
-    if (!(file_path in mockFilesystem)) {
-      return `Error: File '${file_path}' not found`;
-    }
-    const content = mockFilesystem[file_path];
-    if (!content.includes(old_string)) {
-      return `Error: String not found in file: '${old_string}'`;
-    }
-    if (!replace_all) {
-      const escapedOldString = old_string.replace(
-        /[.*+?^${}()|[\]\\]/g,
-        "\\$&"
-      );
-      const occurrences = (content.match(new RegExp(escapedOldString, "g")) || []).length;
-      if (occurrences > 1) {
-        return `Error: String '${old_string}' appears ${occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context.`;
-      } else if (occurrences === 0) {
-        return `Error: String not found in file: '${old_string}'`;
+  /**
+   * Read file content with line numbers.
+   *
+   * @param filePath - Absolute file path
+   * @param offset - Line offset to start reading from (0-indexed)
+   * @param limit - Maximum number of lines to read
+   * @returns Formatted file content with line numbers, or error message
+   */
+  read(filePath, offset = 0, limit = 2e3) {
+    const files = this.getFiles();
+    const fileData = files[filePath];
+    if (!fileData) {
+      return `Error: File '${filePath}' not found`;
+    }
+    return formatReadResponse(fileData, offset, limit);
+  }
+  /**
+   * Read file content as raw FileData.
+   *
+   * @param filePath - Absolute file path
+   * @returns Raw file content as FileData
+   */
+  readRaw(filePath) {
+    const files = this.getFiles();
+    const fileData = files[filePath];
+    if (!fileData) throw new Error(`File '${filePath}' not found`);
+    return fileData;
+  }
+  /**
+   * Create a new file with content.
+   * Returns WriteResult with filesUpdate to update LangGraph state.
+   */
+  write(filePath, content) {
+    const files = this.getFiles();
+    if (filePath in files) {
+      return {
+        error: `Cannot write to ${filePath} because it already exists. Read and then make an edit, or write to a new path.`
+      };
+    }
+    const newFileData = createFileData(content);
+    return {
+      path: filePath,
+      filesUpdate: { [filePath]: newFileData }
+    };
+  }
+  /**
+   * Edit a file by replacing string occurrences.
+   * Returns EditResult with filesUpdate and occurrences.
+   */
+  edit(filePath, oldString, newString, replaceAll = false) {
+    const files = this.getFiles();
+    const fileData = files[filePath];
+    if (!fileData) {
+      return { error: `Error: File '${filePath}' not found` };
+    }
+    const content = fileDataToString(fileData);
+    const result = performStringReplacement(
+      content,
+      oldString,
+      newString,
+      replaceAll
+    );
+    if (typeof result === "string") {
+      return { error: result };
+    }
+    const [newContent, occurrences] = result;
+    const newFileData = updateFileData(fileData, newContent);
+    return {
+      path: filePath,
+      filesUpdate: { [filePath]: newFileData },
+      occurrences
+    };
+  }
+  /**
+   * Structured search results or error string for invalid input.
+   */
+  grepRaw(pattern, path = "/", glob = null) {
+    const files = this.getFiles();
+    return grepMatchesFromFiles(files, pattern, path, glob);
+  }
+  /**
+   * Structured glob matching returning FileInfo objects.
+   */
+  globInfo(pattern, path = "/") {
+    const files = this.getFiles();
+    const result = globSearchFiles(files, pattern, path);
+    if (result === "No files found") {
+      return [];
+    }
+    const paths = result.split("\n");
+    const infos = [];
+    for (const p of paths) {
+      const fd = files[p];
+      const size = fd ? fd.content.join("\n").length : 0;
+      infos.push({
+        path: p,
+        is_dir: false,
+        size,
+        modified_at: fd?.modified_at || ""
+      });
+    }
+    return infos;
+  }
+};
+
+// src/deep_agent_new/middleware/fs.ts
+var FileDataSchema = z3.object({
+  content: z3.array(z3.string()),
+  created_at: z3.string(),
+  modified_at: z3.string()
+});
+function fileDataReducer(left, right) {
+  if (left === void 0) {
+    const result2 = {};
+    for (const [key, value] of Object.entries(right)) {
+      if (value !== null) {
+        result2[key] = value;
       }
     }
-    let newContent;
-    if (replace_all) {
-      const escapedOldString = old_string.replace(
-        /[.*+?^${}()|[\]\\]/g,
-        "\\$&"
-      );
-      newContent = content.replace(
-        new RegExp(escapedOldString, "g"),
-        new_string
-      );
+    return result2;
+  }
+  const result = { ...left };
+  for (const [key, value] of Object.entries(right)) {
+    if (value === null) {
+      delete result[key];
     } else {
-      newContent = content.replace(old_string, new_string);
+      result[key] = value;
     }
-    mockFilesystem[file_path] = newContent;
-    return new Command5({
-      update: {
-        files: mockFilesystem,
-        messages: [
-          new ToolMessage5({
-            content: `Updated file ${file_path}`,
-            tool_call_id: config.toolCall?.id
-          })
-        ]
+  }
+  return result;
+}
+var FilesystemStateSchema = z3.object({
+  files: withLangGraph(
+    z3.record(z3.string(), FileDataSchema).default({}),
+    {
+      reducer: {
+        fn: fileDataReducer,
+        schema: z3.record(z3.string(), FileDataSchema.nullable())
       }
-    });
-  },
-  {
-    name: "edit_file",
-    description: EDIT_DESCRIPTION,
-    schema: z10.object({
-      file_path: z10.string().describe("Absolute path to the file to edit"),
-      old_string: z10.string().describe("String to be replaced (must match exactly)"),
-      new_string: z10.string().describe("String to replace with"),
-      replace_all: z10.boolean().optional().default(false).describe("Whether to replace all occurrences")
-    })
+    }
+  )
+});
+function getBackend(backend, stateAndStore) {
+  if (typeof backend === "function") {
+    return backend(stateAndStore);
   }
-);
+  return backend;
+}
+var FILESYSTEM_SYSTEM_PROMPT = `You have access to a virtual filesystem. All file paths must start with a /.
+
+- ls: list files in a directory (requires absolute path)
+- read_file: read a file from the filesystem
+- write_file: write to a file in the filesystem
+- edit_file: edit a file in the filesystem
+- glob: find files matching a pattern (e.g., "**/*.py")
+- grep: search for text within files`;
+var LS_TOOL_DESCRIPTION = "List files and directories in a directory";
+var READ_FILE_TOOL_DESCRIPTION = "Read the contents of a file";
+var WRITE_FILE_TOOL_DESCRIPTION = "Write content to a new file. Returns an error if the file already exists";
+var EDIT_FILE_TOOL_DESCRIPTION = "Edit a file by replacing a specific string with a new string";
+var GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py' for all Python files)";
+var GREP_TOOL_DESCRIPTION = "Search for a regex pattern in files. Returns matching files and line numbers";
+function createLsTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const path = input.path || "/";
+      const infos = await resolvedBackend.lsInfo(path);
+      if (infos.length === 0) {
+        return `No files found in ${path}`;
+      }
+      const lines = [];
+      for (const info of infos) {
+        if (info.is_dir) {
+          lines.push(`${info.path} (directory)`);
+        } else {
+          const size = info.size ? ` (${info.size} bytes)` : "";
+          lines.push(`${info.path}${size}`);
+        }
+      }
+      return lines.join("\n");
+    },
+    {
+      name: "ls",
+      description: customDescription || LS_TOOL_DESCRIPTION,
+      schema: z3.object({
+        path: z3.string().optional().default("/").describe("Directory path to list (default: /)")
+      })
+    }
+  );
+}
+function createReadFileTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const { file_path, offset = 0, limit = 2e3 } = input;
+      return await resolvedBackend.read(file_path, offset, limit);
+    },
+    {
+      name: "read_file",
+      description: customDescription || READ_FILE_TOOL_DESCRIPTION,
+      schema: z3.object({
+        file_path: z3.string().describe("Absolute path to the file to read"),
+        offset: z3.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
+        limit: z3.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
+      })
+    }
+  );
+}
+function createWriteFileTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const { file_path, content } = input;
+      const result = await resolvedBackend.write(file_path, content);
+      if (result.error) {
+        return result.error;
+      }
+      const message = new ToolMessage({
+        content: `Successfully wrote to '${file_path}'`,
+        tool_call_id: config.toolCall?.id,
+        name: "write_file",
+        metadata: result.metadata
+      });
+      if (result.filesUpdate) {
+        return new Command({
+          update: { files: result.filesUpdate, messages: [message] }
+        });
+      }
+      return message;
+    },
+    {
+      name: "write_file",
+      description: customDescription || WRITE_FILE_TOOL_DESCRIPTION,
+      schema: z3.object({
+        file_path: z3.string().describe("Absolute path to the file to write"),
+        content: z3.string().describe("Content to write to the file")
+      })
+    }
+  );
+}
+function createEditFileTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const { file_path, old_string, new_string, replace_all = false } = input;
+      const result = await resolvedBackend.edit(
+        file_path,
+        old_string,
+        new_string,
+        replace_all
+      );
+      if (result.error) {
+        return result.error;
+      }
+      const message = new ToolMessage({
+        content: `Successfully replaced ${result.occurrences} occurrence(s) in '${file_path}'`,
+        tool_call_id: config.toolCall?.id,
+        name: "edit_file",
+        metadata: result.metadata
+      });
+      if (result.filesUpdate) {
+        return new Command({
+          update: { files: result.filesUpdate, messages: [message] }
+        });
+      }
+      return message;
+    },
+    {
+      name: "edit_file",
+      description: customDescription || EDIT_FILE_TOOL_DESCRIPTION,
+      schema: z3.object({
+        file_path: z3.string().describe("Absolute path to the file to edit"),
+        old_string: z3.string().describe("String to be replaced (must match exactly)"),
+        new_string: z3.string().describe("String to replace with"),
+        replace_all: z3.boolean().optional().default(false).describe("Whether to replace all occurrences")
+      })
+    }
+  );
+}
+function createGlobTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const { pattern, path = "/" } = input;
+      const infos = await resolvedBackend.globInfo(pattern, path);
+      if (infos.length === 0) {
+        return `No files found matching pattern '${pattern}'`;
+      }
+      return infos.map((info) => info.path).join("\n");
+    },
+    {
+      name: "glob",
+      description: customDescription || GLOB_TOOL_DESCRIPTION,
+      schema: z3.object({
+        pattern: z3.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+        path: z3.string().optional().default("/").describe("Base path to search from (default: /)")
+      })
+    }
+  );
+}
+function createGrepTool(backend, options) {
+  const { customDescription } = options;
+  return tool2(
+    async (input, config) => {
+      const stateAndStore = {
+        state: getCurrentTaskInput(config),
+        store: config.store
+      };
+      const resolvedBackend = getBackend(backend, stateAndStore);
+      const { pattern, path = "/", glob = null } = input;
+      const result = await resolvedBackend.grepRaw(pattern, path, glob);
+      if (typeof result === "string") {
+        return result;
+      }
+      if (result.length === 0) {
+        return `No matches found for pattern '${pattern}'`;
+      }
+      const lines = [];
+      let currentFile = null;
+      for (const match of result) {
+        if (match.path !== currentFile) {
+          currentFile = match.path;
+          lines.push(`
+${currentFile}:`);
+        }
+        lines.push(`  ${match.line}: ${match.text}`);
+      }
+      return lines.join("\n");
+    },
+    {
+      name: "grep",
+      description: customDescription || GREP_TOOL_DESCRIPTION,
+      schema: z3.object({
+        pattern: z3.string().describe("Regex pattern to search for"),
+        path: z3.string().optional().default("/").describe("Base path to search from (default: /)"),
+        glob: z3.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+      })
+    }
+  );
+}
+function createFilesystemMiddleware(options = {}) {
+  const {
+    backend = (stateAndStore) => new StateBackend(stateAndStore),
+    systemPrompt: customSystemPrompt = null,
+    customToolDescriptions = null,
+    toolTokenLimitBeforeEvict = 2e4
+  } = options;
+  const systemPrompt = customSystemPrompt || FILESYSTEM_SYSTEM_PROMPT;
+  const tools = [
+    createLsTool(backend, {
+      customDescription: customToolDescriptions?.ls
+    }),
+    createReadFileTool(backend, {
+      customDescription: customToolDescriptions?.read_file
+    }),
+    createWriteFileTool(backend, {
+      customDescription: customToolDescriptions?.write_file
+    }),
+    createEditFileTool(backend, {
+      customDescription: customToolDescriptions?.edit_file
+    }),
+    createGlobTool(backend, {
+      customDescription: customToolDescriptions?.glob
+    }),
+    createGrepTool(backend, {
+      customDescription: customToolDescriptions?.grep
+    })
+  ];
+  return createMiddleware({
+    name: "FilesystemMiddleware",
+    stateSchema: FilesystemStateSchema,
+    tools,
+    wrapModelCall: systemPrompt ? async (request, handler) => {
+      const currentSystemPrompt = request.systemPrompt || "";
+      const newSystemPrompt = currentSystemPrompt ? `${currentSystemPrompt}
+
+${systemPrompt}` : systemPrompt;
+      return handler({ ...request, systemPrompt: newSystemPrompt });
+    } : void 0,
+    wrapToolCall: toolTokenLimitBeforeEvict ? (async (request, handler) => {
+      const result = await handler(request);
+      async function processToolMessage(msg) {
+        if (typeof msg.content === "string" && msg.content.length > toolTokenLimitBeforeEvict * 4) {
+          const stateAndStore = {
+            state: request.state || {},
+            store: request.config?.store
+          };
+          const resolvedBackend = getBackend(backend, stateAndStore);
+          const sanitizedId = sanitizeToolCallId(
+            request.toolCall?.id || msg.tool_call_id
+          );
+          const evictPath = `/large_tool_results/${sanitizedId}`;
+          const writeResult = await resolvedBackend.write(
+            evictPath,
+            msg.content
+          );
+          if (writeResult.error) {
+            return { message: msg, filesUpdate: null };
+          }
+          const truncatedMessage = new ToolMessage({
+            content: `Tool result too large (${Math.round(
+              msg.content.length / 4
+            )} tokens). Content saved to ${evictPath}`,
+            tool_call_id: msg.tool_call_id,
+            name: msg.name
+          });
+          return {
+            message: truncatedMessage,
+            filesUpdate: writeResult.filesUpdate
+          };
+        }
+        return { message: msg, filesUpdate: null };
+      }
+      if (result instanceof ToolMessage) {
+        const processed = await processToolMessage(result);
+        if (processed.filesUpdate) {
+          return new Command({
+            update: {
+              files: processed.filesUpdate,
+              messages: [processed.message]
+            }
+          });
+        }
+        return processed.message;
+      }
+      if (isCommand(result)) {
+        const update = result.update;
+        if (!update?.messages) {
+          return result;
+        }
+        let hasLargeResults = false;
+        const accumulatedFiles = {
+          ...update.files || {}
+        };
+        const processedMessages = [];
+        for (const msg of update.messages) {
+          if (msg instanceof ToolMessage) {
+            const processed = await processToolMessage(msg);
+            processedMessages.push(processed.message);
+            if (processed.filesUpdate) {
+              hasLargeResults = true;
+              Object.assign(accumulatedFiles, processed.filesUpdate);
+            }
+          } else {
+            processedMessages.push(msg);
+          }
+        }
+        if (hasLargeResults) {
+          return new Command({
+            update: {
+              ...update,
+              messages: processedMessages,
+              files: accumulatedFiles
+            }
+          });
+        }
+      }
+      return result;
+    }) : void 0
+  });
+}
 
-// src/deep_agent/state.ts
-import "@langchain/langgraph/zod";
-import { MessagesZodState as MessagesZodState2 } from "@langchain/langgraph";
-import { withLangGraph } from "@langchain/langgraph/zod";
-import { z as z11 } from "zod";
-function fileReducer(left, right) {
-  if (left == null) {
-    return right || {};
-  } else if (right == null) {
-    return left;
-  } else {
-    return { ...left, ...right };
+// src/deep_agent_new/middleware/subagents.ts
+import { z as z4 } from "zod/v3";
+import {
+  createMiddleware as createMiddleware2,
+  createAgent as createAgent2,
+  tool as tool3,
+  ToolMessage as ToolMessage2,
+  humanInTheLoopMiddleware
+} from "langchain";
+import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2 } from "@langchain/langgraph";
+import { HumanMessage } from "@langchain/core/messages";
+var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools.";
+var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
+var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
+function getTaskToolDescription(subagentDescriptions) {
+  return `
+Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
+
+Available agent types and the tools they have access to:
+${subagentDescriptions.join("\n")}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+## Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to create content, perform analysis, or just do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+7. When only the general-purpose agent is provided, you should use it for all tasks. It is great for isolating context and token usage, and completing specific, complex tasks, as it has all the same capabilities as the main agent.
+
+### Example usage of the general-purpose agent:
+
+<example_agent_descriptions>
+"general-purpose": use this agent for general purpose tasks, it has access to all tools as the main agent.
+</example_agent_descriptions>
+
+<example>
+User: "I want to conduct research on the accomplishments of Lebron James, Michael Jordan, and Kobe Bryant, and then compare them."
+Assistant: *Uses the task tool in parallel to conduct isolated research on each of the three players*
+Assistant: *Synthesizes the results of the three isolated research tasks and responds to the User*
+<commentary>
+Research is a complex, multi-step task in it of itself.
+The research of each individual player is not dependent on the research of the other players.
+The assistant uses the task tool to break down the complex objective into three isolated tasks.
+Each research task only needs to worry about context and tokens about one player, then returns synthesized information about each player as the Tool Result.
+This means each research task can dive deep and spend tokens and context deeply researching each player, but the final result is synthesized information, and saves us tokens in the long run when comparing the players to each other.
+</commentary>
+</example>
+
+<example>
+User: "Analyze a single large code repository for security vulnerabilities and generate a report."
+Assistant: *Launches a single \`task\` subagent for the repository analysis*
+Assistant: *Receives report and integrates results into final summary*
+<commentary>
+Subagent is used to isolate a large, context-heavy task, even though there is only one. This prevents the main thread from being overloaded with details.
+If the user then asks followup questions, we have a concise report to reference instead of the entire history of analysis and tool calls, which is good and saves us time and money.
+</commentary>
+</example>
+
+<example>
+User: "Schedule two meetings for me and prepare agendas for each."
+Assistant: *Calls the task tool in parallel to launch two \`task\` subagents (one per meeting) to prepare agendas*
+Assistant: *Returns final schedules and agendas*
+<commentary>
+Tasks are simple individually, but subagents help silo agenda preparation.
+Each subagent only needs to worry about the agenda for one meeting.
+</commentary>
+</example>
+
+<example>
+User: "I want to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway."
+Assistant: *Calls tools directly in parallel to order a pizza from Dominos, a burger from McDonald's, and a salad from Subway*
+<commentary>
+The assistant did not use the task tool because the objective is super simple and clear and only requires a few trivial tool calls.
+It is better to just complete the task directly and NOT use the \`task\`tool.
+</commentary>
+</example>
+
+### Example usage with custom agents:
+
+<example_agent_descriptions>
+"content-reviewer": use this agent after you are done creating significant content or documents
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+"research-analyst": use this agent to conduct thorough research on complex topics
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
   }
+  return true
 }
-function todoReducer(left, right) {
-  if (right != null) {
-    return right;
+</code>
+<commentary>
+Since significant content was created and the task was completed, now use the content-reviewer agent to review the work
+</commentary>
+assistant: Now let me use the content-reviewer agent to review the code
+assistant: Uses the Task tool to launch with the content-reviewer agent
+</example>
+
+<example>
+user: "Can you help me research the environmental impact of different renewable energy sources and create a comprehensive report?"
+<commentary>
+This is a complex research task that would benefit from using the research-analyst agent to conduct thorough analysis
+</commentary>
+assistant: I'll help you research the environmental impact of renewable energy sources. Let me use the research-analyst agent to conduct comprehensive research on this topic.
+assistant: Uses the Task tool to launch with the research-analyst agent, providing detailed instructions about what research to conduct and what format the report should take
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
+</example>
+  `.trim();
+}
+var TASK_SYSTEM_PROMPT = `## \`task\` (subagent spawner)
+
+You have access to a \`task\` tool to launch short-lived subagents that handle isolated tasks. These agents are ephemeral \u2014 they live only for the duration of the task and return a single result.
+
+When to use the task tool:
+- When a task is complex and multi-step, and can be fully delegated in isolation
+- When a task is independent of other tasks and can run in parallel
+- When a task requires focused reasoning or heavy token/context usage that would bloat the orchestrator thread
+- When sandboxing improves reliability (e.g. code execution, structured searches, data formatting)
+- When you only care about the output of the subagent, and not the intermediate steps (ex. performing a lot of research and then returned a synthesized report, performing a series of computations or lookups to achieve a concise, relevant answer.)
+
+Subagent lifecycle:
+1. **Spawn** \u2192 Provide clear role, instructions, and expected output
+2. **Run** \u2192 The subagent completes the task autonomously
+3. **Return** \u2192 The subagent provides a single structured result
+4. **Reconcile** \u2192 Incorporate or synthesize the result into the main thread
+
+When NOT to use the task tool:
+- If you need to see the intermediate reasoning or steps after the subagent has completed (the task tool hides them)
+- If the task is trivial (a few tool calls or simple lookup)
+- If delegating does not reduce token usage, complexity, or context switching
+- If splitting would add latency without benefit
+
+## Important Task Tool Usage Notes to Remember
+- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
+- Remember to use the \`task\` tool to silo independent tasks within a multi-part objective.
+- You should use the \`task\` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient.`;
+function filterStateForSubagent(state) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(state)) {
+    if (!EXCLUDED_STATE_KEYS.includes(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function returnCommandWithStateUpdate(result, toolCallId) {
+  const stateUpdate = filterStateForSubagent(result);
+  const messages = result.messages;
+  const lastMessage = messages?.[messages.length - 1];
+  return new Command2({
+    update: {
+      ...stateUpdate,
+      messages: [
+        new ToolMessage2({
+          content: lastMessage?.content || "Task completed",
+          tool_call_id: toolCallId,
+          name: "task"
+        })
+      ]
+    }
+  });
+}
+function getSubagents(options) {
+  const {
+    defaultModel,
+    defaultTools,
+    defaultMiddleware,
+    defaultInterruptOn,
+    subagents,
+    generalPurposeAgent
+  } = options;
+  const defaultSubagentMiddleware = defaultMiddleware || [];
+  const agents = {};
+  const subagentDescriptions = [];
+  if (generalPurposeAgent) {
+    const generalPurposeMiddleware = [...defaultSubagentMiddleware];
+    if (defaultInterruptOn) {
+      generalPurposeMiddleware.push(
+        humanInTheLoopMiddleware({ interruptOn: defaultInterruptOn })
+      );
+    }
+    const generalPurposeSubagent = createAgent2({
+      model: defaultModel,
+      systemPrompt: DEFAULT_SUBAGENT_PROMPT,
+      tools: defaultTools,
+      middleware: generalPurposeMiddleware
+    });
+    agents["general-purpose"] = generalPurposeSubagent;
+    subagentDescriptions.push(
+      `- general-purpose: ${DEFAULT_GENERAL_PURPOSE_DESCRIPTION}`
+    );
   }
-  return left || [];
+  for (const agentParams of subagents) {
+    subagentDescriptions.push(
+      `- ${agentParams.name}: ${agentParams.description}`
+    );
+    if ("runnable" in agentParams) {
+      agents[agentParams.name] = agentParams.runnable;
+    } else {
+      const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
+      const interruptOn = agentParams.interruptOn || defaultInterruptOn;
+      if (interruptOn)
+        middleware.push(humanInTheLoopMiddleware({ interruptOn }));
+      agents[agentParams.name] = createAgent2({
+        model: agentParams.model ?? defaultModel,
+        systemPrompt: agentParams.systemPrompt,
+        tools: agentParams.tools ?? defaultTools,
+        middleware
+      });
+    }
+  }
+  return { agents, descriptions: subagentDescriptions };
 }
-var DeepAgentState = MessagesZodState2.extend({
-  todos: withLangGraph(z11.custom(), {
-    reducer: {
-      schema: z11.custom(),
-      fn: todoReducer
-    }
-  }),
-  files: withLangGraph(z11.custom(), {
-    reducer: {
-      schema: z11.custom(),
-      fn: fileReducer
-    }
-  })
-});
+function createTaskTool(options) {
+  const {
+    defaultModel,
+    defaultTools,
+    defaultMiddleware,
+    defaultInterruptOn,
+    subagents,
+    generalPurposeAgent,
+    taskDescription
+  } = options;
+  const { agents: subagentGraphs, descriptions: subagentDescriptions } = getSubagents({
+    defaultModel,
+    defaultTools,
+    defaultMiddleware,
+    defaultInterruptOn,
+    subagents,
+    generalPurposeAgent
+  });
+  const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
+  return tool3(
+    async (input, config) => {
+      const { description, subagent_type } = input;
+      if (!(subagent_type in subagentGraphs)) {
+        const allowedTypes = Object.keys(subagentGraphs).map((k) => `\`${k}\``).join(", ");
+        throw new Error(
+          `Error: invoked agent of type ${subagent_type}, the only allowed types are ${allowedTypes}`
+        );
+      }
+      const subagent = subagentGraphs[subagent_type];
+      const currentState = getCurrentTaskInput2();
+      const subagentState = filterStateForSubagent(currentState);
+      subagentState.messages = [new HumanMessage({ content: description })];
+      const result = await subagent.invoke(subagentState, config);
+      if (!config.toolCall?.id) {
+        throw new Error("Tool call ID is required for subagent invocation");
+      }
+      return returnCommandWithStateUpdate(result, config.toolCall.id);
+    },
+    {
+      name: "task",
+      description: finalTaskDescription,
+      schema: z4.object({
+        description: z4.string().describe("The task to execute with the selected agent"),
+        subagent_type: z4.string().describe(
+          `Name of the agent to use. Available: ${Object.keys(
+            subagentGraphs
+          ).join(", ")}`
+        )
+      })
+    }
+  );
+}
+function createSubAgentMiddleware(options) {
+  const {
+    defaultModel,
+    defaultTools = [],
+    defaultMiddleware = null,
+    defaultInterruptOn = null,
+    subagents = [],
+    systemPrompt = TASK_SYSTEM_PROMPT,
+    generalPurposeAgent = true,
+    taskDescription = null
+  } = options;
+  const taskTool = createTaskTool({
+    defaultModel,
+    defaultTools,
+    defaultMiddleware,
+    defaultInterruptOn,
+    subagents,
+    generalPurposeAgent,
+    taskDescription
+  });
+  return createMiddleware2({
+    name: "subAgentMiddleware",
+    tools: [taskTool],
+    wrapModelCall: async (request, handler) => {
+      if (systemPrompt !== null) {
+        const currentPrompt = request.systemPrompt || "";
+        const newPrompt = currentPrompt ? `${currentPrompt}
+
+${systemPrompt}` : systemPrompt;
+        return handler({
+          ...request,
+          systemPrompt: newPrompt
+        });
+      }
+      return handler(request);
+    }
+  });
+}
+
+// src/deep_agent_new/middleware/patch_tool_calls.ts
+import {
+  createMiddleware as createMiddleware3,
+  ToolMessage as ToolMessage3,
+  AIMessage
+} from "langchain";
+import { RemoveMessage } from "@langchain/core/messages";
+import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
+function createPatchToolCallsMiddleware() {
+  return createMiddleware3({
+    name: "patchToolCallsMiddleware",
+    beforeAgent: async (state) => {
+      const messages = state.messages;
+      if (!messages || messages.length === 0) {
+        return;
+      }
+      const patchedMessages = [];
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        patchedMessages.push(msg);
+        if (AIMessage.isInstance(msg) && msg.tool_calls != null) {
+          for (const toolCall of msg.tool_calls) {
+            const correspondingToolMsg = messages.slice(i).find(
+              (m) => ToolMessage3.isInstance(m) && m.tool_call_id === toolCall.id
+            );
+            if (!correspondingToolMsg) {
+              const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
+              patchedMessages.push(
+                new ToolMessage3({
+                  content: toolMsg,
+                  name: toolCall.name,
+                  tool_call_id: toolCall.id
+                })
+              );
+            }
+          }
+        }
+      }
+      return {
+        messages: [
+          new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),
+          ...patchedMessages
+        ]
+      };
+    }
+  });
+}
+
+// src/deep_agent_new/backends/filesystem.ts
+import * as fsSync from "fs";
+import fg from "fast-glob";
+import micromatch2 from "micromatch";
+var SUPPORTS_NOFOLLOW = fsSync.constants.O_NOFOLLOW !== void 0;
+
+// src/deep_agent_new/middleware/todos.ts
+import { Command as Command3 } from "@langchain/langgraph";
+import { z as z5 } from "zod";
+import { createMiddleware as createMiddleware4, tool as tool4, ToolMessage as ToolMessage4 } from "langchain";
+var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for 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.
+Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
+
+## When to Use This Tool
+Use this tool in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex 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. The plan may need future revisions or updates based on results from the first few steps. Keeping track of this in a list is helpful.
+
+## How to Use This Tool
+1. When you start working on a task - Mark it as in_progress BEFORE beginning work.
+2. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation.
+3. You can also update future tasks, such as deleting them if they are no longer necessary, or adding new tasks that are necessary. Don't change previously completed tasks.
+4. You can make several updates to the todo list at once. For example, when you complete a task, you can mark the next task you need to start as in_progress.
+
+## When NOT to Use This Tool
+It is important to skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+## 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 in it of itself is a multi-step feature requiring UI, state management, and styling changes
+2. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+3. Both of the user's requests are complex and require multiple steps to complete.
+</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
+</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. 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)
+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.
 
-// src/deep_agent/graph.ts
-import { createReactAgent as createReactAgent2 } from "@langchain/langgraph/prebuilt";
-var BASE_PROMPT = `You have access to a number of standard tools
+<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>
 
-## \`write_todos\`
+## Examples of When NOT to Use the Todo List
 
-You have access to the \`write_todos\` tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
-These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+<example>
+User: How do I print 'Hello World' in Python?
+Assistant: In Python, you can print "Hello World" with this simple code:
 
-It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
-## \`task\`
+\`\`\`python
+print("Hello World")
+\`\`\`
 
-- When doing web search, prefer to use the \`task\` tool in order to reduce context usage.`;
-var BUILTIN_TOOLS = [
-  writeTodos,
-  readFile,
-  writeFile,
-  editFile,
-  ls
-];
-function createDeepAgent(params = {}) {
-  const {
-    tools = [],
-    instructions,
-    model = getModelLattice("default")?.client,
-    subagents = []
-  } = params;
-  if (!model) {
-    throw new Error("Model not found");
-  }
-  const stateSchema = params.stateSchema ? DeepAgentState.extend(params.stateSchema.shape) : DeepAgentState;
-  const allTools = [...BUILTIN_TOOLS, ...tools];
-  if (subagents.length > 0) {
-    const toolsMap = {};
-    for (const tool5 of allTools) {
-      if (tool5.name) {
-        toolsMap[tool5.name] = tool5;
-      }
-    }
-    const taskTool = createTaskTool({
-      subagents,
-      tools: toolsMap,
-      model,
-      stateSchema
-    });
-    allTools.push(taskTool);
-  }
-  const finalInstructions = instructions ? instructions + BASE_PROMPT : BASE_PROMPT;
-  return createReactAgent2({
-    llm: model,
-    tools: allTools,
-    stateSchema,
-    prompt: finalInstructions,
-    checkpointer: getCheckpointSaver("default")
-  });
-}
+This will output the text "Hello World" to the console when executed.</assistant>
 
-// src/agent_lattice/builders/DeepAgentGraphBuilder.ts
-var DeepAgentGraphBuilder = class {
-  /**
-   * 构建Deep Agent Graph
-   *
-   * @param agentLattice Agent Lattice对象
-   * @param params Agent构建参数
-   * @returns 返回CompiledGraph对象
-   */
-  build(agentLattice, params) {
-    const tools = params.tools.map((t) => {
-      const toolClient = getToolClient(t.key);
-      return toolClient;
-    }).filter((tool5) => tool5 !== void 0);
-    return createDeepAgent({
-      tools,
-      model: params.model,
-      stateSchema: params.stateSchema,
-      instructions: params.prompt,
-      subagents: params.subAgents.map((sa) => sa.config)
-    });
-  }
-};
+<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>
 
-// src/createPlanExecuteAgent.ts
-import {
-  Annotation,
-  END as END2,
-  GraphInterrupt as GraphInterrupt2,
-  START,
-  StateGraph,
-  messagesStateReducer
-} from "@langchain/langgraph";
-import {
-  HumanMessage as HumanMessage2
-} from "@langchain/core/messages";
-import { z as z12 } from "zod";
-
-// src/logger/Logger.ts
-import pino from "pino";
-import "pino-pretty";
-import "pino-roll";
-var PinoLoggerFactory = class _PinoLoggerFactory {
-  constructor() {
-    const isProd = process.env.NODE_ENV === "production";
-    const loggerConfig = {
-      // 自定义时间戳格式
-      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
-      // 关闭默认的时间戳键
-      base: {
-        "@version": "1",
-        app_name: "lattice",
-        service_name: "lattice/graph-server",
-        thread_name: "main",
-        logger_name: "lattice-graph-logger"
-      },
-      formatters: {
-        level: (label, number) => {
-          return {
-            level: label.toUpperCase(),
-            level_value: number * 1e3
-          };
-        }
-      }
-    };
-    if (isProd) {
-      try {
-        this.pinoLogger = pino(
-          loggerConfig,
-          pino.transport({
-            target: "pino-roll",
-            options: {
-              file: "./logs/fin_ai_graph_server",
-              frequency: "daily",
-              mkdir: true
-            }
-          })
-        );
-      } catch (error) {
-        console.error(
-          "\u65E0\u6CD5\u521D\u59CB\u5316 pino-roll \u65E5\u5FD7\u8BB0\u5F55\u5668\uFF0C\u56DE\u9000\u5230\u63A7\u5236\u53F0\u65E5\u5FD7",
-          error
-        );
-        this.pinoLogger = pino({
-          ...loggerConfig,
-          transport: {
-            target: "pino-pretty",
-            options: {
-              colorize: true
-            }
-          }
-        });
-      }
-    } else {
-      this.pinoLogger = pino({
-        ...loggerConfig,
-        transport: {
-          target: "pino-pretty",
-          options: {
-            colorize: true
-          }
-        }
-      });
-    }
-  }
-  static getInstance() {
-    if (!_PinoLoggerFactory.instance) {
-      _PinoLoggerFactory.instance = new _PinoLoggerFactory();
-    }
-    return _PinoLoggerFactory.instance;
-  }
-  getPinoLogger() {
-    return this.pinoLogger;
-  }
-};
-var Logger = class _Logger {
-  constructor(options) {
-    this.context = options?.context || {};
-    this.name = options?.name || "lattice-graph-logger";
-    this.serviceName = options?.serviceName || "lattice/graph-server";
-  }
-  /**
-   * 获取合并了上下文的日志对象
-   * @param additionalContext 额外的上下文数据
-   * @returns 带有上下文的pino日志对象
-   */
-  getContextualLogger(additionalContext) {
-    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
-    const contextObj = {
-      "x-user-id": this.context["x-user-id"] || "",
-      "x-tenant-id": this.context["x-tenant-id"] || "",
-      "x-request-id": this.context["x-request-id"] || "",
-      "x-task-id": this.context["x-task-id"] || "",
-      "x-thread-id": this.context["x-thread-id"] || "",
-      service_name: this.serviceName,
-      logger_name: this.name,
-      ...additionalContext
-    };
-    return pinoLogger.child(contextObj);
-  }
-  info(msg, obj) {
-    this.getContextualLogger(obj).info(msg);
-  }
-  error(msg, obj) {
-    this.getContextualLogger(obj).error(msg);
-  }
-  warn(msg, obj) {
-    this.getContextualLogger(obj).warn(msg);
-  }
-  debug(msg, obj) {
-    this.getContextualLogger(obj).debug(msg);
-  }
-  /**
-   * 更新Logger实例的上下文
-   */
-  updateContext(context) {
-    this.context = {
-      ...this.context,
-      ...context
-    };
-  }
-  /**
-   * 创建一个新的Logger实例，继承当前Logger的上下文
-   */
-  child(options) {
-    return new _Logger({
-      name: options.name || this.name,
-      serviceName: options.serviceName || this.serviceName,
-      context: {
-        ...this.context,
-        ...options.context
-      }
-    });
-  }
-};
+<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:
 
-// src/util/returnToolResponse.ts
-import { ToolMessage as ToolMessage6 } from "@langchain/core/messages";
-import { v4 } from "uuid";
-var returnToolResponse = (config, think) => {
-  const { think_id = v4(), content, title, status, type, data } = think;
-  const contents = type ? [title, content, genUIMarkdown(type, data)] : [title, content];
-  const message = {
-    messages: [
-      new ToolMessage6({
-        content: contents.filter((item) => item).join("\n\n"),
-        tool_call_id: config.configurable?.run_id + "_tool_" + think_id,
-        status: status || "success"
-      })
-    ]
-  };
-  return message;
-};
+- 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
 
-// src/util/returnAIResponse.ts
-import { AIMessage } from "@langchain/core/messages";
-var returnAIResponse = (config, content, type, data) => {
-  const contents = type ? [content, genUIMarkdown(type, data)].join("\n") : content;
-  const message = {
-    messages: [
-      new AIMessage({
-        content: contents
-      })
-      // {
-      //   id: v4(),
-      //   role: "ai",
-      //   content: contents,
-      //   type: "message",
-      // }, // 旧的message
-    ]
-  };
-  return message;
-};
+Different plants have different needs, so it's important to research your specific varieties for optimal care.
 
-// src/util/getLastHumanMessageData.ts
-import {
-  isHumanMessage
-} from "@langchain/core/messages";
-var getLastHumanMessageData = (messages) => {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    if (isHumanMessage(message)) {
-      const files = message?.additional_kwargs?.files;
-      return {
-        files,
-        content: message?.content
-      };
-    }
-  }
-  return null;
-};
+<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, not for the assistant to perform multiple steps or activities.
+</reasoning>
+</example>
 
-// src/createPlanExecuteAgent.ts
-import { tool as tool4 } from "@langchain/core/tools";
+<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 *
 
-// src/util/PGMemory.ts
-import { MemorySaver as MemorySaver2 } from "@langchain/langgraph";
-import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
-var globalMemory = PostgresSaver.fromConnString(process.env.DATABASE_URL);
-var memory2 = new MemorySaver2();
-var _MemoryManager = class _MemoryManager {
-  static getInstance() {
-    return _MemoryManager.instance;
-  }
-};
-_MemoryManager.instance = memory2;
-var MemoryManager = _MemoryManager;
-
-// src/createPlanExecuteAgent.ts
-import { createReactAgent as createReactAgent3 } from "@langchain/langgraph/prebuilt";
-var PlanExecuteState = Annotation.Root({
-  // 输入
-  input: Annotation({
-    reducer: (x, y) => y ?? x ?? ""
-  }),
-  // 计划步骤列表
-  plan: Annotation({
-    reducer: (x, y) => y ?? x ?? []
-  }),
-  // 已执行的步骤 [步骤名称, 执行结果]
-  pastSteps: Annotation({
-    reducer: (x, y) => x.concat(y),
-    default: () => []
-  }),
-  // 最终响应
-  response: Annotation({
-    reducer: (x, y) => y ?? x
-  }),
-  // 错误信息
-  error: Annotation({
-    reducer: (x, y) => y ?? x
-  }),
-  // 继承基础状态
-  "x-tenant-id": Annotation(),
-  messages: Annotation({
-    reducer: messagesStateReducer,
-    default: () => []
-  })
-});
-var planSchema = z12.object({
-  steps: z12.array(z12.string()).describe("\u9700\u8981\u6267\u884C\u7684\u6B65\u9AA4\u5217\u8868\uFF0C\u5E94\u6309\u7167\u6267\u884C\u987A\u5E8F\u6392\u5E8F")
-});
-var responseSchema = z12.object({
-  response: z12.string().describe("\u7ED9\u7528\u6237\u7684\u6700\u7EC8\u54CD\u5E94\uFF0C\u5982\u679C\u4E0D\u9700\u8981\u6267\u884C\u6B65\u9AA4\uFF0C\u5219\u8FD4\u56DE\u8FD9\u4E2A\u5B57\u6BB5")
-});
-function createPlanExecuteAgent(config) {
-  const {
-    name,
-    description,
-    tools: executorTools = [],
-    checkpointer,
-    llmManager,
-    logger,
-    maxSteps = 10,
-    prompt
-  } = config;
-  const agentLogger = logger || new Logger({ name: `PlanExecuteAgent:${name}` });
-  const llm = llmManager || getModelLattice("default")?.client;
-  if (!llm) {
-    throw new Error("LLM not found");
-  }
-  agentLogger.info(`\u521D\u59CB\u5316Plan-Execute\u4EE3\u7406: ${name}`, {
-    description,
-    maxSteps,
-    toolsCount: executorTools.length
-  });
-  const agentExecutor = createReactAgent3({
-    tools: executorTools,
-    llm
-  });
-  async function planStep(state, config2) {
-    const input = state.input || getLastHumanMessageData(state.messages)?.content;
-    const plannerPrompt = `${prompt || ""}
-\u9488\u5BF9\u7ED9\u5B9A\u7684\u76EE\u6807\uFF0C\u5236\u5B9A\u4E00\u4E2A\u7B80\u5355\u7684\u5206\u6B65\u8BA1\u5212\u3002
-\u8FD9\u4E2A\u8BA1\u5212\u5E94\u8BE5\u5305\u542B\u72EC\u7ACB\u7684\u4EFB\u52A1\uFF0C\u5982\u679C\u6B63\u786E\u6267\u884C\u5C06\u4F1A\u5F97\u5230\u6B63\u786E\u7684\u7B54\u6848\u3002\u4E0D\u8981\u6DFB\u52A0\u591A\u4F59\u7684\u6B65\u9AA4\u3002
-\u6700\u540E\u4E00\u6B65\u7684\u7ED3\u679C\u5E94\u8BE5\u662F\u6700\u7EC8\u7B54\u6848\u3002\u786E\u4FDD\u6BCF\u4E00\u6B65\u90FD\u6709\u6240\u9700\u7684\u6240\u6709\u4FE1\u606F - \u4E0D\u8981\u8DF3\u8FC7\u6B65\u9AA4\u3002
+<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>
 
-\u53EF\u4EE5\u4F7F\u7528\u7684\u5DE5\u5177\u5982\u4E0B\uFF1A
-${executorTools.map((tool5) => tool5.name).join("\n")}
+<example>
+User: What time is it in Tokyo right now?
+Assistant: I'll check the current time in Tokyo for you.
 
-\u76EE\u6807: ${input}`;
-    try {
-      const planResult = await llm.invokeWithStructuredOutput(
-        [new HumanMessage2(plannerPrompt)],
-        planSchema
-      );
-      const { messages } = await returnToolResponse(config2, {
-        title: "\u6211\u7684\u8BA1\u5212",
-        content: planResult.steps.map((step) => step).join("\n\n"),
-        status: "success"
-      });
-      agentLogger.info("\u8BA1\u5212\u5236\u5B9A\u5B8C\u6210", { plan: planResult.steps });
-      return {
-        input,
-        plan: planResult.steps,
-        error: void 0,
-        messages
-      };
-    } catch (error) {
-      const errorMsg = `\u8BA1\u5212\u5236\u5B9A\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
-      agentLogger.error(errorMsg, { error });
-      return {
-        error: errorMsg
-      };
-    }
-  }
-  async function executeStep(state, config2) {
-    if (!state.plan || state.plan.length === 0) {
-      agentLogger.warn("\u6CA1\u6709\u53EF\u6267\u884C\u7684\u4EFB\u52A1");
-      return { error: "\u6CA1\u6709\u53EF\u6267\u884C\u7684\u4EFB\u52A1" };
-    }
-    const currentTask = state.plan[0];
-    agentLogger.info("\u5F00\u59CB\u6267\u884C\u4EFB\u52A1", { task: currentTask });
-    try {
-      const executorPrompt = `\u6267\u884C\u4EE5\u4E0B\u4EFB\u52A1\u5E76\u63D0\u4F9B\u7ED3\u679C\uFF1A
+*Searches for current time in Tokyo*
 
-\u4EFB\u52A1: ${currentTask}
+The current time in Tokyo, Japan is [current time]. Tokyo is in the Japan Standard Time (JST) zone, which is UTC+9.
 
-\u4E0A\u4E0B\u6587\u4FE1\u606F:
-- \u539F\u59CB\u76EE\u6807: ${state.input}
-- \u5DF2\u5B8C\u6210\u7684\u6B65\u9AA4: ${state.pastSteps.map(([step, result]) => `${step}: ${result}`).join("\n")}
+<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 for this straightforward request.
+</reasoning>
+</example>
 
-\u8BF7\u63D0\u4F9B\u6267\u884C\u6B64\u4EFB\u52A1\u7684\u8BE6\u7EC6\u7ED3\u679C\u3002`;
-      const executionResult = await agentExecutor.invoke({
-        messages: [new HumanMessage2(executorPrompt)]
-      });
-      const resultContent = executionResult.messages[executionResult.messages.length - 1].content;
-      return {
-        pastSteps: [[currentTask, resultContent]],
-        plan: state.plan.slice(1),
-        // 移除已执行的任务
-        //messages,
-        error: void 0
-      };
-    } catch (error) {
-      if (error instanceof GraphInterrupt2) {
-        throw error;
-      }
-      const errorMsg = `\u4EFB\u52A1\u6267\u884C\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
-      agentLogger.error(errorMsg, { task: currentTask, error });
-      return {
-        error: errorMsg
-        //messages,
-      };
-    }
-  }
-  const responseTool = tool4(
-    ({ response }) => {
-      return response;
-    },
-    {
-      name: "response",
-      description: "Respond to the user.",
-      schema: responseSchema,
-      returnDirect: true
-    }
-  );
-  const planTool = tool4(
-    ({ steps }) => {
-      return steps.join("\n\n");
-    },
-    {
-      name: "plan",
-      description: "This tool is used to plan the steps to follow.",
-      schema: planSchema,
-      returnDirect: true
-    }
-  );
-  const replanAgent = createReactAgent3({
-    tools: [responseTool, planTool],
-    llm
-  });
-  async function replanStep(state, config2) {
-    agentLogger.info("\u5F00\u59CB\u91CD\u65B0\u89C4\u5212");
-    const replannerPrompt = `${prompt || ""}
-\u9488\u5BF9\u7ED9\u5B9A\u7684\u76EE\u6807\uFF0C\u6839\u636E\u5DF2\u6267\u884C\u7684\u6B65\u9AA4\u6765\u66F4\u65B0\u8BA1\u5212\u3002
-\u8FD9\u4E2A\u8BA1\u5212\u5E94\u8BE5\u5305\u542B\u72EC\u7ACB\u7684\u4EFB\u52A1\uFF0C\u5982\u679C\u6B63\u786E\u6267\u884C\u5C06\u4F1A\u5F97\u5230\u6B63\u786E\u7684\u7B54\u6848\u3002\u4E0D\u8981\u6DFB\u52A0\u591A\u4F59\u7684\u6B65\u9AA4\u3002
-\u6700\u540E\u4E00\u6B65\u7684\u7ED3\u679C\u5E94\u8BE5\u662F\u6700\u7EC8\u7B54\u6848\u3002\u786E\u4FDD\u6BCF\u4E00\u6B65\u90FD\u6709\u6240\u9700\u7684\u6240\u6709\u4FE1\u606F - \u4E0D\u8981\u8DF3\u8FC7\u6B65\u9AA4\u3002
+<example>
+User: I need to write a function that checks if a number is prime and then test it out.
+Assistant: I'll help you write a function that checks if a number is prime and then test it out.
+*Writes function that checks if a number is prime*
+*Tests the function*
+
+<reasoning>
+Even though this is a multi-step task, it is very straightforward and can be completed in two trivial steps (which is less than 3 steps!). Using the todo list here is overkill and wastes time and tokens.
+</reasoning>
+</example>
 
-\u4F60\u7684\u76EE\u6807\u662F\uFF1A
-${state.input}
+<example>
+User: I want you to order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+Assistant: I'll help you order a pizza from Dominos, order a burger from McDonald's, and order a salad from Subway.
+*Orders a pizza from Dominos*
+*Orders a burger from McDonald's*
+*Orders a salad from Subway*
 
-\u4F60\u7684\u539F\u59CB\u8BA1\u5212\u662F\uFF1A
-${state.plan.join("\n")}
+<reasoning>
+Even though this is a multi-step task, assuming the assistant has the ability to order from these restaurants, it is very straightforward and can be completed in three trivial tool calls. 
+Using the todo list here is overkill and wastes time and tokens. These three tool calls should be made in parallel, in fact.
+</reasoning>
+</example>
 
-\u4F60\u76EE\u524D\u5DF2\u7ECF\u5B8C\u6210\u4E86\u4EE5\u4E0B\u6B65\u9AA4\uFF1A
-${state.pastSteps.map(([step, result]) => `${step}: ${result}`).join("\n")}
 
-Update your plan accordingly. If no more steps are needed and you can return to the user, then respond with that and use the 'response' function.
-Otherwise, fill out the plan.
-Only add steps to the plan that still NEED to be done. Do not return previously done steps as part of the plan.`;
-    try {
-      const responseResult = await replanAgent.invoke({
-        messages: [new HumanMessage2(replannerPrompt)]
-      });
-      const toolCall = responseResult.messages[responseResult.messages.length - 1];
-      if (toolCall?.name == "response") {
-        agentLogger.info("\u4EFB\u52A1\u5B8C\u6210\uFF0C\u63D0\u4F9B\u6700\u7EC8\u54CD\u5E94");
-        const { messages } = await returnAIResponse(
-          config2,
-          toolCall.content
-        );
-        return {
-          response: toolCall.content,
-          messages,
-          error: void 0
-        };
-      } else if (toolCall?.name == "plan") {
-        let messages = [];
-        if (toolCall.content?.length > 0) {
-          messages = await returnToolResponse(config2, {
-            title: "\u65B0\u7684\u8BA1\u5212",
-            content: toolCall.content,
-            status: "success"
-          }).messages;
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (you can have multiple tasks in_progress at a time if they are not related to each other and can be run in parallel)
+   - completed: Task finished successfully
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+   - IMPORTANT: When you write this todo list, you should mark your first task (or tasks) as in_progress immediately!.
+   - IMPORTANT: Unless all tasks are completed, you should always have at least one task in_progress to show the user that you are working on something.
+
+3. **Task Completion Requirements**:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - There are unresolved issues or errors
+     - Work is partial or incomplete
+     - You encountered blockers that prevent completion
+     - You couldn't find necessary resources or dependencies
+     - Quality standards haven't been met
+
+4. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully
+Remember: If you only need to make a few tool calls to complete a task, and it is clear what you need to do, it is better to just do the task directly and NOT call this tool at all.`;
+var TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT = `## \`write_todos\`
+
+You have access to the \`write_todos\` tool to help you manage and plan complex objectives. 
+Use this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.
+This tool is very helpful for planning complex objectives, and for breaking down these larger complex objectives into smaller steps.
+
+It is critical that you mark todos as completed as soon as you are done with a step. Do not batch up multiple steps before marking them as completed.
+For simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.
+Writing todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.
+
+## Important To-Do List Usage Notes to Remember
+- The \`write_todos\` tool should never be called multiple times in parallel.
+- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
+var TodoStatus = z5.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z5.object({
+  content: z5.string().describe("Content of the todo item"),
+  status: TodoStatus
+});
+var stateSchema = z5.object({ todos: z5.array(TodoSchema).default([]) });
+function todoListMiddleware(options) {
+  const writeTodos = tool4(
+    ({ todos }, config) => {
+      return new Command3({
+        update: {
+          todos,
+          messages: [
+            new ToolMessage4({
+              content: genUIMarkdown("todo_list", todos),
+              tool_call_id: config.toolCall?.id
+            })
+          ]
         }
-        agentLogger.info("\u8BA1\u5212\u66F4\u65B0\u5B8C\u6210", { newPlan: toolCall.content });
-        return {
-          messages,
-          plan: toolCall.content.split("\n\n"),
-          error: void 0
-        };
-      } else {
-        return {
-          error: "\u91CD\u65B0\u89C4\u5212\u5931\u8D25"
-        };
-      }
-    } catch (error) {
-      if (error instanceof GraphInterrupt2) {
-        throw error;
-      }
-      const errorMsg = `\u91CD\u65B0\u89C4\u5212\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
-      agentLogger.error(errorMsg, { error });
-      return {
-        error: errorMsg
-      };
-    }
-  }
-  function shouldEnd(state) {
-    if (state.error) {
-      agentLogger.warn("\u56E0\u9519\u8BEF\u7ED3\u675F\u6267\u884C", { error: state.error });
-      return "end";
-    }
-    if (state.response) {
-      agentLogger.info("\u4EFB\u52A1\u5B8C\u6210\uFF0C\u7ED3\u675F\u6267\u884C");
-      return "end";
-    }
-    if (state.pastSteps.length >= maxSteps) {
-      agentLogger.warn("\u8FBE\u5230\u6700\u5927\u6B65\u9AA4\u6570\u9650\u5236\uFF0C\u7ED3\u675F\u6267\u884C", {
-        maxSteps,
-        currentSteps: state.pastSteps.length
       });
-      return "end";
-    }
-    if (!state.plan || state.plan.length === 0) {
-      agentLogger.info("\u8BA1\u5212\u4E3A\u7A7A\uFF0C\u7ED3\u675F\u6267\u884C");
-      return "end";
+    },
+    {
+      name: "write_todos",
+      description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
+      schema: z5.object({
+        todos: z5.array(TodoSchema).describe("List of todo items to update")
+      })
     }
-    return "continue";
-  }
-  const workflow = new StateGraph(PlanExecuteState).addNode("planner", planStep).addNode("executor", executeStep).addNode("replanner", replanStep).addEdge(START, "planner").addEdge("planner", "executor").addEdge("executor", "replanner").addConditionalEdges("replanner", shouldEnd, {
-    end: END2,
-    continue: "executor"
-  });
-  const compiledGraph = workflow.compile({
-    checkpointer: checkpointer || MemoryManager.getInstance(),
-    name: `PlanExecuteAgent:${name}`
+  );
+  return createMiddleware4({
+    name: "todoListMiddleware",
+    stateSchema,
+    tools: [writeTodos],
+    wrapModelCall: (request, handler) => handler({
+      ...request,
+      systemPrompt: (request.systemPrompt ? `${request.systemPrompt}
+
+` : "") + (options?.systemPrompt ?? TODO_LIST_MIDDLEWARE_SYSTEM_PROMPT)
+    })
   });
-  agentLogger.info(`Plan-Execute\u4EE3\u7406\u7F16\u8BD1\u5B8C\u6210: ${name}`);
-  return {
-    /**
-     * 执行代理
-     */
-    invoke: async (input, config2) => {
-      agentLogger.info(`\u5F00\u59CB\u6267\u884CPlan-Execute\u4EE3\u7406: ${name}`, {
-        input: input.input
-      });
-      try {
-        const result = await compiledGraph.invoke(input, config2);
-        agentLogger.info(`\u4EE3\u7406\u6267\u884C\u5B8C\u6210: ${name}`);
-        return result;
-      } catch (error) {
-        agentLogger.error(
-          `\u4EE3\u7406\u6267\u884C\u5931\u8D25: ${name}`,
-          error instanceof Error ? error : { error }
-        );
-        throw error;
-      }
-    },
-    /**
-     * 流式执行代理
-     */
-    stream: async (input, config2) => {
-      agentLogger.info(`\u5F00\u59CB\u6D41\u5F0F\u6267\u884CPlan-Execute\u4EE3\u7406: ${name}`, {
-        input: input.input
-      });
-      return compiledGraph.stream(input, config2);
-    },
-    /**
-     * 获取代理信息
-     */
-    getInfo: () => ({
-      name,
-      description,
-      type: "PlanExecuteAgent",
-      toolsCount: executorTools.length,
-      maxSteps
+}
+
+// src/deep_agent_new/agent.ts
+var BASE_PROMPT = `In order to complete the objective that the user asks of you, you have access to a number of standard tools.`;
+function createDeepAgent(params = {}) {
+  const {
+    model = "claude-sonnet-4-5-20250929",
+    tools = [],
+    systemPrompt,
+    middleware: customMiddleware = [],
+    subagents = [],
+    responseFormat,
+    contextSchema,
+    checkpointer,
+    store,
+    backend,
+    interruptOn,
+    name
+  } = params;
+  const finalSystemPrompt = systemPrompt ? `${systemPrompt}
+
+${BASE_PROMPT}` : BASE_PROMPT;
+  const filesystemBackend = backend ? backend : (config) => new StateBackend(config);
+  const middleware = [
+    // Provides todo list management capabilities for tracking tasks
+    todoListMiddleware(),
+    // Enables filesystem operations and optional long-term memory storage
+    createFilesystemMiddleware({ backend: filesystemBackend }),
+    // Enables delegation to specialized subagents for complex tasks
+    createSubAgentMiddleware({
+      defaultModel: model,
+      defaultTools: tools,
+      defaultMiddleware: [
+        // Subagent middleware: Todo list management
+        todoListMiddleware(),
+        // Subagent middleware: Filesystem operations
+        createFilesystemMiddleware({
+          backend: filesystemBackend
+        }),
+        // Subagent middleware: Automatic conversation summarization when token limits are approached
+        summarizationMiddleware({
+          model,
+          trigger: { tokens: 17e4 },
+          keep: { messages: 6 }
+        }),
+        // Subagent middleware: Anthropic prompt caching for improved performance
+        anthropicPromptCachingMiddleware({
+          unsupportedModelBehavior: "ignore"
+        }),
+        // Subagent middleware: Patches tool calls for compatibility
+        createPatchToolCallsMiddleware()
+      ],
+      defaultInterruptOn: interruptOn,
+      subagents,
+      generalPurposeAgent: true
     }),
-    /**
-     * 获取编译后的图
-     */
-    getCompiledGraph: () => compiledGraph
-  };
+    // Automatically summarizes conversation history when token limits are approached
+    summarizationMiddleware({
+      model,
+      trigger: { tokens: 17e4 },
+      keep: { messages: 6 }
+    }),
+    // Enables Anthropic prompt caching for improved performance and reduced costs
+    anthropicPromptCachingMiddleware({
+      unsupportedModelBehavior: "ignore"
+    }),
+    // Patches tool calls to ensure compatibility across different model providers
+    createPatchToolCallsMiddleware()
+  ];
+  if (interruptOn) {
+    middleware.push(humanInTheLoopMiddleware2({ interruptOn }));
+  }
+  middleware.push(...customMiddleware);
+  return createAgent3({
+    model,
+    systemPrompt: finalSystemPrompt,
+    tools,
+    middleware,
+    responseFormat,
+    contextSchema,
+    checkpointer,
+    store,
+    name
+  });
 }
 
-// src/agent_lattice/builders/PlanExecuteAgentGraphBuilder.ts
-var PlanExecuteAgentGraphBuilder = class {
+// src/agent_lattice/builders/DeepAgentGraphBuilder.ts
+var DeepAgentGraphBuilder = class {
   /**
-   * 构建Plan Execute Agent Graph
+   * 构建Deep Agent Graph
    *
    * @param agentLattice Agent Lattice对象
    * @param params Agent构建参数
@@ -2197,17 +2210,36 @@ var PlanExecuteAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool5 = getToolClient(t.key);
-      return tool5;
+      const toolClient = getToolClient(t.key);
+      return toolClient;
     }).filter((tool5) => tool5 !== void 0);
-    const agent = createPlanExecuteAgent({
-      llmManager: params.model,
+    const subagents = params.subAgents.map((sa) => {
+      if (sa.client) {
+        return {
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: sa.client
+        };
+      } else {
+        const subagentClient = createAgentClientFromAgentLattice({
+          config: sa.config
+        });
+        return {
+          name: sa.config.name,
+          description: sa.config.description,
+          runnable: subagentClient
+        };
+      }
+    });
+    const deepAgent = createDeepAgent({
       tools,
-      prompt: params.prompt,
-      name: agentLattice.config.name,
-      description: agentLattice.config.description
+      model: params.model,
+      contextSchema: params.stateSchema,
+      systemPrompt: params.prompt,
+      subagents,
+      checkpointer: getCheckpointSaver("default")
     });
-    return agent.getCompiledGraph();
+    return deepAgent;
   }
 };
 
@@ -2232,10 +2264,6 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
   registerDefaultBuilders() {
     this.builders.set(AgentType.REACT, new ReActAgentGraphBuilder());
     this.builders.set(AgentType.DEEP_AGENT, new DeepAgentGraphBuilder());
-    this.builders.set(
-      AgentType.PLAN_EXECUTE,
-      new PlanExecuteAgentGraphBuilder()
-    );
   }
   /**
    * 注册自定义Builder
@@ -2263,7 +2291,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 
 // src/agent_lattice/builders/AgentParamsBuilder.ts
 import {
-  getToolsFromConfig as getToolsFromConfig3,
+  getToolsFromConfig as getToolsFromConfig2,
   getSubAgentsFromConfig as getSubAgentsFromConfig2,
   isDeepAgentConfig as isDeepAgentConfig2
 } from "@axiom-lattice/protocols";
@@ -2284,7 +2312,7 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   buildParams(agentLattice, options) {
-    const toolKeys = options?.overrideTools || getToolsFromConfig3(agentLattice.config);
+    const toolKeys = options?.overrideTools || getToolsFromConfig2(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
       if (!toolLattice) {
@@ -2480,7 +2508,7 @@ var getAgentLattice = (key) => agentLatticeManager.getAgentLattice(key);
 var getAgentConfig = (key) => agentLatticeManager.getAgentConfig(key);
 var getAllAgentConfigs = () => agentLatticeManager.getAllAgentConfigs();
 var validateAgentInput = (key, input) => agentLatticeManager.validateAgentInput(key, input);
-var getAgentClient2 = (key, options) => agentLatticeManager.initializeClient(key, options);
+var getAgentClient = (key, options) => agentLatticeManager.initializeClient(key, options);
 var createAgentClientFromAgentLattice = (agentLattice, options) => agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
 // src/chunk_buffer_lattice/ChunkBuffer.ts
@@ -2811,7 +2839,7 @@ export {
   ThreadStatus,
   ToolLatticeManager,
   agentLatticeManager,
-  getAgentClient2 as getAgentClient,
+  getAgentClient,
   getAgentConfig,
   getAgentLattice,
   getAllAgentConfigs,