@axiom-lattice/core 2.1.29 → 2.1.31

package/dist/index.mjs

@@ -511,11 +511,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool47) {
+  registerExistingTool(key, tool48) {
     const config = {
-      name: tool47.name,
-      description: tool47.description,
-      schema: tool47.schema,
+      name: tool48.name,
+      description: tool48.description,
+      schema: tool48.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -523,7 +523,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool47
+      client: tool48
     };
     this.register(key, toolLattice);
   }
@@ -549,7 +549,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool47) => toolLatticeManager.registerExistingTool(key, tool47);
+var registerExistingTool = (key, tool48) => toolLatticeManager.registerExistingTool(key, tool48);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -561,11 +561,17 @@ registerToolLattice(
   "get_current_date_time",
   {
     name: "get_current_date_time",
-    description: "\u83B7\u53D6\u5F53\u524D\u65E5\u671F\u65F6\u95F4",
+    description: "Access the authoritative system clock to synchronize the real-world timeline. Essential for anchoring all relative time expressions (e.g., 'recent', 'last quarter', 'YTD') and establishing precise temporal filters for data retrieval, trend analysis, and decision-making logic. Avoid data hallucinations from training data.",
     schema: z.object({})
   },
   async () => {
-    return "\u5F53\u524D\u65E5\u671F\u65F6\u95F4\uFF1A" + (/* @__PURE__ */ new Date()).toLocaleString();
+    const now = /* @__PURE__ */ new Date();
+    return JSON.stringify({
+      local_time: now.toLocaleString(),
+      iso_date: now.toISOString().split("T")[0],
+      // 方便直接用于 SQL: 2026-03-10
+      timestamp: now.toISOString()
+    });
   }
 );
 
@@ -1900,7 +1906,7 @@ ${lines.join("\n")}`;
   );
 };
 
-// src/tool_lattice/metrics/list_metrics_datasources.ts
+// src/tool_lattice/metrics/list_datasources.ts
 import z8 from "zod";
 import { tool as tool7 } from "langchain";
 var LIST_METRICS_DATASOURCES_DESCRIPTION = `List all available datasources from all configured metrics servers. Returns a table with Server Key, DataSource ID, and DataSource Name. Use this tool first to discover what datasources are available before querying metrics.`;
@@ -1972,7 +1978,7 @@ To view all available data sources, please clear the current selection or reopen
       }
     },
     {
-      name: "list_metrics_datasources",
+      name: "list_datasources",
       description: `${LIST_METRICS_DATASOURCES_DESCRIPTION}${availableServersText}`,
       schema: z8.object({})
     }
@@ -2874,10 +2880,10 @@ When to Use This Tool:
 
 When NOT to Use This Tool:
 - For simple metric queries - use query_semantic_metric_data instead
-- When you haven't identified the correct datasource yet - use list_metrics_datasources first
+- When you haven't identified the correct datasource yet - use list_datasources first
 
 Prerequisites:
-1. Call list_metrics_datasources to get available datasource IDs
+1. Call list_datasources to get available datasource IDs
 2. Call query_tables_list to see available tables and their structures
 3. Call query_table_definition to understand table columns before writing SQL
 
@@ -2896,7 +2902,7 @@ Example:
   "params": {
     "year": "2024"
   },
-  "limit": 1000
+  "limit": 100
 }`;
 var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions }) => {
   const availableServersText = serverKeys.length > 0 ? `
@@ -2954,7 +2960,7 @@ ${serverKeys.map(
         datasourceId: z14.string().optional().describe("The data source ID to execute SQL against. Optional if configured in runConfig.metricsDataSource"),
         customSql: z14.string().describe("Custom SQL query string with named parameters (e.g., :year, :category). Use double quotes for identifiers."),
         params: z14.record(z14.union([z14.string(), z14.number(), z14.boolean()])).optional().describe("Optional parameters for the SQL query. Keys should match the :paramName placeholders in customSql."),
-        limit: z14.number().optional().describe("Maximum number of results to return (default: 1000).")
+        limit: z14.number().optional().describe("Maximum number of results to return (default: 100).")
       })
     }
   );
@@ -5756,6 +5762,122 @@ var InMemoryMetricsServerConfigStore = class {
   }
 };
 
+// src/store_lattice/InMemoryMcpServerConfigStore.ts
+var InMemoryMcpServerConfigStore = class {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get composite key for storage
+   */
+  getKey(tenantId, id) {
+    return `${tenantId}:${id}`;
+  }
+  /**
+   * Get all MCP server configurations for a tenant
+   */
+  async getAllConfigs(tenantId) {
+    return Array.from(this.configs.values()).filter(
+      (config) => config.tenantId === tenantId
+    );
+  }
+  /**
+   * Get all MCP server configurations across all tenants
+   */
+  async getAllConfigsWithoutTenant() {
+    return Array.from(this.configs.values());
+  }
+  /**
+   * Get MCP server configuration by ID
+   */
+  async getConfigById(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.get(key) || null;
+  }
+  /**
+   * Get MCP server configuration by business key
+   */
+  async getConfigByKey(tenantId, key) {
+    const configs = await this.getAllConfigs(tenantId);
+    return configs.find((config) => config.key === key) || null;
+  }
+  /**
+   * Create a new MCP server configuration
+   */
+  async createConfig(tenantId, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const entry = {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      selectedTools: data.selectedTools || [],
+      isEnvEncrypted: false,
+      status: "disconnected",
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    const storageKey = this.getKey(tenantId, id);
+    this.configs.set(storageKey, entry);
+    return entry;
+  }
+  /**
+   * Update an existing MCP server configuration
+   */
+  async updateConfig(tenantId, id, updates) {
+    const key = this.getKey(tenantId, id);
+    const existing = this.configs.get(key);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      config: updates.config ? { ...existing.config, ...updates.config } : existing.config,
+      key: updates.key || existing.key,
+      name: updates.name !== void 0 ? updates.name : existing.name,
+      description: updates.description !== void 0 ? updates.description : existing.description,
+      selectedTools: updates.selectedTools !== void 0 ? updates.selectedTools : existing.selectedTools,
+      status: updates.status !== void 0 ? updates.status : existing.status,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.configs.set(key, updated);
+    return updated;
+  }
+  /**
+   * Delete a MCP server configuration by ID
+   */
+  async deleteConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.delete(key);
+  }
+  /**
+   * Check if configuration exists
+   */
+  async hasConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.has(key);
+  }
+  /**
+   * Clear all configurations (useful for testing)
+   */
+  clear() {
+    this.configs.clear();
+  }
+  /**
+   * Clear configurations for a specific tenant
+   */
+  clearByTenant(tenantId) {
+    for (const key of this.configs.keys()) {
+      if (key.startsWith(`${tenantId}:`)) {
+        this.configs.delete(key);
+      }
+    }
+  }
+};
+
 // src/store_lattice/InMemoryUserStore.ts
 var InMemoryUserStore = class {
   constructor() {
@@ -6061,6 +6183,7 @@ var defaultWorkspaceStore = new InMemoryWorkspaceStore();
 var defaultProjectStore = new InMemoryProjectStore();
 var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
 var defaultMetricsServerConfigStore = new InMemoryMetricsServerConfigStore();
+var defaultMcpServerConfigStore = new InMemoryMcpServerConfigStore();
 storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
 storeLatticeManager.registerLattice(
   "default",
@@ -6072,6 +6195,7 @@ storeLatticeManager.registerLattice("default", "workspace", defaultWorkspaceStor
 storeLatticeManager.registerLattice("default", "project", defaultProjectStore);
 storeLatticeManager.registerLattice("default", "database", defaultDatabaseConfigStore);
 storeLatticeManager.registerLattice("default", "metrics", defaultMetricsServerConfigStore);
+storeLatticeManager.registerLattice("default", "mcp", defaultMcpServerConfigStore);
 var defaultUserStore = new InMemoryUserStore();
 var defaultTenantStore = new InMemoryTenantStore();
 var defaultUserTenantLinkStore = new InMemoryUserTenantLinkStore();
@@ -6263,7 +6387,7 @@ ${skillsPrompt}
 
 // src/deep_agent_new/middleware/fs.ts
 import { createMiddleware as createMiddleware5, tool as tool42, ToolMessage } from "langchain";
-import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
+import { Command, isCommand, getCurrentTaskInput, GraphInterrupt } from "@langchain/langgraph";
 import { z as z310 } from "zod/v3";
 import { withLangGraph } from "@langchain/langgraph/zod";
 
@@ -6980,7 +7104,7 @@ function createFilesystemMiddleware(options = {}) {
     backend = async (stateAndStore) => new StateBackend(stateAndStore),
     systemPrompt: customSystemPrompt = null,
     customToolDescriptions = null,
-    toolTokenLimitBeforeEvict = 2e4
+    toolTokenLimitBeforeEvict = 1e5
   } = options;
   const systemPrompt = customSystemPrompt || FILESYSTEM_SYSTEM_PROMPT;
   const tools = [
@@ -7015,7 +7139,24 @@ ${systemPrompt}` : systemPrompt;
       return handler({ ...request, systemPrompt: newSystemPrompt });
     } : void 0,
     wrapToolCall: toolTokenLimitBeforeEvict ? (async (request, handler) => {
-      const result = await handler(request);
+      let result;
+      try {
+        result = await handler(request);
+      } catch (error) {
+        if (error instanceof GraphInterrupt) {
+          throw error;
+        }
+        console.error(request.toolCall?.name, error);
+        return new Command({
+          update: {
+            messages: [new ToolMessage({
+              content: error instanceof Error ? error.message : "Unknown error",
+              tool_call_id: request.toolCall?.id,
+              name: request.toolCall?.name
+            })]
+          }
+        });
+      }
       async function processToolMessage(msg) {
         if (typeof msg.content === "string" && msg.content.length > toolTokenLimitBeforeEvict * 4) {
           const stateAndStore = {
@@ -7129,6 +7270,122 @@ function createMetricsMiddleware(params) {
   });
 }
 
+// src/middlewares/askUserClarifyMiddleware.ts
+import { createMiddleware as createMiddleware7, ToolMessage as ToolMessage2 } from "langchain";
+import { GraphInterrupt as GraphInterrupt2, interrupt as interrupt2 } from "@langchain/langgraph";
+
+// src/tool_lattice/ask_user_to_clarify/index.ts
+import { tool as tool43 } from "langchain";
+import z43 from "zod";
+var questionSchema = z43.object({
+  question: z43.string().describe("The question text to ask the user"),
+  options: z43.array(z43.string()).describe("List of EXACT, selectable values. Maximum 3 options allowed. DO NOT include any 'placeholder' options that require the user to type (e.g., do NOT add 'Enter manual value'). If manual input is needed, set allowOther to true instead."),
+  type: z43.enum(["single", "multiple"]).describe("Whether the question allows single or multiple selections"),
+  required: z43.boolean().optional().default(false).describe("Whether this question must be answered"),
+  allowOther: z43.boolean().optional().default(true).describe("Set to true to append an 'Other' option that opens a free-text input field. Use this for open-ended answers or when the 3 options cannot cover all possibilities.")
+});
+var inputSchema = z43.object({
+  questions: z43.array(questionSchema).min(1, "At least one question is required").describe("A structured sequence of clarification questions. Use these to gather missing parameters or disambiguate user intent before proceeding.")
+});
+function createAskUserToClarifyTool() {
+  return tool43(
+    async (input) => {
+      return JSON.stringify(input);
+    },
+    {
+      name: "ask_user_to_clarify",
+      description: "Prompts the user to choose from a list of predefined values OR provide custom input. USE CASES: 1. Use 'options' ONLY for distinct, mutually exclusive choices (e.g., ['Standard', 'Express']). 2. Set 'allowOther: true' ONLY when you need to capture free-text information that doesn't fit into the predefined options. IMPORTANT: Never put placeholders like 'Please specify' or 'Other' inside the 'options' list. ",
+      schema: inputSchema
+    }
+  );
+}
+
+// src/middlewares/askUserClarifyMiddleware.ts
+function createAskUserClarifyMiddleware() {
+  return createMiddleware7({
+    name: "AskUserClarifyMiddleware",
+    tools: [createAskUserToClarifyTool()],
+    wrapToolCall: async (request, handler) => {
+      const toolCall = request.toolCall;
+      const toolName = toolCall?.name;
+      if (toolName !== "ask_user_to_clarify") {
+        try {
+          return await handler(request);
+        } catch (error) {
+          if (error instanceof GraphInterrupt2) {
+            throw error;
+          }
+          console.error(`Error executing tool "${toolName}":`, error);
+          return new ToolMessage2({
+            content: `Error executing tool: ${error instanceof Error ? error.message : "Unknown error"}`,
+            tool_call_id: toolCall?.id,
+            name: toolName
+          });
+        }
+      }
+      const input = toolCall?.args;
+      if (!input?.questions || input.questions.length === 0) {
+        return new ToolMessage2({
+          content: "No questions provided.",
+          tool_call_id: toolCall?.id,
+          name: toolName
+        });
+      }
+      const uiData = {
+        questions: input.questions.map((q) => ({
+          question: q.question,
+          options: q.options,
+          type: q.type,
+          required: q.required,
+          allowOther: q.allowOther
+        }))
+      };
+      const md = genUIMarkdown("clarify", uiData);
+      const result = await interrupt2(md);
+      const response = result.data;
+      if (!response?.answers || response.answers.length === 0) {
+        return new ToolMessage2({
+          content: "No clarification questions were answered.",
+          tool_call_id: toolCall?.id,
+          name: toolName
+        });
+      }
+      const answeredQuestions = response.answers.filter(
+        (answer) => answer.selectedOptions.length > 0 || answer.otherText && answer.otherText.trim() !== ""
+      );
+      if (answeredQuestions.length === 0) {
+        return new ToolMessage2({
+          content: "No clarification questions were answered.",
+          tool_call_id: toolCall?.id,
+          name: toolName
+        });
+      }
+      const lines = ["## Clarification Questions Answered", ""];
+      for (const answer of answeredQuestions) {
+        const question = input.questions[answer.questionIndex];
+        if (!question) continue;
+        lines.push(`**Q${answer.questionIndex + 1}: ${question.question}**`);
+        const parts = [];
+        if (answer.selectedOptions.length > 0) {
+          parts.push(...answer.selectedOptions);
+        }
+        if (answer.otherText && answer.otherText.trim() !== "") {
+          parts.push(`Other: ${answer.otherText.trim()}`);
+        }
+        if (parts.length > 0) {
+          lines.push(`A: ${parts.join(", ")}`);
+        }
+        lines.push("");
+      }
+      return new ToolMessage2({
+        content: lines.join("\n"),
+        tool_call_id: toolCall?.id,
+        name: toolName
+      });
+    }
+  });
+}
+
 // src/agent_lattice/builders/commonMiddleware.ts
 function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
   const middlewares = [];
@@ -7175,6 +7432,9 @@ function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
           }
         }
         break;
+      case "ask_user_to_clarify":
+        middlewares.push(createAskUserClarifyMiddleware());
+        break;
     }
   }
   return middlewares;
@@ -7218,9 +7478,9 @@ var ReActAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool47 = getToolClient(t.key);
-      return tool47;
-    }).filter((tool47) => tool47 !== void 0);
+      const tool48 = getToolClient(t.key);
+      return tool48;
+    }).filter((tool48) => tool48 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
@@ -7246,12 +7506,12 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z43 } from "zod/v3";
+import { z as z44 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware7,
+  createMiddleware as createMiddleware8,
   createAgent as createAgent2,
-  tool as tool43,
-  ToolMessage as ToolMessage2,
+  tool as tool44,
+  ToolMessage as ToolMessage3,
   humanInTheLoopMiddleware
 } from "langchain";
 import { Command as Command2, getCurrentTaskInput as getCurrentTaskInput2 } from "@langchain/langgraph";
@@ -7261,7 +7521,7 @@ import { HumanMessage } from "@langchain/core/messages";
 import {
   StateGraph,
   END as END2,
-  interrupt as interrupt2,
+  interrupt as interrupt3,
   Annotation
 } from "@langchain/langgraph";
 
@@ -7618,7 +7878,7 @@ async function interruptNode(state) {
       "Interrupt node called but no interrupt value found in result"
     );
   }
-  const response = await interrupt2(interruptValue);
+  const response = await interrupt3(interruptValue);
   return {
     command2: {
       resume: response
@@ -7821,7 +8081,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new ToolMessage2({
+        new ToolMessage3({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -7900,7 +8160,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool43(
+  return tool44(
     async (input, config) => {
       const { description, subagent_type } = input;
       try {
@@ -7935,7 +8195,7 @@ function createTaskTool(options) {
         return new Command2({
           update: {
             messages: [
-              new ToolMessage2({
+              new ToolMessage3({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -7948,9 +8208,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z43.object({
-        description: z43.string().describe("The task to execute with the selected agent"),
-        subagent_type: z43.string().describe(
+      schema: z44.object({
+        description: z44.string().describe("The task to execute with the selected agent"),
+        subagent_type: z44.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -7979,7 +8239,7 @@ function createSubAgentMiddleware(options) {
     generalPurposeAgent,
     taskDescription
   });
-  return createMiddleware7({
+  return createMiddleware8({
     name: "subAgentMiddleware",
     tools: [taskTool],
     wrapModelCall: async (request, handler) => {
@@ -8000,14 +8260,14 @@ ${systemPrompt}` : systemPrompt;
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware8,
-  ToolMessage as ToolMessage3,
+  createMiddleware as createMiddleware9,
+  ToolMessage as ToolMessage4,
   AIMessage as AIMessage2
 } from "langchain";
 import { RemoveMessage } from "@langchain/core/messages";
 import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware8({
+  return createMiddleware9({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -8021,12 +8281,12 @@ function createPatchToolCallsMiddleware() {
         if (AIMessage2.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
+              (m) => ToolMessage4.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({
+                new ToolMessage4({
                   content: toolMsg,
                   name: toolCall.name,
                   tool_call_id: toolCall.id
@@ -9139,8 +9399,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z44 } from "zod";
-import { createMiddleware as createMiddleware9, tool as tool44, ToolMessage as ToolMessage4 } from "langchain";
+import { z as z45 } from "zod";
+import { createMiddleware as createMiddleware10, tool as tool45, ToolMessage as ToolMessage5 } 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.
@@ -9367,20 +9627,20 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## 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 = z44.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z44.object({
-  content: z44.string().describe("Content of the todo item"),
+var TodoStatus = z45.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = z45.object({
+  content: z45.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = z44.object({ todos: z44.array(TodoSchema).default([]) });
+var stateSchema = z45.object({ todos: z45.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool44(
+  const writeTodos = tool45(
     ({ todos }, config) => {
       return new Command3({
         update: {
           todos,
           messages: [
-            new ToolMessage4({
+            new ToolMessage5({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -9391,12 +9651,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z44.object({
-        todos: z44.array(TodoSchema).describe("List of todo items to update")
+      schema: z45.object({
+        todos: z45.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware9({
+  return createMiddleware10({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -9539,7 +9799,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool47) => tool47 !== void 0);
+    }).filter((tool48) => tool48 !== void 0);
     const subagents = params.subAgents.map((sa) => {
       if (sa.client) {
         return {
@@ -9579,7 +9839,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z47 } from "zod/v3";
+import { z as z48 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -10015,14 +10275,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z46 } from "zod/v3";
-import { createMiddleware as createMiddleware10, createAgent as createAgent4, tool as tool46, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z47 } from "zod/v3";
+import { createMiddleware as createMiddleware11, createAgent as createAgent4, tool as tool47, ToolMessage as ToolMessage7 } from "langchain";
 import { Command as Command5, getCurrentTaskInput as getCurrentTaskInput3 } from "@langchain/langgraph";
 import { v4 as uuidv4 } from "uuid";
 
 // src/agent_team/middleware/teammate_tools.ts
-import { z as z45 } from "zod/v3";
-import { tool as tool45, ToolMessage as ToolMessage5 } from "langchain";
+import { z as z46 } from "zod/v3";
+import { tool as tool46, ToolMessage as ToolMessage6 } from "langchain";
 import { Command as Command4 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -10047,7 +10307,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool45(
+  const claimTaskTool = tool46(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -10072,12 +10332,12 @@ function createTeammateTools(options) {
     {
       name: "claim_task",
       description: "Pick a task to work on by task_id. Use check_tasks first to see all tasks; then call this with the task_id you choose. The task's assignee is set to you and you should focus on that task until you complete_task or fail_task it.",
-      schema: z45.object({
-        task_id: z45.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z46.object({
+        task_id: z46.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool45(
+  const completeTaskTool = tool46(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -10098,13 +10358,13 @@ function createTeammateTools(options) {
     {
       name: "complete_task",
       description: "Mark a claimed task as completed with a result summary. Call this after you have finished working on a task.",
-      schema: z45.object({
-        task_id: z45.string().describe("ID of the task to complete"),
-        result: z45.string().describe("Summary of the task result")
+      schema: z46.object({
+        task_id: z46.string().describe("ID of the task to complete"),
+        result: z46.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool45(
+  const failTaskTool = tool46(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -10125,13 +10385,13 @@ function createTeammateTools(options) {
     {
       name: "fail_task",
       description: "Mark a claimed task as failed with an error description. Call this if you cannot complete the task.",
-      schema: z45.object({
-        task_id: z45.string().describe("ID of the task to fail"),
-        error: z45.string().describe("Description of why the task failed")
+      schema: z46.object({
+        task_id: z46.string().describe("ID of the task to fail"),
+        error: z46.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool45(
+  const sendMessageTool = tool46(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -10145,11 +10405,11 @@ function createTeammateTools(options) {
     {
       name: "send_message",
       description: 'Send a message to the team lead or another teammate via the mailbox. Use "team_lead" to message the team lead. Use this to report discoveries, request guidance, or suggest new tasks.',
-      schema: z45.object({
-        to: z45.string().describe(
+      schema: z46.object({
+        to: z46.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z45.string().describe("Message content")
+        content: z46.string().describe("Message content")
       })
     }
   );
@@ -10169,7 +10429,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool45(
+  const readMessagesTool = tool46(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -10181,7 +10441,7 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new ToolMessage5({
+        const toolMessage2 = new ToolMessage6({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -10206,7 +10466,7 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new ToolMessage5({
+        const toolMessage2 = new ToolMessage6({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -10216,7 +10476,7 @@ function createTeammateTools(options) {
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new ToolMessage5({
+      const toolMessage = new ToolMessage6({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -10228,10 +10488,10 @@ function createTeammateTools(options) {
     {
       name: "read_messages",
       description: "Read unread messages from the mailbox. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z45.object({})
+      schema: z46.object({})
     }
   );
-  const checkTasksTool = tool45(
+  const checkTasksTool = tool46(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -10239,10 +10499,10 @@ function createTeammateTools(options) {
     {
       name: "check_tasks",
       description: "Use this tool to get the current status of all tasks in a team. This is your primary way to monitor task progress.",
-      schema: z45.object({})
+      schema: z46.object({})
     }
   );
-  const broadcastMessageTool = tool45(
+  const broadcastMessageTool = tool46(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -10261,8 +10521,8 @@ function createTeammateTools(options) {
     {
       name: "broadcast_message",
       description: "Send a message to everyone in the team except yourself. Use this to share updates or information with all teammates and the team lead at once.",
-      schema: z45.object({
-        content: z45.string().describe("Message content to broadcast to others")
+      schema: z46.object({
+        content: z46.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -10485,12 +10745,12 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool46(
+  const createTeamTool = tool47(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new ToolMessage6({
+        const msg = new ToolMessage7({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
@@ -10575,7 +10835,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new ToolMessage6({
+      const toolMessage = new ToolMessage7({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -10636,20 +10896,20 @@ After calling create_team, you MUST:
 2. When messages indicate task changes, call check_tasks to get full task status
 3. Continue until all tasks show "completed" or "failed"
 4. Do NOT assume tasks are done - always verify with check_tasks`,
-      schema: z46.object({
-        tasks: z46.array(
-          z46.object({
-            id: z46.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z46.string().describe("Short task title"),
-            description: z46.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z46.array(z46.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      schema: z47.object({
+        tasks: z47.array(
+          z47.object({
+            id: z47.string().describe("Task ID in format task-01, task-02, etc."),
+            title: z47.string().describe("Short task title"),
+            description: z47.string().describe("Detailed task description - what exactly needs to be done"),
+            dependencies: z47.array(z47.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
           })
         ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
-        teammates: z46.array(
-          z46.object({
-            name: z46.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z46.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z46.string().describe("What this teammate will focus on - specific instructions for their work")
+        teammates: z47.array(
+          z47.object({
+            name: z47.string().describe("Teammate name (must match a pre-configured teammate type)"),
+            role: z47.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
+            description: z47.string().describe("What this teammate will focus on - specific instructions for their work")
           })
         ).describe("Teammate agents to create. Each should have a clear role and focus.")
       })
@@ -10660,7 +10920,7 @@ After calling create_team, you MUST:
     if (state?.team?.teamId) return state.team.teamId;
     throw new Error("No team_id provided and no team in state. Call create_team first.");
   };
-  const addTasksTool = tool46(
+  const addTasksTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -10674,7 +10934,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -10712,33 +10972,33 @@ IMPORTANT: Dependencies
 
 IMPORTANT: Assigning to a specific teammate
 - When you need a particular teammate to do the work, set assignee to that teammate's name (e.g. assignee: "researcher"). They can then claim or see the task as assigned to them.`,
-      schema: z46.object({
-        tasks: z46.array(
-          z46.object({
-            id: z46.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z46.string().describe("Short task title"),
-            description: z46.string().describe("Detailed task description - what needs to be done"),
-            assignee: z46.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z46.array(z46.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      schema: z47.object({
+        tasks: z47.array(
+          z47.object({
+            id: z47.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
+            title: z47.string().describe("Short task title"),
+            description: z47.string().describe("Detailed task description - what needs to be done"),
+            assignee: z47.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
+            dependencies: z47.array(z47.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool46(
+  const assignTaskTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new ToolMessage6({
+        return new ToolMessage7({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -10747,26 +11007,26 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "assign_task",
       description: "Assign a task to a specific teammate. Use when you need to reassign work to a different teammate. Omit team_id to use the active team from state.",
-      schema: z46.object({
-        task_id: z46.string().describe("Task ID to assign"),
-        assignee: z46.string().describe("Teammate name to assign this task to")
+      schema: z47.object({
+        task_id: z47.string().describe("Task ID to assign"),
+        assignee: z47.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool46(
+  const setTaskStatusTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new ToolMessage6({
+        return new ToolMessage7({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -10775,26 +11035,26 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_status",
       description: "Set a task's status. Use to reopen a task (set to pending), mark as failed, or correct status. Values: pending, claimed, in_progress, completed, failed. Omit team_id to use the active team from state.",
-      schema: z46.object({
-        task_id: z46.string().describe("Task ID to update"),
-        status: z46.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      schema: z47.object({
+        task_id: z47.string().describe("Task ID to update"),
+        status: z47.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
       })
     }
   );
-  const setTaskDependenciesTool = tool46(
+  const setTaskDependenciesTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new ToolMessage6({
+        return new ToolMessage7({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -10803,13 +11063,13 @@ IMPORTANT: Assigning to a specific teammate
     {
       name: "set_task_dependencies",
       description: 'Set which task IDs must complete before this task can be claimed. Pass an array of task IDs (e.g. ["task-01", "task-02"]). Use to fix task order or add/remove dependencies. Omit team_id to use the active team from state.',
-      schema: z46.object({
-        task_id: z46.string().describe("Task ID to update"),
-        dependencies: z46.array(z46.string()).describe("Task IDs that must complete before this task can be claimed")
+      schema: z47.object({
+        task_id: z47.string().describe("Task ID to update"),
+        dependencies: z47.array(z47.string()).describe("Task IDs that must complete before this task can be claimed")
       })
     }
   );
-  const checkTasksTool = tool46(
+  const checkTasksTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -10818,7 +11078,7 @@ IMPORTANT: Assigning to a specific teammate
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new ToolMessage6({
+            new ToolMessage7({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -10849,12 +11109,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z46.object({
-        team_id: z46.string().optional().describe("Team ID (omit to use active team)")
+      schema: z47.object({
+        team_id: z47.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool46(
+  const sendMessageTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -10864,7 +11124,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -10873,13 +11133,13 @@ Task Status Values:
     {
       name: "send_message",
       description: "Send a message to a specific teammate in the team. Omit team_id to use the active team from state.",
-      schema: z46.object({
-        to: z46.string().describe("Recipient teammate name"),
-        content: z46.string().describe("Message content")
+      schema: z47.object({
+        to: z47.string().describe("Recipient teammate name"),
+        content: z47.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool46(
+  const readMessagesTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -10907,7 +11167,7 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new ToolMessage6({
+        const toolMessage2 = new ToolMessage7({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -10939,7 +11199,7 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new ToolMessage6({
+        const toolMessage2 = new ToolMessage7({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -10949,7 +11209,7 @@ Task Status Values:
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new ToolMessage6({
+      const toolMessage = new ToolMessage7({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -10961,12 +11221,12 @@ Task Status Values:
     {
       name: "read_messages",
       description: "Read unread messages from teammates. Returns immediately if messages exist, otherwise waits for up to 3 minutes for new messages.",
-      schema: z46.object({
-        team_id: z46.string().optional().describe("Team ID (omit to use active team)")
+      schema: z47.object({
+        team_id: z47.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool46(
+  const disbandTeamTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -10976,7 +11236,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -10987,7 +11247,7 @@ Task Status Values:
       description: "Disband a team when all work is done. Before calling: (1) Call check_tasks to verify no tasks are still pending/in_progress; (2) if any are, discuss with the team via read_messages and broadcast_message/send_message whether to continue or stop/cancel them; (3) only after alignment (all tasks completed/failed or explicitly stopped), then call this tool. This will: 1) Send a shutdown message to all teammates, 2) Wait briefly for them to clean up, 3) Clear all tasks and messages. Omit team_id to use the active team from state."
     }
   );
-  const broadcastMessageTool = tool46(
+  const broadcastMessageTool = tool47(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -10996,7 +11256,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new ToolMessage6({
+      return new ToolMessage7({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -11005,12 +11265,12 @@ Task Status Values:
     {
       name: "broadcast_message",
       description: "Send a message to all teammates at once. Use this to communicate with everyone in the team. Omit team_id to use the active team from state.",
-      schema: z46.object({
-        content: z46.string().describe("Message content to broadcast to all teammates")
+      schema: z47.object({
+        content: z47.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
-  return createMiddleware10({
+  return createMiddleware11({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -11038,37 +11298,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z47.object({
-  name: z47.string().describe("Teammate name"),
-  role: z47.string().describe("Role category (e.g. research, writing, review)"),
-  description: z47.string().describe("What this teammate focuses on")
+var TeammateInfoSchema = z48.object({
+  name: z48.string().describe("Teammate name"),
+  role: z48.string().describe("Role category (e.g. research, writing, review)"),
+  description: z48.string().describe("What this teammate focuses on")
 });
-var TeamTaskInfoSchema = z47.object({
-  id: z47.string(),
-  title: z47.string(),
-  description: z47.string(),
-  status: z47.string().optional()
+var TeamTaskInfoSchema = z48.object({
+  id: z48.string(),
+  title: z48.string(),
+  description: z48.string(),
+  status: z48.string().optional()
 });
-var MailboxMessageSchema = z47.object({
-  id: z47.string().describe("Unique message identifier"),
-  from: z47.string().describe("Sender agent name"),
-  to: z47.string().describe("Recipient agent name"),
-  content: z47.string().describe("Message content"),
-  timestamp: z47.string().describe("ISO timestamp when the message was sent"),
-  type: z47.nativeEnum(MessageType).describe("Message type"),
-  read: z47.boolean().describe("Whether the recipient has read this message")
+var MailboxMessageSchema = z48.object({
+  id: z48.string().describe("Unique message identifier"),
+  from: z48.string().describe("Sender agent name"),
+  to: z48.string().describe("Recipient agent name"),
+  content: z48.string().describe("Message content"),
+  timestamp: z48.string().describe("ISO timestamp when the message was sent"),
+  type: z48.nativeEnum(MessageType).describe("Message type"),
+  read: z48.boolean().describe("Whether the recipient has read this message")
 });
-var TeamInfoSchema = z47.object({
-  teamId: z47.string().describe("Unique team identifier"),
-  teamLeadId: z47.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z47.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z47.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z47.string().optional().describe("ISO timestamp when team was created")
+var TeamInfoSchema = z48.object({
+  teamId: z48.string().describe("Unique team identifier"),
+  teamLeadId: z48.string().default("team_lead").describe("Team lead agent ID"),
+  teammates: z48.array(TeammateInfoSchema).describe("Active teammates in this team"),
+  tasks: z48.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
+  createdAt: z48.string().optional().describe("ISO timestamp when team was created")
 });
-var TEAM_STATE_SCHEMA = z47.object({
+var TEAM_STATE_SCHEMA = z48.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z47.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z47.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  tasks: z48.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
+  team_mailbox: z48.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
 });
 var TEAM_LEAD_BASE_PROMPT = `You are a team lead that coordinates a team of specialized agents. In order to complete the objective that the user asks of you, you will need to:
 
@@ -11148,7 +11408,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool47) => tool47 !== void 0);
+    }).filter((tool48) => tool48 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -13825,10 +14085,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool47 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool47.name}` : tool47.name;
-      tool47.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool47);
+    for (const tool48 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool48.name}` : tool48.name;
+      tool48.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool48);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);