@axiom-lattice/core 2.1.26 → 2.1.28

package/dist/index.mjs

@@ -508,11 +508,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool46) {
+  registerExistingTool(key, tool47) {
     const config = {
-      name: tool46.name,
-      description: tool46.description,
-      schema: tool46.schema,
+      name: tool47.name,
+      description: tool47.description,
+      schema: tool47.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -520,7 +520,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool46
+      client: tool47
     };
     this.register(key, toolLattice);
   }
@@ -546,7 +546,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
 };
 var toolLatticeManager = ToolLatticeManager.getInstance();
 var registerToolLattice = (key, config, executor) => toolLatticeManager.registerLattice(key, config, executor);
-var registerExistingTool = (key, tool46) => toolLatticeManager.registerExistingTool(key, tool46);
+var registerExistingTool = (key, tool47) => toolLatticeManager.registerExistingTool(key, tool47);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -1434,6 +1434,28 @@ var SemanticMetricsClient = class {
     }
     return data.data;
   }
+  /**
+   * Execute a custom SQL query
+   * POST /metrics/query
+   */
+  async executeSqlQuery(request) {
+    const response = await fetch(`${this.baseUrl}/metrics/query`, {
+      method: "POST",
+      headers: {
+        ...this.getHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.code !== 200) {
+      throw new Error(`API error: ${data.message}`);
+    }
+    return data.data;
+  }
   /**
    * Get selected data sources for this configuration
    */
@@ -1889,6 +1911,20 @@ ${serverKeys.map(
   return tool7(
     async (_input, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        if (metricsDataSource) {
+          const { serverKey, datasourceId } = metricsDataSource;
+          return `\u2139\uFE0F **\u5F53\u524D\u5DF2\u9009\u4E2D\u6570\u636E\u6E90**
+
+\u60A8\u5DF2\u901A\u8FC7\u754C\u9762\u9009\u4E2D\u4E86\u7279\u5B9A\u7684\u6570\u636E\u6E90\uFF0C\u6240\u6709 metrics \u67E5\u8BE2\u5C06\u4E13\u6CE8\u4E8E\uFF1A
+- **\u670D\u52A1\u5668**: ${serverKey}
+- **\u6570\u636E\u6E90ID**: ${datasourceId}
+
+\u60A8\u53EF\u4EE5\u76F4\u63A5\u4F7F\u7528\u5176\u4ED6 metrics \u5DE5\u5177\uFF08\u5982 query_metrics_list\u3001query_semantic_metric_data \u7B49\uFF09\uFF0C\u65E0\u9700\u518D\u6307\u5B9A serverKey \u548C datasourceId \u53C2\u6570\u3002
+
+\u5982\u9700\u67E5\u770B\u6240\u6709\u53EF\u7528\u7684\u6570\u636E\u6E90\uFF0C\u8BF7\u6E05\u9664\u5F53\u524D\u9009\u62E9\u6216\u91CD\u65B0\u6253\u5F00\u6570\u636E\u6E90\u9009\u62E9\u5668\u3002`;
+        }
         if (serverKeys.length === 0) {
           return "No metrics servers configured.";
         }
@@ -1984,10 +2020,13 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool8(
     async ({
-      serverKey,
+      serverKey: inputServerKey,
       datasourceIds
     }, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
         if (!serverKey) {
           return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
         }
@@ -1999,7 +2038,7 @@ ${serverKeys.map(
           return `Error: Server "${serverKey}" is not a semantic metrics server. This tool only works with semantic servers.`;
         }
         const client = metricsServerManager.getClient(serverKey);
-        const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : client.getSelectedDataSources();
+        const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : metricsDataSource?.datasourceId ? [metricsDataSource.datasourceId] : client.getSelectedDataSources();
         if (targetDatasourceIds.length === 0) {
           return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
         }
@@ -2047,7 +2086,7 @@ ${serverKeys.map(
         for (const dsId of sortedDatasourceIds) {
           const metrics = metricsByDatasource.get(dsId);
           const sortedMetrics = metrics.sort((a, b) => {
-            if (a.domain !== b.domain) {
+            if (a.domain && a.domain !== b.domain) {
               return a.domain.localeCompare(b.domain);
             }
             return a.metricName.localeCompare(b.metricName);
@@ -2074,8 +2113,8 @@ ${serverKeys.map(
       name: "query_metrics_list",
       description: `${QUERY_METRICS_LIST_DESCRIPTION}${availableServersText}`,
       schema: z9.object({
-        serverKey: z9.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
-        datasourceIds: z9.array(z9.string()).optional().describe("Optional array of datasource IDs to query. If not provided, uses all selected datasources.")
+        serverKey: z9.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
+        datasourceIds: z9.array(z9.string()).optional().describe("Optional array of datasource IDs to query. If not provided, uses all selected datasources or the one configured in runConfig.metricsDataSource.")
       })
     }
   );
@@ -2132,11 +2171,15 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool9(
     async ({
-      serverKey,
+      serverKey: inputServerKey,
       metricName,
-      datasourceId
+      datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
+        const datasourceId = inputDatasourceId || metricsDataSource?.datasourceId;
         if (!serverKey) {
           return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
         }
@@ -2195,12 +2238,20 @@ ${serverKeys.map(
         lines.push(foundDetail.description);
         lines.push("");
         if (foundDetail.defaultTimeContext) {
+          const dtc = foundDetail.defaultTimeContext;
           lines.push(`## \u65F6\u95F4\u4E0A\u4E0B\u6587`);
           lines.push("");
-          lines.push(`- **\u65F6\u95F4\u7EF4\u5EA6**: ${foundDetail.defaultTimeContext.timeDimension} (${foundDetail.defaultTimeContext.label})`);
-          lines.push(`- **\u9ED8\u8BA4\u7C92\u5EA6**: ${foundDetail.defaultTimeContext.granularity}`);
-          lines.push(`- **\u9ED8\u8BA4\u7A97\u53E3**: ${foundDetail.defaultTimeContext.window}`);
-          lines.push(`- **\u652F\u6301\u7684\u7C92\u5EA6**: ${foundDetail.defaultTimeContext.supportedGrains.join("\u3001")}`);
+          if (dtc.timeDimension) {
+            lines.push(`- **\u65F6\u95F4\u7EF4\u5EA6**: ${dtc.timeDimension}${dtc.label ? ` (${dtc.label})` : ""}`);
+          }
+          if (dtc.granularity) {
+            lines.push(`- **\u9ED8\u8BA4\u7C92\u5EA6**: ${dtc.granularity}`);
+          }
+          if (dtc.window) {
+            lines.push(`- **\u9ED8\u8BA4\u7A97\u53E3**: ${dtc.window}`);
+          }
+          const grains = dtc.supportedGrains;
+          lines.push(`- **\u652F\u6301\u7684\u7C92\u5EA6**: ${Array.isArray(grains) && grains.length > 0 ? grains.join("\u3001") : "\u672A\u914D\u7F6E"}`);
           lines.push("");
         }
         if (foundDetail.supportedDimensions && foundDetail.supportedDimensions.length > 0) {
@@ -2264,10 +2315,12 @@ ${serverKeys.map(
           const aiContext = foundDetail.aiAgentContext;
           lines.push(`## AI \u5206\u6790\u4E0A\u4E0B\u6587`);
           lines.push("");
-          lines.push(`### \u6307\u6807\u6781\u6027`);
-          lines.push("");
-          lines.push(aiContext.polarity === "positive" ? "\u6B63\u5411\u6307\u6807\uFF08\u8D8A\u9AD8\u8D8A\u597D\uFF09" : "\u8D1F\u5411\u6307\u6807\uFF08\u8D8A\u4F4E\u8D8A\u597D\uFF09");
-          lines.push("");
+          if (aiContext.polarity) {
+            lines.push(`### \u6307\u6807\u6781\u6027`);
+            lines.push("");
+            lines.push(aiContext.polarity === "positive" ? "\u6B63\u5411\u6307\u6807\uFF08\u8D8A\u9AD8\u8D8A\u597D\uFF09" : "\u8D1F\u5411\u6307\u6807\uFF08\u8D8A\u4F4E\u8D8A\u597D\uFF09");
+            lines.push("");
+          }
           if (aiContext.synonyms && aiContext.synonyms.length > 0) {
             lines.push(`### \u540C\u4E49\u8BCD/\u522B\u540D`);
             lines.push("");
@@ -2290,7 +2343,9 @@ ${serverKeys.map(
             if (aiContext.diagnosticWorkflow.trigger && aiContext.diagnosticWorkflow.trigger.any_of) {
               lines.push(`**\u89E6\u53D1\u6761\u4EF6** (\u6EE1\u8DB3\u4EFB\u4E00):`);
               for (const trigger of aiContext.diagnosticWorkflow.trigger.any_of) {
-                lines.push(`- ${trigger.metric} ${trigger.operator} ${trigger.value}`);
+                if (trigger.metric && trigger.operator) {
+                  lines.push(`- ${trigger.metric} ${trigger.operator} ${trigger.value ?? "N/A"}`);
+                }
               }
               lines.push("");
             }
@@ -2298,14 +2353,17 @@ ${serverKeys.map(
               lines.push(`**\u5206\u6790\u52A8\u4F5C**:`);
               for (let i = 0; i < aiContext.diagnosticWorkflow.actions.length; i++) {
                 const action = aiContext.diagnosticWorkflow.actions[i];
-                lines.push(`${i + 1}. **${action.type}**`);
+                if (!action) continue;
+                lines.push(`${i + 1}. **${action.type ?? "\u672A\u547D\u540D\u52A8\u4F5C"}**`);
                 if (action.metric) {
                   lines.push(`   - \u5BF9\u6BD4\u6307\u6807: ${action.metric}`);
                 }
                 if (action.dimensions && action.dimensions.length > 0) {
                   lines.push(`   - \u4E0B\u94BB\u7EF4\u5EA6: ${action.dimensions.join("\u3001")}`);
                 }
-                lines.push(`   - \u76EE\u7684: ${action.intent}`);
+                if (action.intent) {
+                  lines.push(`   - \u76EE\u7684: ${action.intent}`);
+                }
               }
               lines.push("");
             }
@@ -2339,9 +2397,9 @@ ${serverKeys.map(
       name: "query_metric_definition",
       description: `${QUERY_METRIC_DEFINITION_DESCRIPTION}${availableServersText}`,
       schema: z10.object({
-        serverKey: z10.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        serverKey: z10.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
         metricName: z10.string().describe("The name of the metric to get definition for."),
-        datasourceId: z10.string().optional().describe("Optional specific datasource ID to search in. If not provided, searches all selected datasources.")
+        datasourceId: z10.string().optional().describe("Optional specific datasource ID to search in. If not provided, uses the one configured in runConfig.metricsDataSource or searches all selected datasources.")
       })
     }
   );
@@ -2533,14 +2591,18 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool10(
     async ({
-      serverKey,
-      datasourceId,
+      serverKey: inputServerKey,
+      datasourceId: inputDatasourceId,
       metrics,
       groupBy,
       filters,
       limit
     }, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
+        const datasourceId = metricsDataSource?.datasourceId || inputDatasourceId;
         if (!serverKey) {
           return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
         }
@@ -2563,6 +2625,7 @@ ${serverKeys.map(
           operator: f.operator,
           values: f.values
         }));
+        console.log(`[query_semantic_metric_data] Querying: server=${serverKey}, datasource=${datasourceId}, metrics=[${metrics.join(", ")}], groupBy=[${groupBy?.join(", ") || ""}], filters=${JSON.stringify(filters)}, limit=${limit || 1e3}`);
         const result = await client.semanticQuery({
           datasourceId,
           metrics,
@@ -2583,8 +2646,8 @@ ${serverKeys.map(
       name: "query_semantic_metric_data",
       description: `${QUERY_SEMANTIC_METRIC_DATA_DESCRIPTION}${availableServersText}`,
       schema: z11.object({
-        serverKey: z11.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
-        datasourceId: z11.string().describe("The data source ID to query metrics from."),
+        serverKey: z11.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
+        datasourceId: z11.string().optional().describe("The data source ID to query metrics from. Optional if configured in runConfig.metricsDataSource"),
         metrics: z11.array(z11.string()).describe("Array of metric names to query (e.g., ['net_sales_amt', 'gross_profit'])."),
         groupBy: z11.array(z11.string()).optional().describe("Optional array of dimensions to group by (e.g., ['DocDate__month', 'CustomerCode'])."),
         filters: z11.array(z11.object({
@@ -2611,10 +2674,13 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool11(
     async ({
-      serverKey,
+      serverKey: inputServerKey,
       datasourceIds
     }, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
         if (!serverKey) {
           return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
         }
@@ -2626,7 +2692,7 @@ ${serverKeys.map(
           return `Error: Server "${serverKey}" is not a semantic metrics server. This tool only works with semantic servers.`;
         }
         const client = metricsServerManager.getClient(serverKey);
-        const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : client.getSelectedDataSources();
+        const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : metricsDataSource?.datasourceId ? [metricsDataSource.datasourceId] : client.getSelectedDataSources();
         if (targetDatasourceIds.length === 0) {
           return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
         }
@@ -2686,8 +2752,8 @@ ${serverKeys.map(
       name: "query_tables_list",
       description: `${QUERY_TABLES_LIST_DESCRIPTION}${availableServersText}`,
       schema: z12.object({
-        serverKey: z12.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
-        datasourceIds: z12.array(z12.string()).optional().describe("Optional array of datasource IDs to query. If not provided, uses all selected datasources.")
+        serverKey: z12.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
+        datasourceIds: z12.array(z12.string()).optional().describe("Optional array of datasource IDs to query. If not provided, uses the one configured in runConfig.metricsDataSource or all selected datasources.")
       })
     }
   );
@@ -2706,11 +2772,15 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool12(
     async ({
-      serverKey,
+      serverKey: inputServerKey,
       tableName,
-      datasourceId
+      datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
+        const datasourceId = inputDatasourceId || metricsDataSource?.datasourceId;
         if (!serverKey) {
           return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
         }
@@ -2798,16 +2868,117 @@ ${serverKeys.map(
       name: "query_table_definition",
       description: `${QUERY_TABLE_DEFINITION_DESCRIPTION}${availableServersText}`,
       schema: z13.object({
-        serverKey: z13.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        serverKey: z13.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
         tableName: z13.string().describe("The name of the table to get definition for."),
-        datasourceId: z13.string().optional().describe("Optional specific datasource ID to search in. If not provided, searches all selected datasources.")
+        datasourceId: z13.string().optional().describe("Optional specific datasource ID to search in. If not provided, uses the one configured in runConfig.metricsDataSource or searches all selected datasources.")
       })
     }
   );
 };
 
-// src/tool_lattice/code_eval/index.ts
+// src/tool_lattice/metrics/execute_sql_query.ts
 import z14 from "zod";
+import { tool as tool13 } from "langchain";
+var EXECUTE_SQL_QUERY_DESCRIPTION = `Execute Custom SQL Query - Advanced Data Analysis Tool
+
+Use this tool when you need to perform complex queries that cannot be achieved through the standard semantic metric query interface.
+
+When to Use This Tool:
+- When you need custom aggregations, calculations, or joins
+- When the standard metric query patterns don't meet your requirements
+- When you need to query raw table data with custom filters
+- When you want to perform complex analytical queries (e.g., window functions, CTEs)
+
+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
+
+Prerequisites:
+1. Call list_metrics_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
+
+SQL Query Guidelines:
+- Use named parameters with :paramName syntax (e.g., :year, :category)
+- Provide parameter values in the params object
+- Always use proper table and column names from table definitions
+- Include appropriate WHERE clauses to limit data
+- Use LIMIT to prevent returning too many rows
+
+Example:
+{
+  "serverKey": "production_metrics",
+  "datasourceId": "1",
+  "customSql": "SELECT \\"Code\\" AS period, SUM(\\"LineTotal\\") AS revenue FROM \\"MTC_VW_SalesRevenueCost\\" WHERE \\"Category\\" = :year GROUP BY \\"Code\\" ORDER BY \\"Code\\" ASC",
+  "params": {
+    "year": "2024"
+  },
+  "limit": 1000
+}`;
+var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool13(
+    async ({
+      serverKey: inputServerKey,
+      datasourceId: inputDatasourceId,
+      customSql,
+      params,
+      limit
+    }, _exeConfig) => {
+      try {
+        const runConfig = _exeConfig?.configurable?.runConfig || {};
+        const metricsDataSource = runConfig.metricsDataSource;
+        const serverKey = metricsDataSource?.serverKey || inputServerKey;
+        const datasourceId = metricsDataSource?.datasourceId || inputDatasourceId;
+        if (!serverKey) {
+          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+        }
+        if (!serverKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        }
+        if (!datasourceId) {
+          return "Error: datasourceId parameter is required.";
+        }
+        if (!customSql || customSql.trim().length === 0) {
+          return "Error: customSql parameter is required and cannot be empty.";
+        }
+        const config = metricsServerManager.getConfig(serverKey);
+        if (config.type !== "semantic") {
+          return `Error: Server "${serverKey}" is not a semantic metrics server. This tool only works with semantic servers.`;
+        }
+        const client = metricsServerManager.getClient(serverKey);
+        const result = await client.executeSqlQuery({
+          datasourceId,
+          customSql,
+          params,
+          limit: limit || 1e3
+        });
+        return JSON.stringify(result, null, 2);
+      } catch (error) {
+        return `Error executing SQL query: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "execute_sql_query",
+      description: `${EXECUTE_SQL_QUERY_DESCRIPTION}${availableServersText}`,
+      schema: z14.object({
+        serverKey: z14.string().optional().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}. Optional if configured in runConfig.metricsDataSource`),
+        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).")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/code_eval/index.ts
+import z15 from "zod";
 
 // src/sandbox_lattice/SandboxLatticeManager.ts
 import { SandboxClient } from "@agent-infra/sandbox";
@@ -3046,7 +3217,7 @@ var getSandBoxManager = (key = "default") => {
 };
 
 // src/tool_lattice/code_eval/index.ts
-import { tool as tool13 } from "langchain";
+import { tool as tool14 } from "langchain";
 var CODE_EVAL_DESCRIPTION = `Execute code in Python or JavaScript runtime.
 
 Args:
@@ -3056,7 +3227,7 @@ Args:
 Returns:
     Dict containing output, errors, and execution details`;
 var createCodeEvalTool = ({ isolatedLevel }) => {
-  return tool13(async (input, exe_config) => {
+  return tool14(async (input, exe_config) => {
     try {
       const runConfig = exe_config.configurable?.runConfig;
       const sandboxManager = getSandBoxManager();
@@ -3097,16 +3268,16 @@ ${traceback.join("\n")}`);
   }, {
     name: "execute_code",
     description: CODE_EVAL_DESCRIPTION,
-    schema: z14.object({
-      language: z14.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
-      code: z14.string().describe("Code to execute")
+    schema: z15.object({
+      language: z15.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
+      code: z15.string().describe("Code to execute")
     })
   });
 };
 
 // src/tool_lattice/code_execute_file/index.ts
-import z15 from "zod";
-import { tool as tool14 } from "langchain";
+import z16 from "zod";
+import { tool as tool15 } from "langchain";
 import * as path from "path";
 var CODE_EXECUTE_FILE_DESCRIPTION = `Execute a code file from the sandbox filesystem. Only supports Python (.py) and JavaScript (.js, .mjs) files. Other file types are not supported. The tool reads the file content and executes it in an isolated sandbox environment. Language is automatically inferred from the file extension. Output is returned via stdout; errors appear in stderr and traceback.`;
 function inferLanguageFromPath(filePath) {
@@ -3119,7 +3290,7 @@ function inferLanguageFromPath(filePath) {
   return null;
 }
 var createCodeExecuteFileTool = ({ isolatedLevel }) => {
-  return tool14(
+  return tool15(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3182,15 +3353,15 @@ ${traceback.join("\n")}`);
     {
       name: "execute_code_file",
       description: CODE_EXECUTE_FILE_DESCRIPTION,
-      schema: z15.object({
-        file_path: z15.string().describe("Path to the code file to execute (absolute path in sandbox filesystem). Only supports .py (Python) and .js/.mjs (JavaScript) files.")
+      schema: z16.object({
+        file_path: z16.string().describe("Path to the code file to execute (absolute path in sandbox filesystem). Only supports .py (Python) and .js/.mjs (JavaScript) files.")
       })
     }
   );
 };
 
 // src/tool_lattice/convert_to_markdown/index.ts
-import z16 from "zod";
+import z17 from "zod";
 var CONVERT_TO_MARKDOWN_DESCRIPTION = `Convert a resource described by an http:, https:, file: or data: URI to markdown.
 
 Args:
@@ -3207,8 +3378,8 @@ registerToolLattice(
     name: "convert_to_markdown",
     description: CONVERT_TO_MARKDOWN_DESCRIPTION,
     needUserApprove: false,
-    schema: z16.object({
-      uri: z16.string().describe("The URI to convert.")
+    schema: z17.object({
+      uri: z17.string().describe("The URI to convert.")
     })
   },
   async (input, exe_config) => {
@@ -3231,15 +3402,15 @@ registerToolLattice(
 );
 
 // src/tool_lattice/browser/browser_navigate.ts
-import z17 from "zod";
-import { tool as tool15 } from "langchain";
+import z18 from "zod";
+import { tool as tool16 } from "langchain";
 var BROWSER_NAVIGATE_DESCRIPTION = `Navigate to a URL.
 
 Args:
     url (str): The URL to navigate to.
 `;
 var createBrowserNavigateTool = ({ isolatedLevel }) => {
-  return tool15(
+  return tool16(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3259,23 +3430,23 @@ var createBrowserNavigateTool = ({ isolatedLevel }) => {
     {
       name: "browser_navigate",
       description: BROWSER_NAVIGATE_DESCRIPTION,
-      schema: z17.object({
-        url: z17.string().describe("The URL to navigate to.")
+      schema: z18.object({
+        url: z18.string().describe("The URL to navigate to.")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_click.ts
-import z18 from "zod";
-import { tool as tool16 } from "langchain";
+import z19 from "zod";
+import { tool as tool17 } from "langchain";
 var BROWSER_CLICK_DESCRIPTION = `Click an element on the page, before using the tool, use \`browser_get_clickable_elements\` to get the index of the element, but not call \`browser_get_clickable_elements\` multiple times.
 
 Args:
     index (int): Index of the element to click
 `;
 var createBrowserClickTool = ({ isolatedLevel }) => {
-  return tool16(
+  return tool17(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3295,23 +3466,23 @@ var createBrowserClickTool = ({ isolatedLevel }) => {
     {
       name: "browser_click",
       description: BROWSER_CLICK_DESCRIPTION,
-      schema: z18.object({
-        index: z18.number().describe("Index of the element to click")
+      schema: z19.object({
+        index: z19.number().describe("Index of the element to click")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_text.ts
-import z19 from "zod";
-import { tool as tool17 } from "langchain";
+import z20 from "zod";
+import { tool as tool18 } from "langchain";
 var BROWSER_GET_TEXT_DESCRIPTION = `Get the text content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetTextTool = ({ isolatedLevel }) => {
-  return tool17(
+  return tool18(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3329,21 +3500,21 @@ var createBrowserGetTextTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_text",
       description: BROWSER_GET_TEXT_DESCRIPTION,
-      schema: z19.object({})
+      schema: z20.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_markdown.ts
-import z20 from "zod";
-import { tool as tool18 } from "langchain";
+import z21 from "zod";
+import { tool as tool19 } from "langchain";
 var BROWSER_GET_MARKDOWN_DESCRIPTION = `Get the markdown content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
-  return tool18(
+  return tool19(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3361,21 +3532,21 @@ var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_markdown",
       description: BROWSER_GET_MARKDOWN_DESCRIPTION,
-      schema: z20.object({})
+      schema: z21.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_evaluate.ts
-import z21 from "zod";
-import { tool as tool19 } from "langchain";
+import z22 from "zod";
+import { tool as tool20 } from "langchain";
 var BROWSER_EVALUATE_DESCRIPTION = `Execute JavaScript in the browser console.
 
 Args:
     script (str): JavaScript code to execute, () => { /* code */ }
 `;
 var createBrowserEvaluateTool = ({ isolatedLevel }) => {
-  return tool19(
+  return tool20(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3395,16 +3566,16 @@ var createBrowserEvaluateTool = ({ isolatedLevel }) => {
     {
       name: "browser_evaluate",
       description: BROWSER_EVALUATE_DESCRIPTION,
-      schema: z21.object({
-        script: z21.string().describe("JavaScript code to execute, () => { /* code */ }")
+      schema: z22.object({
+        script: z22.string().describe("JavaScript code to execute, () => { /* code */ }")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_screenshot.ts
-import z22 from "zod";
-import { tool as tool20 } from "langchain";
+import z23 from "zod";
+import { tool as tool21 } from "langchain";
 var BROWSER_SCREENSHOT_DESCRIPTION = `Take a screenshot of the current page or a specific element.
 
 Args:
@@ -3417,7 +3588,7 @@ Args:
     highlight (bool): Highlight the element
 `;
 var createBrowserScreenshotTool = ({ isolatedLevel }) => {
-  return tool20(
+  return tool21(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3469,29 +3640,29 @@ var createBrowserScreenshotTool = ({ isolatedLevel }) => {
     {
       name: "browser_screenshot",
       description: BROWSER_SCREENSHOT_DESCRIPTION,
-      schema: z22.object({
-        name: z22.string().optional().describe("Name for the screenshot"),
-        selector: z22.string().optional().describe("CSS selector for element to screenshot"),
-        index: z22.number().optional().describe("index of the element to screenshot"),
-        width: z22.number().optional().describe("Width in pixels (default: viewport width)"),
-        height: z22.number().optional().describe("Height in pixels (default: viewport height)"),
-        fullPage: z22.boolean().optional().describe("Full page screenshot (default: false)"),
-        highlight: z22.boolean().default(false).describe("Highlight the element")
+      schema: z23.object({
+        name: z23.string().optional().describe("Name for the screenshot"),
+        selector: z23.string().optional().describe("CSS selector for element to screenshot"),
+        index: z23.number().optional().describe("index of the element to screenshot"),
+        width: z23.number().optional().describe("Width in pixels (default: viewport width)"),
+        height: z23.number().optional().describe("Height in pixels (default: viewport height)"),
+        fullPage: z23.boolean().optional().describe("Full page screenshot (default: false)"),
+        highlight: z23.boolean().default(false).describe("Highlight the element")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_scroll.ts
-import z23 from "zod";
-import { tool as tool21 } from "langchain";
+import z24 from "zod";
+import { tool as tool22 } from "langchain";
 var BROWSER_SCROLL_DESCRIPTION = `Scroll the page.
 
 Args:
     amount (int): Pixels to scroll (positive for down, negative for up), if the amount is not provided, scroll to the bottom of the page
 `;
 var createBrowserScrollTool = ({ isolatedLevel }) => {
-  return tool21(
+  return tool22(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3511,16 +3682,16 @@ var createBrowserScrollTool = ({ isolatedLevel }) => {
     {
       name: "browser_scroll",
       description: BROWSER_SCROLL_DESCRIPTION,
-      schema: z23.object({
-        amount: z23.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
+      schema: z24.object({
+        amount: z24.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_form_input_fill.ts
-import z24 from "zod";
-import { tool as tool22 } from "langchain";
+import z25 from "zod";
+import { tool as tool23 } from "langchain";
 var BROWSER_FORM_INPUT_FILL_DESCRIPTION = `Fill out an input field, before using the tool, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -3530,7 +3701,7 @@ Args:
     clear (bool): Whether to clear existing text before filling
 `;
 var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
-  return tool22(
+  return tool23(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3553,19 +3724,19 @@ var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
     {
       name: "browser_form_input_fill",
       description: BROWSER_FORM_INPUT_FILL_DESCRIPTION,
-      schema: z24.object({
-        selector: z24.string().optional().describe("CSS selector for input field"),
-        index: z24.number().optional().describe("Index of the element to fill"),
-        value: z24.string().describe("Value to fill"),
-        clear: z24.boolean().default(false).describe("Whether to clear existing text before filling")
+      schema: z25.object({
+        selector: z25.string().optional().describe("CSS selector for input field"),
+        index: z25.number().optional().describe("Index of the element to fill"),
+        value: z25.string().describe("Value to fill"),
+        clear: z25.boolean().default(false).describe("Whether to clear existing text before filling")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_select.ts
-import z25 from "zod";
-import { tool as tool23 } from "langchain";
+import z26 from "zod";
+import { tool as tool24 } from "langchain";
 var BROWSER_SELECT_DESCRIPTION = `Select an element on the page with index, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -3574,7 +3745,7 @@ Args:
     value (str): Value to select
 `;
 var createBrowserSelectTool = ({ isolatedLevel }) => {
-  return tool23(
+  return tool24(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3596,18 +3767,18 @@ var createBrowserSelectTool = ({ isolatedLevel }) => {
     {
       name: "browser_select",
       description: BROWSER_SELECT_DESCRIPTION,
-      schema: z25.object({
-        index: z25.number().optional().describe("Index of the element to select"),
-        selector: z25.string().optional().describe("CSS selector for element to select"),
-        value: z25.string().describe("Value to select")
+      schema: z26.object({
+        index: z26.number().optional().describe("Index of the element to select"),
+        selector: z26.string().optional().describe("CSS selector for element to select"),
+        value: z26.string().describe("Value to select")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_hover.ts
-import z26 from "zod";
-import { tool as tool24 } from "langchain";
+import z27 from "zod";
+import { tool as tool25 } from "langchain";
 var BROWSER_HOVER_DESCRIPTION = `Hover an element on the page, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -3615,7 +3786,7 @@ Args:
     selector (str): CSS selector for element to hover
 `;
 var createBrowserHoverTool = ({ isolatedLevel }) => {
-  return tool24(
+  return tool25(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3636,24 +3807,24 @@ var createBrowserHoverTool = ({ isolatedLevel }) => {
     {
       name: "browser_hover",
       description: BROWSER_HOVER_DESCRIPTION,
-      schema: z26.object({
-        index: z26.number().optional().describe("Index of the element to hover"),
-        selector: z26.string().optional().describe("CSS selector for element to hover")
+      schema: z27.object({
+        index: z27.number().optional().describe("Index of the element to hover"),
+        selector: z27.string().optional().describe("CSS selector for element to hover")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_back.ts
-import z27 from "zod";
-import { tool as tool25 } from "langchain";
+import z28 from "zod";
+import { tool as tool26 } from "langchain";
 var BROWSER_GO_BACK_DESCRIPTION = `Go back to the previous page.
 
 Args:
     None
 `;
 var createBrowserGoBackTool = ({ isolatedLevel }) => {
-  return tool25(
+  return tool26(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3671,21 +3842,21 @@ var createBrowserGoBackTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_back",
       description: BROWSER_GO_BACK_DESCRIPTION,
-      schema: z27.object({})
+      schema: z28.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_forward.ts
-import z28 from "zod";
-import { tool as tool26 } from "langchain";
+import z29 from "zod";
+import { tool as tool27 } from "langchain";
 var BROWSER_GO_FORWARD_DESCRIPTION = `Go forward to the next page.
 
 Args:
     None
 `;
 var createBrowserGoForwardTool = ({ isolatedLevel }) => {
-  return tool26(
+  return tool27(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3703,21 +3874,21 @@ var createBrowserGoForwardTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_forward",
       description: BROWSER_GO_FORWARD_DESCRIPTION,
-      schema: z28.object({})
+      schema: z29.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_new_tab.ts
-import z29 from "zod";
-import { tool as tool27 } from "langchain";
+import z30 from "zod";
+import { tool as tool28 } from "langchain";
 var BROWSER_NEW_TAB_DESCRIPTION = `Open a new tab.
 
 Args:
     url (str): URL to open in the new tab
 `;
 var createBrowserNewTabTool = ({ isolatedLevel }) => {
-  return tool27(
+  return tool28(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3737,23 +3908,23 @@ var createBrowserNewTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_new_tab",
       description: BROWSER_NEW_TAB_DESCRIPTION,
-      schema: z29.object({
-        url: z29.string().describe("URL to open in the new tab")
+      schema: z30.object({
+        url: z30.string().describe("URL to open in the new tab")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_tab_list.ts
-import z30 from "zod";
-import { tool as tool28 } from "langchain";
+import z31 from "zod";
+import { tool as tool29 } from "langchain";
 var BROWSER_TAB_LIST_DESCRIPTION = `Get the list of tabs.
 
 Args:
     None
 `;
 var createBrowserTabListTool = ({ isolatedLevel }) => {
-  return tool28(
+  return tool29(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3771,21 +3942,21 @@ var createBrowserTabListTool = ({ isolatedLevel }) => {
     {
       name: "browser_tab_list",
       description: BROWSER_TAB_LIST_DESCRIPTION,
-      schema: z30.object({})
+      schema: z31.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_switch_tab.ts
-import z31 from "zod";
-import { tool as tool29 } from "langchain";
+import z32 from "zod";
+import { tool as tool30 } from "langchain";
 var BROWSER_SWITCH_TAB_DESCRIPTION = `Switch to a specific tab.
 
 Args:
     index (int): Tab index to switch to
 `;
 var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
-  return tool29(
+  return tool30(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3805,23 +3976,23 @@ var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_switch_tab",
       description: BROWSER_SWITCH_TAB_DESCRIPTION,
-      schema: z31.object({
-        index: z31.number().describe("Tab index to switch to")
+      schema: z32.object({
+        index: z32.number().describe("Tab index to switch to")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close_tab.ts
-import z32 from "zod";
-import { tool as tool30 } from "langchain";
+import z33 from "zod";
+import { tool as tool31 } from "langchain";
 var BROWSER_CLOSE_TAB_DESCRIPTION = `Close the current tab.
 
 Args:
     None
 `;
 var createBrowserCloseTabTool = ({ isolatedLevel }) => {
-  return tool30(
+  return tool31(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3839,21 +4010,21 @@ var createBrowserCloseTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_close_tab",
       description: BROWSER_CLOSE_TAB_DESCRIPTION,
-      schema: z32.object({})
+      schema: z33.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close.ts
-import z33 from "zod";
-import { tool as tool31 } from "langchain";
+import z34 from "zod";
+import { tool as tool32 } from "langchain";
 var BROWSER_CLOSE_DESCRIPTION = `Close the browser when the task is done and the browser is not needed anymore.
 
 Args:
     None
 `;
 var createBrowserCloseTool = ({ isolatedLevel }) => {
-  return tool31(
+  return tool32(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3871,21 +4042,21 @@ var createBrowserCloseTool = ({ isolatedLevel }) => {
     {
       name: "browser_close",
       description: BROWSER_CLOSE_DESCRIPTION,
-      schema: z33.object({})
+      schema: z34.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_press_key.ts
-import z34 from "zod";
-import { tool as tool32 } from "langchain";
+import z35 from "zod";
+import { tool as tool33 } from "langchain";
 var BROWSER_PRESS_KEY_DESCRIPTION = `Press a key on the keyboard.
 
 Args:
     key (str): Name of the key to press or a character to generate, such as Enter, Tab, Escape, Backspace, Delete, Insert, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, ArrowLeft, ArrowRight, ArrowUp, ArrowDown, PageUp, PageDown, Home, End, ShiftLeft, ShiftRight, ControlLeft, ControlRight, AltLeft, AltRight, MetaLeft, MetaRight, CapsLock, PrintScreen, ScrollLock, Pause, ContextMenu
 `;
 var createBrowserPressKeyTool = ({ isolatedLevel }) => {
-  return tool32(
+  return tool33(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3905,8 +4076,8 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
     {
       name: "browser_press_key",
       description: BROWSER_PRESS_KEY_DESCRIPTION,
-      schema: z34.object({
-        key: z34.enum([
+      schema: z35.object({
+        key: z35.enum([
           "Enter",
           "Tab",
           "Escape",
@@ -3953,15 +4124,15 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
 };
 
 // src/tool_lattice/browser/browser_read_links.ts
-import z35 from "zod";
-import { tool as tool33 } from "langchain";
+import z36 from "zod";
+import { tool as tool34 } from "langchain";
 var BROWSER_READ_LINKS_DESCRIPTION = `Get all links on the current page.
 
 Args:
     None
 `;
 var createBrowserReadLinksTool = ({ isolatedLevel }) => {
-  return tool33(
+  return tool34(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -3979,21 +4150,21 @@ var createBrowserReadLinksTool = ({ isolatedLevel }) => {
     {
       name: "browser_read_links",
       description: BROWSER_READ_LINKS_DESCRIPTION,
-      schema: z35.object({})
+      schema: z36.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_clickable_elements.ts
-import z36 from "zod";
-import { tool as tool34 } from "langchain";
+import z37 from "zod";
+import { tool as tool35 } from "langchain";
 var BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION = `Get the clickable or hoverable or selectable elements on the current page, don't call this tool multiple times.
 
 Args:
     None
 `;
 var createBrowserGetClickableElementsTool = ({ isolatedLevel }) => {
-  return tool34(
+  return tool35(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -4011,21 +4182,21 @@ var createBrowserGetClickableElementsTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_clickable_elements",
       description: BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION,
-      schema: z36.object({})
+      schema: z37.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_download_list.ts
-import z37 from "zod";
-import { tool as tool35 } from "langchain";
+import z38 from "zod";
+import { tool as tool36 } from "langchain";
 var BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION = `Get the list of downloaded files.
 
 Args:
     None
 `;
 var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
-  return tool35(
+  return tool36(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -4043,14 +4214,14 @@ var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_download_list",
       description: BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION,
-      schema: z37.object({})
+      schema: z38.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/get_info.ts
-import z38 from "zod";
-import { tool as tool36 } from "langchain";
+import z39 from "zod";
+import { tool as tool37 } from "langchain";
 var BROWSER_GET_INFO_DESCRIPTION = `Get information about browser, like CDP URL, viewport size, etc.
 
 Args:
@@ -4059,7 +4230,7 @@ Args:
 Returns:
     Dict containing browser information including CDP URL, viewport dimensions, and other browser metadata.`;
 var createBrowserGetInfoTool = ({ isolatedLevel }) => {
-  return tool36(
+  return tool37(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -4077,7 +4248,7 @@ var createBrowserGetInfoTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_info",
       description: BROWSER_GET_INFO_DESCRIPTION,
-      schema: z38.object({})
+      schema: z39.object({})
     }
   );
 };
@@ -5926,11 +6097,11 @@ storeLatticeManager.registerLattice("default", "tenant", defaultTenantStore);
 storeLatticeManager.registerLattice("default", "userTenantLink", defaultUserTenantLinkStore);
 
 // src/tool_lattice/skill/load_skills.ts
-import z39 from "zod";
-import { tool as tool38 } from "langchain";
+import z40 from "zod";
+import { tool as tool39 } from "langchain";
 var LOAD_SKILLS_DESCRIPTION = `Load all available skills and return their metadata (name, description, license, compatibility, metadata, and subSkills) without the content. This tool returns skill information including hierarchical relationships (subSkills). Use this to discover what skills are available and their structure.`;
 var createLoadSkillsTool = ({ skills } = {}) => {
-  return tool38(
+  return tool39(
     async (_input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -5954,17 +6125,17 @@ var createLoadSkillsTool = ({ skills } = {}) => {
     {
       name: "load_skills",
       description: LOAD_SKILLS_DESCRIPTION,
-      schema: z39.object({})
+      schema: z40.object({})
     }
   );
 };
 
 // src/tool_lattice/skill/load_skill_content.ts
-import z40 from "zod";
-import { tool as tool39 } from "langchain";
+import z41 from "zod";
+import { tool as tool40 } from "langchain";
 var LOAD_SKILL_CONTENT_DESCRIPTION = `Load a specific skill's content by name and return its full content including markdown body. This tool returns the complete skill content including frontmatter and markdown body. If the skill has resources, they will be listed at the end of the content with instructions on how to access them. Use this tool to get the complete skill content for a skill that you want to use.`;
 var createLoadSkillContentTool = () => {
-  return tool39(
+  return tool40(
     async (input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -6022,19 +6193,19 @@ ${content}`;
     {
       name: "load_skill_content",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: z40.object({
-        skill_name: z40.string().describe("The name of the skill to load")
+      schema: z41.object({
+        skill_name: z41.string().describe("The name of the skill to load")
       })
     }
   );
 };
 
 // src/tool_lattice/skill/load_skill_resource.ts
-import z41 from "zod";
-import { tool as tool40 } from "langchain";
+import z42 from "zod";
+import { tool as tool41 } from "langchain";
 var LOAD_SKILL_RESOURCE_DESCRIPTION = `Load a specific resource file from a skill's resources directory. Use this tool when you need to access template files, example data, or other resources bundled with a skill. The resource paths are listed in the skill content when using the load_skill_content tool.`;
 var createLoadSkillResourceTool = () => {
-  return tool40(
+  return tool41(
     async (input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -6055,9 +6226,9 @@ var createLoadSkillResourceTool = () => {
     {
       name: "load_skill_resource",
       description: LOAD_SKILL_RESOURCE_DESCRIPTION,
-      schema: z41.object({
-        skill_name: z41.string().describe("The name of the skill containing the resource"),
-        resource_path: z41.string().describe("The path to the resource relative to the skill's resources/ directory")
+      schema: z42.object({
+        skill_name: z42.string().describe("The name of the skill containing the resource"),
+        resource_path: z42.string().describe("The path to the resource relative to the skill's resources/ directory")
       })
     }
   );
@@ -6124,7 +6295,7 @@ ${extraNote}`;
 }
 
 // src/deep_agent_new/middleware/fs.ts
-import { createMiddleware as createMiddleware5, tool as tool41, ToolMessage } from "langchain";
+import { createMiddleware as createMiddleware5, tool as tool42, ToolMessage } from "langchain";
 import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
 import { z as z310 } from "zod/v3";
 import { withLangGraph } from "@langchain/langgraph/zod";
@@ -6623,7 +6794,7 @@ var GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py'
 var GREP_TOOL_DESCRIPTION = "Search for a regex pattern in files. Returns matching files and line numbers";
 function createLsTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6659,7 +6830,7 @@ function createLsTool(backend, options) {
 }
 function createReadFileTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6684,7 +6855,7 @@ function createReadFileTool(backend, options) {
 }
 function createWriteFileTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6723,7 +6894,7 @@ function createWriteFileTool(backend, options) {
 }
 function createEditFileTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6769,7 +6940,7 @@ function createEditFileTool(backend, options) {
 }
 function createGlobTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6797,7 +6968,7 @@ function createGlobTool(backend, options) {
 }
 function createGrepTool(backend, options) {
   const { customDescription } = options;
-  return tool41(
+  return tool42(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -6981,7 +7152,8 @@ function createMetricsMiddleware(params) {
       createQueryMetricDefinitionTool(toolParams),
       createQuerySemanticMetricDataTool(toolParams),
       createQueryTablesListTool(toolParams),
-      createQueryTableDefinitionTool(toolParams)
+      createQueryTableDefinitionTool(toolParams),
+      createExecuteSqlQueryTool(toolParams)
     ]
   });
 }
@@ -7075,9 +7247,9 @@ var ReActAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool46 = getToolClient(t.key);
-      return tool46;
-    }).filter((tool46) => tool46 !== void 0);
+      const tool47 = getToolClient(t.key);
+      return tool47;
+    }).filter((tool47) => tool47 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
@@ -7103,11 +7275,11 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z42 } from "zod/v3";
+import { z as z43 } from "zod/v3";
 import {
   createMiddleware as createMiddleware7,
   createAgent as createAgent2,
-  tool as tool42,
+  tool as tool43,
   ToolMessage as ToolMessage2,
   humanInTheLoopMiddleware
 } from "langchain";
@@ -7429,6 +7601,11 @@ var AgentWorkerState = Annotation.Root({
     reducer: (x, y) => y ?? x,
     default: () => void 0
   }),
+  // RunConfig for passing configuration through the graph
+  runConfig: Annotation({
+    reducer: (x, y) => y ?? x,
+    default: () => void 0
+  }),
   // Execution result
   result: Annotation({
     reducer: (x, y) => y ?? x,
@@ -7446,12 +7623,13 @@ var AgentWorkerState = Annotation.Root({
   })
 });
 async function executeNode(state) {
-  const { assistant_id, thread_id, input, command2 } = state;
+  const { assistant_id, thread_id, input, command2, runConfig } = state;
   const callParams = {
     assistant_id,
     thread_id,
     input,
-    command: command2
+    command: command2,
+    runConfig
   };
   const result = await AgentManager.getInstance().callAgentInQueue(
     callParams,
@@ -7516,7 +7694,7 @@ var DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user
 var EXCLUDED_STATE_KEYS = ["messages", "todos", "jumpTo"];
 var DEFAULT_GENERAL_PURPOSE_DESCRIPTION = "General-purpose agent for researching complex questions, searching for files and content, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. This agent has access to all tools as the main agent.";
 function getTaskToolDescription(subagentDescriptions) {
-  return `
+  return subagentDescriptions.length > 0 ? `
 Launch an ephemeral subagent to handle complex, multi-step independent tasks with isolated context windows.
 
 Available agent types and the tools they have access to:
@@ -7626,7 +7804,7 @@ Since the user is greeting, use the greeting-responder agent to respond with a f
 </commentary>
 assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
 </example>
-  `.trim();
+  `.trim() : "No subagents available, you DON'T NEED TO USE THE TASK TOOL, just use the tools directly.";
 }
 var TASK_SYSTEM_PROMPT = `## \`task\` (subagent spawner)
 
@@ -7713,16 +7891,16 @@ function getSubagents(options) {
   }
   for (const agentParams of subagents) {
     subagentDescriptions.push(
-      `- ${agentParams.name}: ${agentParams.description}`
+      `- ${agentParams.key}: ${agentParams.name} - ${agentParams.description}`
     );
     if ("runnable" in agentParams) {
-      agents[agentParams.name] = agentParams.runnable;
+      agents[agentParams.key] = agentParams.runnable;
     } else {
       const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
         middleware.push(humanInTheLoopMiddleware({ interruptOn }));
-      agents[agentParams.name] = createAgent2({
+      agents[agentParams.key] = createAgent2({
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
@@ -7751,7 +7929,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool42(
+  return tool43(
     async (input, config) => {
       const { description, subagent_type } = input;
       try {
@@ -7770,7 +7948,12 @@ function createTaskTool(options) {
         const workerResult = await agentWorkerGraph.invoke({
           assistant_id: subagent_type,
           thread_id: subagent_thread_id,
-          input: { ...subagentState, message: description }
+          input: { ...subagentState, message: description },
+          runConfig: {
+            ...config.configurable?.runConfig,
+            assistant_id: subagent_type,
+            thread_id: subagent_thread_id
+          }
         });
         const result = workerResult.finalState?.values;
         if (!config.toolCall?.id) {
@@ -7794,9 +7977,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z42.object({
-        description: z42.string().describe("The task to execute with the selected agent"),
-        subagent_type: z42.string().describe(
+      schema: z43.object({
+        description: z43.string().describe("The task to execute with the selected agent"),
+        subagent_type: z43.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -8985,8 +9168,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z43 } from "zod";
-import { createMiddleware as createMiddleware9, tool as tool43, ToolMessage as ToolMessage4 } from "langchain";
+import { z as z44 } from "zod";
+import { createMiddleware as createMiddleware9, tool as tool44, ToolMessage as ToolMessage4 } from "langchain";
 var WRITE_TODOS_DESCRIPTION = `Use this tool to create and manage a structured task list for your current work session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
 It also helps the user understand the progress of the task and overall progress of their requests.
 Only use this tool if you think it will be helpful in staying organized. If the user's request is trivial and takes less than 3 steps, it is better to NOT use this tool and just do the taks directly.
@@ -9213,14 +9396,14 @@ 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 = z43.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z43.object({
-  content: z43.string().describe("Content of the todo item"),
+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"),
   status: TodoStatus
 });
-var stateSchema = z43.object({ todos: z43.array(TodoSchema).default([]) });
+var stateSchema = z44.object({ todos: z44.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool43(
+  const writeTodos = tool44(
     ({ todos }, config) => {
       return new Command3({
         update: {
@@ -9237,8 +9420,8 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z43.object({
-        todos: z43.array(TodoSchema).describe("List of todo items to update")
+      schema: z44.object({
+        todos: z44.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
@@ -9385,10 +9568,11 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool46) => tool46 !== void 0);
+    }).filter((tool47) => tool47 !== void 0);
     const subagents = params.subAgents.map((sa) => {
       if (sa.client) {
         return {
+          key: sa.config.key,
           name: sa.config.name,
           description: sa.config.description,
           runnable: sa.client
@@ -9398,6 +9582,7 @@ var DeepAgentGraphBuilder = class {
           config: sa.config
         });
         return {
+          key: sa.config.key,
           name: sa.config.name,
           description: sa.config.description,
           runnable: subagentClient
@@ -9423,7 +9608,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z46 } from "zod/v3";
+import { z as z47 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -9859,14 +10044,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z45 } from "zod/v3";
-import { createMiddleware as createMiddleware10, createAgent as createAgent4, tool as tool45, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z46 } from "zod/v3";
+import { createMiddleware as createMiddleware10, createAgent as createAgent4, tool as tool46, ToolMessage as ToolMessage6 } 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 z44 } from "zod/v3";
-import { tool as tool44, ToolMessage as ToolMessage5 } from "langchain";
+import { z as z45 } from "zod/v3";
+import { tool as tool45, ToolMessage as ToolMessage5 } from "langchain";
 import { Command as Command4 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -9891,7 +10076,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool44(
+  const claimTaskTool = tool45(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -9916,12 +10101,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: z44.object({
-        task_id: z44.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z45.object({
+        task_id: z45.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool44(
+  const completeTaskTool = tool45(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -9942,13 +10127,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: z44.object({
-        task_id: z44.string().describe("ID of the task to complete"),
-        result: z44.string().describe("Summary of the task result")
+      schema: z45.object({
+        task_id: z45.string().describe("ID of the task to complete"),
+        result: z45.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool44(
+  const failTaskTool = tool45(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -9969,13 +10154,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: z44.object({
-        task_id: z44.string().describe("ID of the task to fail"),
-        error: z44.string().describe("Description of why the task failed")
+      schema: z45.object({
+        task_id: z45.string().describe("ID of the task to fail"),
+        error: z45.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool44(
+  const sendMessageTool = tool45(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -9989,11 +10174,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: z44.object({
-        to: z44.string().describe(
+      schema: z45.object({
+        to: z45.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z44.string().describe("Message content")
+        content: z45.string().describe("Message content")
       })
     }
   );
@@ -10013,7 +10198,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool44(
+  const readMessagesTool = tool45(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -10072,10 +10257,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: z44.object({})
+      schema: z45.object({})
     }
   );
-  const checkTasksTool = tool44(
+  const checkTasksTool = tool45(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -10083,10 +10268,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: z44.object({})
+      schema: z45.object({})
     }
   );
-  const broadcastMessageTool = tool44(
+  const broadcastMessageTool = tool45(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -10105,8 +10290,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: z44.object({
-        content: z44.string().describe("Message content to broadcast to others")
+      schema: z45.object({
+        content: z45.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -10329,7 +10514,7 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool45(
+  const createTeamTool = tool46(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
@@ -10480,20 +10665,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: z45.object({
-        tasks: z45.array(
-          z45.object({
-            id: z45.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z45.string().describe("Short task title"),
-            description: z45.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z45.array(z45.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      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"])')
           })
         ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
-        teammates: z45.array(
-          z45.object({
-            name: z45.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z45.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z45.string().describe("What this teammate will focus on - specific instructions for their work")
+        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")
           })
         ).describe("Teammate agents to create. Each should have a clear role and focus.")
       })
@@ -10504,7 +10689,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 = tool45(
+  const addTasksTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -10556,20 +10741,20 @@ 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: z45.object({
-        tasks: z45.array(
-          z45.object({
-            id: z45.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z45.string().describe("Short task title"),
-            description: z45.string().describe("Detailed task description - what needs to be done"),
-            assignee: z45.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z45.array(z45.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      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")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool45(
+  const assignTaskTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -10591,13 +10776,13 @@ 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: z45.object({
-        task_id: z45.string().describe("Task ID to assign"),
-        assignee: z45.string().describe("Teammate name to assign this task to")
+      schema: z46.object({
+        task_id: z46.string().describe("Task ID to assign"),
+        assignee: z46.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool45(
+  const setTaskStatusTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -10619,13 +10804,13 @@ 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: z45.object({
-        task_id: z45.string().describe("Task ID to update"),
-        status: z45.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      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")
       })
     }
   );
-  const setTaskDependenciesTool = tool45(
+  const setTaskDependenciesTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -10647,13 +10832,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: z45.object({
-        task_id: z45.string().describe("Task ID to update"),
-        dependencies: z45.array(z45.string()).describe("Task IDs that must complete before this task can be claimed")
+      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")
       })
     }
   );
-  const checkTasksTool = tool45(
+  const checkTasksTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -10693,12 +10878,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z45.object({
-        team_id: z45.string().optional().describe("Team ID (omit to use active team)")
+      schema: z46.object({
+        team_id: z46.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool45(
+  const sendMessageTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -10717,13 +10902,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: z45.object({
-        to: z45.string().describe("Recipient teammate name"),
-        content: z45.string().describe("Message content")
+      schema: z46.object({
+        to: z46.string().describe("Recipient teammate name"),
+        content: z46.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool45(
+  const readMessagesTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -10805,12 +10990,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: z45.object({
-        team_id: z45.string().optional().describe("Team ID (omit to use active team)")
+      schema: z46.object({
+        team_id: z46.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool45(
+  const disbandTeamTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -10831,7 +11016,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 = tool45(
+  const broadcastMessageTool = tool46(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -10849,8 +11034,8 @@ 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: z45.object({
-        content: z45.string().describe("Message content to broadcast to all teammates")
+      schema: z46.object({
+        content: z46.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
@@ -10882,37 +11067,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z46.object({
-  name: z46.string().describe("Teammate name"),
-  role: z46.string().describe("Role category (e.g. research, writing, review)"),
-  description: z46.string().describe("What this teammate focuses on")
+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 TeamTaskInfoSchema = z46.object({
-  id: z46.string(),
-  title: z46.string(),
-  description: z46.string(),
-  status: z46.string().optional()
+var TeamTaskInfoSchema = z47.object({
+  id: z47.string(),
+  title: z47.string(),
+  description: z47.string(),
+  status: z47.string().optional()
 });
-var MailboxMessageSchema = z46.object({
-  id: z46.string().describe("Unique message identifier"),
-  from: z46.string().describe("Sender agent name"),
-  to: z46.string().describe("Recipient agent name"),
-  content: z46.string().describe("Message content"),
-  timestamp: z46.string().describe("ISO timestamp when the message was sent"),
-  type: z46.nativeEnum(MessageType).describe("Message type"),
-  read: z46.boolean().describe("Whether the recipient has read this message")
+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 TeamInfoSchema = z46.object({
-  teamId: z46.string().describe("Unique team identifier"),
-  teamLeadId: z46.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z46.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z46.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z46.string().optional().describe("ISO timestamp when team was created")
+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 TEAM_STATE_SCHEMA = z46.object({
+var TEAM_STATE_SCHEMA = z47.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z46.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z46.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  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")
 });
 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:
 
@@ -10992,7 +11177,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool46) => tool46 !== void 0);
+    }).filter((tool47) => tool47 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -13669,10 +13854,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool46 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool46.name}` : tool46.name;
-      tool46.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool46);
+    for (const tool47 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool47.name}` : tool47.name;
+      tool47.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool47);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -13810,6 +13995,7 @@ export {
   checkEmptyContent,
   clearEncryptionKeyCache,
   createAgentTeam,
+  createExecuteSqlQueryTool,
   createFileData,
   createInfoSqlTool,
   createListMetricsDataSourcesTool,