@axiom-lattice/core 2.0.2 → 2.0.4

package/dist/index.mjs

@@ -574,19 +574,272 @@ registerToolLattice(
     topic = "general",
     includeRawContent = false
   }, config) => {
+    console.log("[DEBUG][internet_search] Starting search with params:", {
+      query,
+      maxResults,
+      topic,
+      includeRawContent
+    });
+    console.log("[DEBUG][internet_search] Creating TavilySearch instance...");
     const tavilySearch = new TavilySearch({
       maxResults,
       tavilyApiKey: process.env.TAVILY_API_KEY,
       includeRawContent,
       topic
     });
+    console.log("[DEBUG][internet_search] Invoking search for query:", query);
     const tavilyResponse = await tavilySearch.invoke({ query });
-    return genUICard("Internet Search:" + query, "generic_data_table", {
+    console.log(
+      "[DEBUG][internet_search] Search completed. Results count:",
+      tavilyResponse.results?.length ?? 0
+    );
+    const result = genUICard("Internet Search:" + query, "generic_data_table", {
       dataSource: tavilyResponse.results
     });
+    console.log("[DEBUG][internet_search] Returning UI card result");
+    return result;
   }
 );
 
+// 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,
@@ -689,10 +942,10 @@ registerCheckpointSaver("default", memory);
 // src/agent_lattice/builders/state.ts
 import "@langchain/langgraph/zod";
 import { MessagesZodState } from "@langchain/langgraph";
-import { z as z3 } from "zod";
+import { z as z8 } from "zod";
 var ReActAgentState = MessagesZodState.extend({
-  files: z3.object({
-    final_output: z3.record(z3.any())
+  files: z8.object({
+    final_output: z8.record(z8.any())
   })
 });
 var createReactAgentSchema = (schema) => {
@@ -726,23 +979,17 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent/subAgent.ts
-import { tool as tool3 } from "@langchain/core/tools";
-import { ToolMessage as ToolMessage2 } from "@langchain/core/messages";
+import { tool as tool2 } from "@langchain/core/tools";
+import { ToolMessage as ToolMessage4 } from "@langchain/core/messages";
 import {
-  Command as Command2,
-  getCurrentTaskInput as getCurrentTaskInput2,
+  Command as Command4,
+  getCurrentTaskInput as getCurrentTaskInput5,
   GraphInterrupt
 } from "@langchain/langgraph";
-import { z as z5 } from "zod";
-
-// src/deep_agent/tools.ts
-import { tool as tool2 } from "@langchain/core/tools";
-import { ToolMessage } from "@langchain/core/messages";
-import { Command, getCurrentTaskInput } from "@langchain/langgraph";
-import { z as z4 } from "zod";
+import { z as z9 } from "zod";
 
 // src/deep_agent/prompts.ts
-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.
+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:
@@ -996,14 +1243,143 @@ 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 {
+    }
+  }
+  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 {
+      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}'`
+            );
+          }
+        }
+      } 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(", ")}`
+        )
+      })
+    }
+  );
+}
+
 // src/deep_agent/tools.ts
-var writeTodos = tool2(
+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 Command({
+    return new Command5({
       update: {
         todos: input.todos,
         messages: [
-          new ToolMessage({
+          new ToolMessage5({
             content: genUIMarkdown("todo_list", input.todos),
             tool_call_id: config.toolCall?.id
           })
@@ -1013,32 +1389,32 @@ var writeTodos = tool2(
   },
   {
     name: "write_todos",
-    description: WRITE_TODOS_DESCRIPTION,
-    schema: z4.object({
-      todos: z4.array(
-        z4.object({
-          content: z4.string().describe("Content of the todo item"),
-          status: z4.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
+    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")
     })
   }
 );
-var ls = tool2(
+var ls = tool3(
   () => {
-    const state = getCurrentTaskInput();
+    const state = getCurrentTaskInput6();
     const files = state.files || {};
     return Object.keys(files);
   },
   {
     name: "ls",
     description: "List all files in the mock filesystem",
-    schema: z4.object({})
+    schema: z10.object({})
   }
 );
-var readFile = tool2(
+var readFile = tool3(
   (input) => {
-    const state = getCurrentTaskInput();
+    const state = getCurrentTaskInput6();
     const mockFilesystem = state.files || {};
     const { file_path, offset = 0, limit = 2e3 } = input;
     if (!(file_path in mockFilesystem)) {
@@ -1068,23 +1444,23 @@ var readFile = tool2(
   {
     name: "read_file",
     description: TOOL_DESCRIPTION,
-    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")
+    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 = tool2(
+var writeFile = tool3(
   (input, config) => {
-    const state = getCurrentTaskInput();
+    const state = getCurrentTaskInput6();
     const files = { ...state.files || {} };
     files[input.file_path] = input.content;
-    return new Command({
+    return new Command5({
       update: {
         files,
         messages: [
-          new ToolMessage({
+          new ToolMessage5({
             content: `Updated file ${input.file_path}`,
             tool_call_id: config.toolCall?.id
           })
@@ -1095,15 +1471,15 @@ var writeFile = tool2(
   {
     name: "write_file",
     description: "Write content to a file in the mock filesystem",
-    schema: z4.object({
-      file_path: z4.string().describe("Absolute path to the file to write"),
-      content: z4.string().describe("Content to write to the file")
+    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")
     })
   }
 );
-var editFile = tool2(
+var editFile = tool3(
   (input, config) => {
-    const state = getCurrentTaskInput();
+    const state = getCurrentTaskInput6();
     const mockFilesystem = { ...state.files || {} };
     const { file_path, old_string, new_string, replace_all = false } = input;
     if (!(file_path in mockFilesystem)) {
@@ -1139,11 +1515,11 @@ var editFile = tool2(
       newContent = content.replace(old_string, new_string);
     }
     mockFilesystem[file_path] = newContent;
-    return new Command({
+    return new Command5({
       update: {
         files: mockFilesystem,
         messages: [
-          new ToolMessage({
+          new ToolMessage5({
             content: `Updated file ${file_path}`,
             tool_call_id: config.toolCall?.id
           })
@@ -1154,135 +1530,20 @@ var editFile = tool2(
   {
     name: "edit_file",
     description: EDIT_DESCRIPTION,
-    schema: z4.object({
-      file_path: z4.string().describe("Absolute path to the file to edit"),
-      old_string: z4.string().describe("String to be replaced (must match exactly)"),
-      new_string: z4.string().describe("String to replace with"),
-      replace_all: z4.boolean().optional().default(false).describe("Whether to replace all occurrences")
+    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")
     })
   }
 );
 
-// src/deep_agent/subAgent.ts
-import {
-  getToolsFromConfig as getToolsFromConfig2,
-  hasTools as hasTools2
-} from "@axiom-lattice/protocols";
-var BUILTIN_TOOLS = {
-  write_todos: writeTodos,
-  read_file: readFile,
-  write_file: writeFile,
-  edit_file: editFile,
-  ls
-};
-function createTaskTool(inputs) {
-  const {
-    subagents,
-    tools = {},
-    model = getModelLattice("default")?.client,
-    stateSchema,
-    postModelHook
-  } = inputs;
-  if (!model) {
-    throw new Error("Model not found");
-  }
-  const allTools = { ...BUILTIN_TOOLS, ...tools };
-  const agentsMap = /* @__PURE__ */ new Map();
-  for (const subagent of subagents) {
-    let reactAgent;
-    const agentLattice = getAgentLattice(subagent.key);
-    if (agentLattice) {
-      reactAgent = agentLattice.client;
-    } 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}'`
-            );
-          }
-        }
-      } else {
-        subagentTools.push(...Object.values(allTools));
-      }
-      reactAgent = createAgentClientFromAgentLattice({ config: subagent });
-    }
-    agentsMap.set(subagent.name, reactAgent);
-  }
-  return tool3(
-    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 = getCurrentTaskInput2();
-        const modifiedState = {
-          ...currentState,
-          messages: [
-            {
-              role: "user",
-              content: description
-            }
-          ]
-        };
-        const result = await reactAgent.invoke(modifiedState, config);
-        return new Command2({
-          update: {
-            files: result.files || {},
-            messages: [
-              new ToolMessage2({
-                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 Command2({
-          update: {
-            messages: [
-              new ToolMessage2({
-                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: z5.object({
-        description: z5.string().describe("The task to execute with the selected agent"),
-        subagent_type: z5.string().describe(
-          `Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`
-        )
-      })
-    }
-  );
-}
-
 // 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 z6 } from "zod";
+import { z as z11 } from "zod";
 function fileReducer(left, right) {
   if (left == null) {
     return right || {};
@@ -1299,15 +1560,15 @@ function todoReducer(left, right) {
   return left || [];
 }
 var DeepAgentState = MessagesZodState2.extend({
-  todos: withLangGraph(z6.custom(), {
+  todos: withLangGraph(z11.custom(), {
     reducer: {
-      schema: z6.custom(),
+      schema: z11.custom(),
       fn: todoReducer
     }
   }),
-  files: withLangGraph(z6.custom(), {
+  files: withLangGraph(z11.custom(), {
     reducer: {
-      schema: z6.custom(),
+      schema: z11.custom(),
       fn: fileReducer
     }
   })
@@ -1326,7 +1587,7 @@ It is critical that you mark todos as completed as soon as you are done with a t
 ## \`task\`
 
 - When doing web search, prefer to use the \`task\` tool in order to reduce context usage.`;
-var BUILTIN_TOOLS2 = [
+var BUILTIN_TOOLS = [
   writeTodos,
   readFile,
   writeFile,
@@ -1344,7 +1605,7 @@ function createDeepAgent(params = {}) {
     throw new Error("Model not found");
   }
   const stateSchema = params.stateSchema ? DeepAgentState.extend(params.stateSchema.shape) : DeepAgentState;
-  const allTools = [...BUILTIN_TOOLS2, ...tools];
+  const allTools = [...BUILTIN_TOOLS, ...tools];
   if (subagents.length > 0) {
     const toolsMap = {};
     for (const tool5 of allTools) {
@@ -1406,7 +1667,7 @@ import {
 import {
   HumanMessage as HumanMessage2
 } from "@langchain/core/messages";
-import { z as z7 } from "zod";
+import { z as z12 } from "zod";
 
 // src/logger/Logger.ts
 import pino from "pino";
@@ -1547,14 +1808,14 @@ var Logger = class _Logger {
 };
 
 // src/util/returnToolResponse.ts
-import { ToolMessage as ToolMessage3 } from "@langchain/core/messages";
+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 ToolMessage3({
+      new ToolMessage6({
         content: contents.filter((item) => item).join("\n\n"),
         tool_call_id: config.configurable?.run_id + "_tool_" + think_id,
         status: status || "success"
@@ -1649,11 +1910,11 @@ var PlanExecuteState = Annotation.Root({
     default: () => []
   })
 });
-var planSchema = z7.object({
-  steps: z7.array(z7.string()).describe("\u9700\u8981\u6267\u884C\u7684\u6B65\u9AA4\u5217\u8868\uFF0C\u5E94\u6309\u7167\u6267\u884C\u987A\u5E8F\u6392\u5E8F")
+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 = z7.object({
-  response: z7.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")
+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 {