@axiom-lattice/core 2.0.1 → 2.0.3

package/dist/index.js

@@ -44,7 +44,7 @@ __export(index_exports, {
   ThreadStatus: () => ThreadStatus,
   ToolLatticeManager: () => ToolLatticeManager,
   agentLatticeManager: () => agentLatticeManager,
-  getAgentClient: () => getAgentClient,
+  getAgentClient: () => getAgentClient2,
   getAgentConfig: () => getAgentConfig,
   getAgentLattice: () => getAgentLattice,
   getAllAgentConfigs: () => getAllAgentConfigs,
@@ -627,7 +627,7 @@ registerToolLattice(
   {
     name: "internet_search",
     description: "Run a web search",
-    needUserApprove: true,
+    needUserApprove: false,
     schema: import_zod2.default.object({
       query: import_zod2.default.string().describe("The search query"),
       maxResults: import_zod2.default.number().optional().default(5).describe("Maximum number of results to return"),
@@ -641,19 +641,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 import_tavily.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
+var import_zod3 = __toESM(require("zod"));
+var import_messages = require("@langchain/core/messages");
+var import_langgraph2 = require("@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: import_zod3.default.object({
+      todos: import_zod3.default.array(
+        import_zod3.default.object({
+          content: import_zod3.default.string().describe("Content of the todo item"),
+          status: import_zod3.default.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
+        })
+      ).describe("List of todo items to update")
+    })
+  },
+  ((input, config) => {
+    return new import_langgraph2.Command({
+      update: {
+        todos: input.todos,
+        messages: [
+          new import_messages.ToolMessage({
+            content: genUIMarkdown("todo_list", input.todos),
+            tool_call_id: config.toolCall?.id
+          })
+        ]
+      }
+    });
+  })
+);
+
+// src/tool_lattice/read_file/index.ts
+var import_zod4 = __toESM(require("zod"));
+var import_langgraph3 = require("@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: import_zod4.default.object({
+      file_path: import_zod4.default.string().describe("Absolute path to the file to read"),
+      offset: import_zod4.default.number().optional().default(0).describe("Line offset to start reading from"),
+      limit: import_zod4.default.number().optional().default(2e3).describe("Maximum number of lines to read")
+    })
+  },
+  ((input) => {
+    const state = (0, import_langgraph3.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
+var import_zod5 = __toESM(require("zod"));
+var import_messages2 = require("@langchain/core/messages");
+var import_langgraph4 = require("@langchain/langgraph");
+registerToolLattice(
+  "write_file",
+  {
+    name: "write_file",
+    description: "Write content to a file in the mock filesystem",
+    needUserApprove: false,
+    schema: import_zod5.default.object({
+      file_path: import_zod5.default.string().describe("Absolute path to the file to write"),
+      content: import_zod5.default.string().describe("Content to write to the file")
+    })
+  },
+  ((input, config) => {
+    const state = (0, import_langgraph4.getCurrentTaskInput)();
+    const files = { ...state.files || {} };
+    files[input.file_path] = input.content;
+    return new import_langgraph4.Command({
+      update: {
+        files,
+        messages: [
+          new import_messages2.ToolMessage({
+            content: `Updated file ${input.file_path}`,
+            tool_call_id: config.toolCall?.id
+          })
+        ]
+      }
+    });
+  })
+);
+
+// src/tool_lattice/edit_file/index.ts
+var import_zod6 = __toESM(require("zod"));
+var import_messages3 = require("@langchain/core/messages");
+var import_langgraph5 = require("@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: import_zod6.default.object({
+      file_path: import_zod6.default.string().describe("Absolute path to the file to edit"),
+      old_string: import_zod6.default.string().describe("String to be replaced (must match exactly)"),
+      new_string: import_zod6.default.string().describe("String to replace with"),
+      replace_all: import_zod6.default.boolean().optional().default(false).describe("Whether to replace all occurrences")
+    })
+  },
+  ((input, config) => {
+    const state = (0, import_langgraph5.getCurrentTaskInput)();
+    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 import_langgraph5.Command({
+      update: {
+        files: mockFilesystem,
+        messages: [
+          new import_messages3.ToolMessage({
+            content: `Updated file ${file_path}`,
+            tool_call_id: config.toolCall?.id
+          })
+        ]
+      }
+    });
+  })
+);
+
+// src/tool_lattice/ls/index.ts
+var import_zod7 = __toESM(require("zod"));
+var import_langgraph6 = require("@langchain/langgraph");
+registerToolLattice(
+  "ls",
+  {
+    name: "ls",
+    description: "List all files in the mock filesystem",
+    needUserApprove: false,
+    schema: import_zod7.default.object({})
+  },
+  (() => {
+    const state = (0, import_langgraph6.getCurrentTaskInput)();
+    const files = state.files || {};
+    return Object.keys(files);
+  })
+);
+
 // src/agent_lattice/types.ts
 var import_protocols = require("@axiom-lattice/protocols");
 
@@ -661,7 +914,7 @@ var import_protocols = require("@axiom-lattice/protocols");
 var import_prebuilt = require("@langchain/langgraph/prebuilt");
 
 // src/memory_lattice/DefaultMemorySaver.ts
-var import_langgraph2 = require("@langchain/langgraph");
+var import_langgraph7 = require("@langchain/langgraph");
 
 // src/memory_lattice/MemoryLatticeManager.ts
 var import_protocols2 = require("@axiom-lattice/protocols");
@@ -737,20 +990,20 @@ var getCheckpointSaver = (key) => MemoryLatticeManager.getInstance().getCheckpoi
 var registerCheckpointSaver = (key, saver) => MemoryLatticeManager.getInstance().registerCheckpointSaver(key, saver);
 
 // src/memory_lattice/DefaultMemorySaver.ts
-var memory = new import_langgraph2.MemorySaver();
+var memory = new import_langgraph7.MemorySaver();
 registerCheckpointSaver("default", memory);
 
 // src/agent_lattice/builders/state.ts
-var import_zod3 = require("@langchain/langgraph/zod");
-var import_langgraph3 = require("@langchain/langgraph");
-var import_zod4 = require("zod");
-var ReActAgentState = import_langgraph3.MessagesZodState.extend({
-  files: import_zod4.z.object({
-    final_output: import_zod4.z.record(import_zod4.z.any())
+var import_zod8 = require("@langchain/langgraph/zod");
+var import_langgraph8 = require("@langchain/langgraph");
+var import_zod9 = require("zod");
+var ReActAgentState = import_langgraph8.MessagesZodState.extend({
+  files: import_zod9.z.object({
+    final_output: import_zod9.z.record(import_zod9.z.any())
   })
 });
 var createReactAgentSchema = (schema) => {
-  return schema ? import_langgraph3.MessagesZodState.extend(schema.shape) : void 0;
+  return schema ? import_langgraph8.MessagesZodState.extend(schema.shape) : void 0;
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
@@ -780,20 +1033,13 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent/subAgent.ts
-var import_tools3 = require("@langchain/core/tools");
-var import_messages2 = require("@langchain/core/messages");
-var import_langgraph5 = require("@langchain/langgraph");
-var import_prebuilt2 = require("@langchain/langgraph/prebuilt");
-var import_zod6 = require("zod");
-
-// src/deep_agent/tools.ts
 var import_tools2 = require("@langchain/core/tools");
-var import_messages = require("@langchain/core/messages");
-var import_langgraph4 = require("@langchain/langgraph");
-var import_zod5 = require("zod");
+var import_messages4 = require("@langchain/core/messages");
+var import_langgraph9 = require("@langchain/langgraph");
+var import_zod10 = require("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:
@@ -1047,14 +1293,140 @@ 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
+var import_protocols3 = require("@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 ((0, import_protocols3.hasTools)(subagent)) {
+        for (const toolName of (0, import_protocols3.getToolsFromConfig)(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 (0, import_tools2.tool)(
+    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 = (0, import_langgraph9.getCurrentTaskInput)();
+        const modifiedState = {
+          ...currentState,
+          messages: [
+            {
+              role: "user",
+              content: description
+            }
+          ]
+        };
+        const result = await reactAgent.invoke(modifiedState, config);
+        return new import_langgraph9.Command({
+          update: {
+            files: result.files || {},
+            messages: [
+              new import_messages4.ToolMessage({
+                content: result.messages?.slice(-1)[0]?.content || "Task completed",
+                tool_call_id: config.toolCall?.id
+              })
+            ]
+          }
+        });
+      } catch (error) {
+        if (error instanceof import_langgraph9.GraphInterrupt) {
+          throw error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return new import_langgraph9.Command({
+          update: {
+            messages: [
+              new import_messages4.ToolMessage({
+                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: import_zod10.z.object({
+        description: import_zod10.z.string().describe("The task to execute with the selected agent"),
+        subagent_type: import_zod10.z.string().describe(
+          `Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`
+        )
+      })
+    }
+  );
+}
+
 // src/deep_agent/tools.ts
-var writeTodos = (0, import_tools2.tool)(
+var import_tools3 = require("@langchain/core/tools");
+var import_messages5 = require("@langchain/core/messages");
+var import_langgraph10 = require("@langchain/langgraph");
+var import_zod11 = require("zod");
+var writeTodos = (0, import_tools3.tool)(
   (input, config) => {
-    return new import_langgraph4.Command({
+    return new import_langgraph10.Command({
       update: {
         todos: input.todos,
         messages: [
-          new import_messages.ToolMessage({
+          new import_messages5.ToolMessage({
             content: genUIMarkdown("todo_list", input.todos),
             tool_call_id: config.toolCall?.id
           })
@@ -1064,32 +1436,32 @@ var writeTodos = (0, import_tools2.tool)(
   },
   {
     name: "write_todos",
-    description: WRITE_TODOS_DESCRIPTION,
-    schema: import_zod5.z.object({
-      todos: import_zod5.z.array(
-        import_zod5.z.object({
-          content: import_zod5.z.string().describe("Content of the todo item"),
-          status: import_zod5.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
+    description: WRITE_TODOS_DESCRIPTION2,
+    schema: import_zod11.z.object({
+      todos: import_zod11.z.array(
+        import_zod11.z.object({
+          content: import_zod11.z.string().describe("Content of the todo item"),
+          status: import_zod11.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo")
         })
       ).describe("List of todo items to update")
     })
   }
 );
-var ls = (0, import_tools2.tool)(
+var ls = (0, import_tools3.tool)(
   () => {
-    const state = (0, import_langgraph4.getCurrentTaskInput)();
+    const state = (0, import_langgraph10.getCurrentTaskInput)();
     const files = state.files || {};
     return Object.keys(files);
   },
   {
     name: "ls",
     description: "List all files in the mock filesystem",
-    schema: import_zod5.z.object({})
+    schema: import_zod11.z.object({})
   }
 );
-var readFile = (0, import_tools2.tool)(
+var readFile = (0, import_tools3.tool)(
   (input) => {
-    const state = (0, import_langgraph4.getCurrentTaskInput)();
+    const state = (0, import_langgraph10.getCurrentTaskInput)();
     const mockFilesystem = state.files || {};
     const { file_path, offset = 0, limit = 2e3 } = input;
     if (!(file_path in mockFilesystem)) {
@@ -1119,23 +1491,23 @@ var readFile = (0, import_tools2.tool)(
   {
     name: "read_file",
     description: TOOL_DESCRIPTION,
-    schema: import_zod5.z.object({
-      file_path: import_zod5.z.string().describe("Absolute path to the file to read"),
-      offset: import_zod5.z.number().optional().default(0).describe("Line offset to start reading from"),
-      limit: import_zod5.z.number().optional().default(2e3).describe("Maximum number of lines to read")
+    schema: import_zod11.z.object({
+      file_path: import_zod11.z.string().describe("Absolute path to the file to read"),
+      offset: import_zod11.z.number().optional().default(0).describe("Line offset to start reading from"),
+      limit: import_zod11.z.number().optional().default(2e3).describe("Maximum number of lines to read")
     })
   }
 );
-var writeFile = (0, import_tools2.tool)(
+var writeFile = (0, import_tools3.tool)(
   (input, config) => {
-    const state = (0, import_langgraph4.getCurrentTaskInput)();
+    const state = (0, import_langgraph10.getCurrentTaskInput)();
     const files = { ...state.files || {} };
     files[input.file_path] = input.content;
-    return new import_langgraph4.Command({
+    return new import_langgraph10.Command({
       update: {
         files,
         messages: [
-          new import_messages.ToolMessage({
+          new import_messages5.ToolMessage({
             content: `Updated file ${input.file_path}`,
             tool_call_id: config.toolCall?.id
           })
@@ -1146,15 +1518,15 @@ var writeFile = (0, import_tools2.tool)(
   {
     name: "write_file",
     description: "Write content to a file in the mock filesystem",
-    schema: import_zod5.z.object({
-      file_path: import_zod5.z.string().describe("Absolute path to the file to write"),
-      content: import_zod5.z.string().describe("Content to write to the file")
+    schema: import_zod11.z.object({
+      file_path: import_zod11.z.string().describe("Absolute path to the file to write"),
+      content: import_zod11.z.string().describe("Content to write to the file")
     })
   }
 );
-var editFile = (0, import_tools2.tool)(
+var editFile = (0, import_tools3.tool)(
   (input, config) => {
-    const state = (0, import_langgraph4.getCurrentTaskInput)();
+    const state = (0, import_langgraph10.getCurrentTaskInput)();
     const mockFilesystem = { ...state.files || {} };
     const { file_path, old_string, new_string, replace_all = false } = input;
     if (!(file_path in mockFilesystem)) {
@@ -1190,11 +1562,11 @@ var editFile = (0, import_tools2.tool)(
       newContent = content.replace(old_string, new_string);
     }
     mockFilesystem[file_path] = newContent;
-    return new import_langgraph4.Command({
+    return new import_langgraph10.Command({
       update: {
         files: mockFilesystem,
         messages: [
-          new import_messages.ToolMessage({
+          new import_messages5.ToolMessage({
             content: `Updated file ${file_path}`,
             tool_call_id: config.toolCall?.id
           })
@@ -1205,133 +1577,20 @@ var editFile = (0, import_tools2.tool)(
   {
     name: "edit_file",
     description: EDIT_DESCRIPTION,
-    schema: import_zod5.z.object({
-      file_path: import_zod5.z.string().describe("Absolute path to the file to edit"),
-      old_string: import_zod5.z.string().describe("String to be replaced (must match exactly)"),
-      new_string: import_zod5.z.string().describe("String to replace with"),
-      replace_all: import_zod5.z.boolean().optional().default(false).describe("Whether to replace all occurrences")
+    schema: import_zod11.z.object({
+      file_path: import_zod11.z.string().describe("Absolute path to the file to edit"),
+      old_string: import_zod11.z.string().describe("String to be replaced (must match exactly)"),
+      new_string: import_zod11.z.string().describe("String to replace with"),
+      replace_all: import_zod11.z.boolean().optional().default(false).describe("Whether to replace all occurrences")
     })
   }
 );
 
-// src/deep_agent/subAgent.ts
-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) {
-    const subagentTools = [];
-    if (subagent.tools) {
-      for (const toolName of subagent.tools) {
-        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));
-    }
-    const reactAgent = (0, import_prebuilt2.createReactAgent)({
-      llm: model,
-      tools: subagentTools,
-      stateSchema,
-      messageModifier: subagent.prompt,
-      // checkpointer: false,
-      checkpointer: getCheckpointSaver("default"),
-      postModelHook
-    });
-    agentsMap.set(subagent.name, reactAgent);
-  }
-  return (0, import_tools3.tool)(
-    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 = (0, import_langgraph5.getCurrentTaskInput)();
-        const modifiedState = {
-          ...currentState,
-          messages: [
-            {
-              role: "user",
-              content: description
-            }
-          ]
-        };
-        const result = await reactAgent.invoke(modifiedState, config);
-        return new import_langgraph5.Command({
-          update: {
-            files: result.files || {},
-            messages: [
-              new import_messages2.ToolMessage({
-                content: result.messages?.slice(-1)[0]?.content || "Task completed",
-                tool_call_id: config.toolCall?.id
-              })
-            ]
-          }
-        });
-      } catch (error) {
-        if (error instanceof import_langgraph5.GraphInterrupt) {
-          throw error;
-        }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return new import_langgraph5.Command({
-          update: {
-            messages: [
-              new import_messages2.ToolMessage({
-                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: import_zod6.z.object({
-        description: import_zod6.z.string().describe("The task to execute with the selected agent"),
-        subagent_type: import_zod6.z.string().describe(
-          `Name of the agent to use. Available: ${subagents.map((a) => a.name).join(", ")}`
-        )
-      })
-    }
-  );
-}
-
 // src/deep_agent/state.ts
-var import_zod7 = require("@langchain/langgraph/zod");
-var import_langgraph6 = require("@langchain/langgraph");
-var import_zod8 = require("@langchain/langgraph/zod");
-var import_zod9 = require("zod");
+var import_zod12 = require("@langchain/langgraph/zod");
+var import_langgraph11 = require("@langchain/langgraph");
+var import_zod13 = require("@langchain/langgraph/zod");
+var import_zod14 = require("zod");
 function fileReducer(left, right) {
   if (left == null) {
     return right || {};
@@ -1347,23 +1606,23 @@ function todoReducer(left, right) {
   }
   return left || [];
 }
-var DeepAgentState = import_langgraph6.MessagesZodState.extend({
-  todos: (0, import_zod8.withLangGraph)(import_zod9.z.custom(), {
+var DeepAgentState = import_langgraph11.MessagesZodState.extend({
+  todos: (0, import_zod13.withLangGraph)(import_zod14.z.custom(), {
     reducer: {
-      schema: import_zod9.z.custom(),
+      schema: import_zod14.z.custom(),
       fn: todoReducer
     }
   }),
-  files: (0, import_zod8.withLangGraph)(import_zod9.z.custom(), {
+  files: (0, import_zod13.withLangGraph)(import_zod14.z.custom(), {
     reducer: {
-      schema: import_zod9.z.custom(),
+      schema: import_zod14.z.custom(),
       fn: fileReducer
     }
   })
 });
 
 // src/deep_agent/graph.ts
-var import_prebuilt3 = require("@langchain/langgraph/prebuilt");
+var import_prebuilt2 = require("@langchain/langgraph/prebuilt");
 var BASE_PROMPT = `You have access to a number of standard tools
 
 ## \`write_todos\`
@@ -1375,7 +1634,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,
@@ -1393,7 +1652,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) {
@@ -1410,7 +1669,7 @@ function createDeepAgent(params = {}) {
     allTools.push(taskTool);
   }
   const finalInstructions = instructions ? instructions + BASE_PROMPT : BASE_PROMPT;
-  return (0, import_prebuilt3.createReactAgent)({
+  return (0, import_prebuilt2.createReactAgent)({
     llm: model,
     tools: allTools,
     stateSchema,
@@ -1438,20 +1697,15 @@ var DeepAgentGraphBuilder = class {
       model: params.model,
       stateSchema: params.stateSchema,
       instructions: params.prompt,
-      subagents: params.subAgents.map((sa) => ({
-        name: sa.key,
-        description: sa.config.description,
-        prompt: sa.config.prompt,
-        tools: sa.config.tools
-      }))
+      subagents: params.subAgents.map((sa) => sa.config)
     });
   }
 };
 
 // src/createPlanExecuteAgent.ts
-var import_langgraph8 = require("@langchain/langgraph");
-var import_messages6 = require("@langchain/core/messages");
-var import_zod10 = require("zod");
+var import_langgraph13 = require("@langchain/langgraph");
+var import_messages9 = require("@langchain/core/messages");
+var import_zod15 = require("zod");
 
 // src/logger/Logger.ts
 var import_pino = __toESM(require("pino"));
@@ -1592,14 +1846,14 @@ var Logger = class _Logger {
 };
 
 // src/util/returnToolResponse.ts
-var import_messages3 = require("@langchain/core/messages");
+var import_messages6 = require("@langchain/core/messages");
 var import_uuid = require("uuid");
 var returnToolResponse = (config, think) => {
   const { think_id = (0, import_uuid.v4)(), content, title, status, type, data } = think;
   const contents = type ? [title, content, genUIMarkdown(type, data)] : [title, content];
   const message = {
     messages: [
-      new import_messages3.ToolMessage({
+      new import_messages6.ToolMessage({
         content: contents.filter((item) => item).join("\n\n"),
         tool_call_id: config.configurable?.run_id + "_tool_" + think_id,
         status: status || "success"
@@ -1610,12 +1864,12 @@ var returnToolResponse = (config, think) => {
 };
 
 // src/util/returnAIResponse.ts
-var import_messages4 = require("@langchain/core/messages");
+var import_messages7 = require("@langchain/core/messages");
 var returnAIResponse = (config, content, type, data) => {
   const contents = type ? [content, genUIMarkdown(type, data)].join("\n") : content;
   const message = {
     messages: [
-      new import_messages4.AIMessage({
+      new import_messages7.AIMessage({
         content: contents
       })
       // {
@@ -1630,11 +1884,11 @@ var returnAIResponse = (config, content, type, data) => {
 };
 
 // src/util/getLastHumanMessageData.ts
-var import_messages5 = require("@langchain/core/messages");
+var import_messages8 = require("@langchain/core/messages");
 var getLastHumanMessageData = (messages) => {
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if ((0, import_messages5.isHumanMessage)(message)) {
+    if ((0, import_messages8.isHumanMessage)(message)) {
       const files = message?.additional_kwargs?.files;
       return {
         files,
@@ -1646,13 +1900,13 @@ var getLastHumanMessageData = (messages) => {
 };
 
 // src/createPlanExecuteAgent.ts
-var import_tools7 = require("@langchain/core/tools");
+var import_tools6 = require("@langchain/core/tools");
 
 // src/util/PGMemory.ts
-var import_langgraph7 = require("@langchain/langgraph");
+var import_langgraph12 = require("@langchain/langgraph");
 var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpoint-postgres");
 var globalMemory = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(process.env.DATABASE_URL);
-var memory2 = new import_langgraph7.MemorySaver();
+var memory2 = new import_langgraph12.MemorySaver();
 var _MemoryManager = class _MemoryManager {
   static getInstance() {
     return _MemoryManager.instance;
@@ -1662,41 +1916,41 @@ _MemoryManager.instance = memory2;
 var MemoryManager = _MemoryManager;
 
 // src/createPlanExecuteAgent.ts
-var import_prebuilt4 = require("@langchain/langgraph/prebuilt");
-var PlanExecuteState = import_langgraph8.Annotation.Root({
+var import_prebuilt3 = require("@langchain/langgraph/prebuilt");
+var PlanExecuteState = import_langgraph13.Annotation.Root({
   // 输入
-  input: (0, import_langgraph8.Annotation)({
+  input: (0, import_langgraph13.Annotation)({
     reducer: (x, y) => y ?? x ?? ""
   }),
   // 计划步骤列表
-  plan: (0, import_langgraph8.Annotation)({
+  plan: (0, import_langgraph13.Annotation)({
     reducer: (x, y) => y ?? x ?? []
   }),
   // 已执行的步骤 [步骤名称, 执行结果]
-  pastSteps: (0, import_langgraph8.Annotation)({
+  pastSteps: (0, import_langgraph13.Annotation)({
     reducer: (x, y) => x.concat(y),
     default: () => []
   }),
   // 最终响应
-  response: (0, import_langgraph8.Annotation)({
+  response: (0, import_langgraph13.Annotation)({
     reducer: (x, y) => y ?? x
   }),
   // 错误信息
-  error: (0, import_langgraph8.Annotation)({
+  error: (0, import_langgraph13.Annotation)({
     reducer: (x, y) => y ?? x
   }),
   // 继承基础状态
-  "x-tenant-id": (0, import_langgraph8.Annotation)(),
-  messages: (0, import_langgraph8.Annotation)({
-    reducer: import_langgraph8.messagesStateReducer,
+  "x-tenant-id": (0, import_langgraph13.Annotation)(),
+  messages: (0, import_langgraph13.Annotation)({
+    reducer: import_langgraph13.messagesStateReducer,
     default: () => []
   })
 });
-var planSchema = import_zod10.z.object({
-  steps: import_zod10.z.array(import_zod10.z.string()).describe("\u9700\u8981\u6267\u884C\u7684\u6B65\u9AA4\u5217\u8868\uFF0C\u5E94\u6309\u7167\u6267\u884C\u987A\u5E8F\u6392\u5E8F")
+var planSchema = import_zod15.z.object({
+  steps: import_zod15.z.array(import_zod15.z.string()).describe("\u9700\u8981\u6267\u884C\u7684\u6B65\u9AA4\u5217\u8868\uFF0C\u5E94\u6309\u7167\u6267\u884C\u987A\u5E8F\u6392\u5E8F")
 });
-var responseSchema = import_zod10.z.object({
-  response: import_zod10.z.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 = import_zod15.z.object({
+  response: import_zod15.z.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 {
@@ -1719,7 +1973,7 @@ function createPlanExecuteAgent(config) {
     maxSteps,
     toolsCount: executorTools.length
   });
-  const agentExecutor = (0, import_prebuilt4.createReactAgent)({
+  const agentExecutor = (0, import_prebuilt3.createReactAgent)({
     tools: executorTools,
     llm
   });
@@ -1736,7 +1990,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
 \u76EE\u6807: ${input}`;
     try {
       const planResult = await llm.invokeWithStructuredOutput(
-        [new import_messages6.HumanMessage(plannerPrompt)],
+        [new import_messages9.HumanMessage(plannerPrompt)],
         planSchema
       );
       const { messages } = await returnToolResponse(config2, {
@@ -1777,7 +2031,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
 
 \u8BF7\u63D0\u4F9B\u6267\u884C\u6B64\u4EFB\u52A1\u7684\u8BE6\u7EC6\u7ED3\u679C\u3002`;
       const executionResult = await agentExecutor.invoke({
-        messages: [new import_messages6.HumanMessage(executorPrompt)]
+        messages: [new import_messages9.HumanMessage(executorPrompt)]
       });
       const resultContent = executionResult.messages[executionResult.messages.length - 1].content;
       return {
@@ -1788,7 +2042,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
         error: void 0
       };
     } catch (error) {
-      if (error instanceof import_langgraph8.GraphInterrupt) {
+      if (error instanceof import_langgraph13.GraphInterrupt) {
         throw error;
       }
       const errorMsg = `\u4EFB\u52A1\u6267\u884C\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
@@ -1799,7 +2053,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
       };
     }
   }
-  const responseTool = (0, import_tools7.tool)(
+  const responseTool = (0, import_tools6.tool)(
     ({ response }) => {
       return response;
     },
@@ -1810,7 +2064,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
       returnDirect: true
     }
   );
-  const planTool = (0, import_tools7.tool)(
+  const planTool = (0, import_tools6.tool)(
     ({ steps }) => {
       return steps.join("\n\n");
     },
@@ -1821,7 +2075,7 @@ ${executorTools.map((tool5) => tool5.name).join("\n")}
       returnDirect: true
     }
   );
-  const replanAgent = (0, import_prebuilt4.createReactAgent)({
+  const replanAgent = (0, import_prebuilt3.createReactAgent)({
     tools: [responseTool, planTool],
     llm
   });
@@ -1846,7 +2100,7 @@ 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 import_messages6.HumanMessage(replannerPrompt)]
+        messages: [new import_messages9.HumanMessage(replannerPrompt)]
       });
       const toolCall = responseResult.messages[responseResult.messages.length - 1];
       if (toolCall?.name == "response") {
@@ -1881,7 +2135,7 @@ Only add steps to the plan that still NEED to be done. Do not return previously
         };
       }
     } catch (error) {
-      if (error instanceof import_langgraph8.GraphInterrupt) {
+      if (error instanceof import_langgraph13.GraphInterrupt) {
         throw error;
       }
       const errorMsg = `\u91CD\u65B0\u89C4\u5212\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`;
@@ -1913,8 +2167,8 @@ Only add steps to the plan that still NEED to be done. Do not return previously
     }
     return "continue";
   }
-  const workflow = new import_langgraph8.StateGraph(PlanExecuteState).addNode("planner", planStep).addNode("executor", executeStep).addNode("replanner", replanStep).addEdge(import_langgraph8.START, "planner").addEdge("planner", "executor").addEdge("executor", "replanner").addConditionalEdges("replanner", shouldEnd, {
-    end: import_langgraph8.END,
+  const workflow = new import_langgraph13.StateGraph(PlanExecuteState).addNode("planner", planStep).addNode("executor", executeStep).addNode("replanner", replanStep).addEdge(import_langgraph13.START, "planner").addEdge("planner", "executor").addEdge("executor", "replanner").addConditionalEdges("replanner", shouldEnd, {
+    end: import_langgraph13.END,
     continue: "executor"
   });
   const compiledGraph = workflow.compile({
@@ -2044,6 +2298,7 @@ var AgentGraphBuilderFactory = class _AgentGraphBuilderFactory {
 };
 
 // src/agent_lattice/builders/AgentParamsBuilder.ts
+var import_protocols4 = require("@axiom-lattice/protocols");
 var AgentParamsBuilder = class {
   /**
    * constructor
@@ -2061,7 +2316,7 @@ var AgentParamsBuilder = class {
    * @returns Agent build parameters
    */
   buildParams(agentLattice, options) {
-    const toolKeys = options?.overrideTools || agentLattice.config.tools || [];
+    const toolKeys = options?.overrideTools || (0, import_protocols4.getToolsFromConfig)(agentLattice.config);
     const tools = toolKeys.map((toolKey) => {
       const toolLattice = toolLatticeManager.getToolLattice(toolKey);
       if (!toolLattice) {
@@ -2078,7 +2333,7 @@ var AgentParamsBuilder = class {
     if (!model) {
       throw new Error(`Model "${modelKey}" does not exist`);
     }
-    const subAgentKeys = agentLattice.config.subAgents || [];
+    const subAgentKeys = (0, import_protocols4.getSubAgentsFromConfig)(agentLattice.config);
     const subAgents = subAgentKeys.map((agentKey) => {
       const subAgentLattice = this.getAgentLatticeFunc(agentKey);
       if (!subAgentLattice) {
@@ -2090,10 +2345,17 @@ var AgentParamsBuilder = class {
         client: subAgentLattice.client
       };
     });
+    let internalSubAgents = [];
+    if ((0, import_protocols4.isDeepAgentConfig)(agentLattice.config)) {
+      internalSubAgents = agentLattice.config.internalSubAgents?.map((i) => ({
+        key: i.key,
+        config: i
+      })) || [];
+    }
     return {
       tools,
       model,
-      subAgents,
+      subAgents: [...subAgents, ...internalSubAgents],
       prompt: agentLattice.config.prompt,
       stateSchema: agentLattice.config.schema
     };
@@ -2196,11 +2458,25 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @returns 返回Agent构建参数
    */
   buildAgentParams(agentLattice, options) {
-    const paramsBuilder = new AgentParamsBuilder(
-      (key) => this.getAgentLattice(key)
-    );
+    const paramsBuilder = new AgentParamsBuilder((key) => {
+      this.initializeClient(key);
+      return this.getAgentLattice(key);
+    });
     return paramsBuilder.buildParams(agentLattice, options);
   }
+  /**
+   * Create an AgentClient from AgentLattice config
+   *
+   * @param agentLattice Agent Lattice object
+   * @param options Build options
+   * @returns AgentClient instance
+   */
+  createAgentClientFromConfig(agentLattice, options) {
+    const factory = AgentGraphBuilderFactory.getInstance();
+    const builder = factory.getBuilder(agentLattice.config.type);
+    const params = this.buildAgentParams(agentLattice, options);
+    return builder.build(agentLattice, params);
+  }
   /**
    * 初始化Agent客户端
    *
@@ -2218,10 +2494,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     if (agentLattice.client) {
       return agentLattice.client;
     }
-    const factory = AgentGraphBuilderFactory.getInstance();
-    const builder = factory.getBuilder(agentLattice.config.type);
-    const params = this.buildAgentParams(agentLattice, options);
-    const graph = builder.build(agentLattice, params);
+    const graph = this.createAgentClientFromConfig(agentLattice, options);
     agentLattice.client = graph;
     return graph;
   }
@@ -2239,7 +2512,8 @@ 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 getAgentClient = (key, options) => agentLatticeManager.initializeClient(key, options);
+var getAgentClient2 = (key, options) => agentLatticeManager.initializeClient(key, options);
+var createAgentClientFromAgentLattice = (agentLattice, options) => agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
 // src/chunk_buffer_lattice/ChunkBuffer.ts
 var ChunkBuffer = class {