@axiom-lattice/core 2.1.33 → 2.1.35

package/dist/index.mjs

@@ -338,7 +338,7 @@ var ModelLattice = class extends BaseChatModel {
         streaming: config.streaming
       });
     } else if (config.provider === "deepseek") {
-      return new ChatDeepSeek({
+      const deepseek = new ChatDeepSeek({
         model: config.model,
         temperature: config.temperature || 0,
         maxTokens: config.maxTokens,
@@ -346,10 +346,12 @@ var ModelLattice = class extends BaseChatModel {
         maxRetries: config.maxRetries || 2,
         apiKey: config.apiKey || process.env[config.apiKeyEnvName || "DEEPSEEK_API_KEY"],
         streaming: config.streaming,
+        enable_thinking: true,
         configuration: {
           baseURL: config.baseURL
         }
       });
+      return deepseek;
     } else if (config.provider === "siliconcloud") {
       return new ChatOpenAI({
         model: config.model,
@@ -1432,6 +1434,37 @@ ${databaseKeys.map(
   );
 };
 
+// src/tool_lattice/metrics/utils.ts
+function getTenantIdFromConfig2(exeConfig, getTenantId) {
+  const runConfig = exeConfig?.configurable?.runConfig || {};
+  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+}
+function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
+  return serverKeys.filter((key) => {
+    return manager.hasServer(tenantId, key);
+  });
+}
+function arrayRowsToObjectRows(rows, columns) {
+  if (!rows || rows.length === 0) {
+    return [];
+  }
+  return rows.map((row) => {
+    const obj = {};
+    columns.forEach((col, index) => {
+      obj[col.name] = row[index];
+    });
+    return obj;
+  });
+}
+function objectRowsToArrayRows(rows, columns) {
+  if (!rows || rows.length === 0) {
+    return [];
+  }
+  return rows.map(
+    (row) => columns.map((col) => row[col])
+  );
+}
+
 // src/tool_lattice/metrics/SemanticMetricsClient.ts
 var SemanticMetricsClient = class {
   constructor(config) {
@@ -1561,15 +1594,34 @@ var SemanticMetricsClient = class {
       limit: 1e3
     };
     const result = await this.semanticQuery(request);
-    const metricResult = result.results.find((r) => r.metricName === metricName);
-    const dataPoints = metricResult?.rows.map((row, index) => ({
-      timestamp: index * 1e3,
-      // Use index as timestamp if not provided
-      value: typeof row.value === "number" ? row.value : 0,
-      labels: Object.fromEntries(
-        Object.entries(row).map(([k, v]) => [k, String(v)])
-      )
-    })) || [];
+    const dataPoints = [];
+    if (result.rows && result.rows.length > 0) {
+      const columnNames = result.columns.map((col) => col.name);
+      result.rows.forEach((row, index) => {
+        const rowObj = {};
+        columnNames.forEach((colName, colIndex) => {
+          rowObj[colName] = row[colIndex];
+        });
+        dataPoints.push({
+          timestamp: index * 1e3,
+          // Use index as timestamp if not provided
+          value: typeof rowObj[metricName] === "number" ? rowObj[metricName] : 0,
+          labels: Object.fromEntries(
+            Object.entries(rowObj).map(([k, v]) => [k, String(v)])
+          )
+        });
+      });
+    } else if (result.rowsObject && result.rowsObject.length > 0) {
+      result.rowsObject.forEach((row, index) => {
+        dataPoints.push({
+          timestamp: index * 1e3,
+          value: typeof row[metricName] === "number" ? row[metricName] : 0,
+          labels: Object.fromEntries(
+            Object.entries(row).map(([k, v]) => [k, String(v)])
+          )
+        });
+      });
+    }
     return {
       metricName,
       dataPoints,
@@ -1630,30 +1682,92 @@ var SemanticMetricsClient = class {
   /**
    * Execute a semantic metrics query
    * POST /metrics/query
+   *
+   * @param request - Query request with optional format parameter
+   * @returns Standardized query response based on format specification
    */
   async semanticQuery(request) {
+    const format = request.format ?? "array";
     const response = await fetch(`${this.baseUrl}/metrics/query`, {
       method: "POST",
       headers: {
         ...this.getHeaders(),
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(request)
+      body: JSON.stringify({ ...request, debug: true })
     });
     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}`);
+    const apiResponse = await response.json();
+    if (apiResponse.code !== 200) {
+      throw new Error(`API error: ${apiResponse.message}`);
     }
-    return data.data;
+    const data = apiResponse.data;
+    const result = {
+      semanticModel: data.semanticModel,
+      columns: data.columns,
+      rowCount: data.rows?.length ?? 0
+    };
+    if (format === "array" || format === "both") {
+      result.rows = data.rows;
+    }
+    if (format === "object" || format === "both") {
+      result.rowsObject = arrayRowsToObjectRows(data.rows, data.columns);
+    }
+    return result;
+  }
+  /**
+   * Execute a table query
+   * GET /api/metrics/table/{tableName}
+   *
+   * @param request - Table query request with optional format parameter
+   * @returns Standardized table query response based on format specification
+   */
+  async tableQuery(request) {
+    const format = request.format ?? "object";
+    const { tableName, limit = 20 } = request;
+    const queryParams = new URLSearchParams();
+    queryParams.append("limit", limit.toString());
+    const response = await fetch(
+      `${this.baseUrl}/api/metrics/table/${encodeURIComponent(tableName)}?${queryParams}`,
+      {
+        method: "GET",
+        headers: this.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const apiResponse = await response.json();
+    if (apiResponse.code !== 200) {
+      throw new Error(`API error: ${apiResponse.message}`);
+    }
+    const data = apiResponse.data;
+    const result = {
+      tableName: data.tableName,
+      columns: data.columns,
+      rowCount: data.rowCount,
+      executionTimeMs: data.executionTimeMs,
+      executedSql: data.executedSql
+    };
+    if (format === "object" || format === "both") {
+      result.rowsObject = data.rows;
+    }
+    if (format === "array" || format === "both") {
+      result.rows = objectRowsToArrayRows(data.rows, data.columns);
+    }
+    return result;
   }
   /**
    * Execute a custom SQL query
    * POST /metrics/query
+   *
+   * @param request - SQL query request with optional format parameter
+   * @returns Standardized query response based on format specification
    */
   async executeSqlQuery(request) {
+    const format = request.format ?? "object";
     const response = await fetch(`${this.baseUrl}/metrics/query`, {
       method: "POST",
       headers: {
@@ -1665,11 +1779,27 @@ var SemanticMetricsClient = class {
     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}`);
+    const apiResponse = await response.json();
+    if (apiResponse.code !== 200) {
+      throw new Error(`API error: ${apiResponse.message}`);
+    }
+    const data = apiResponse.data;
+    const result = {
+      datasourceId: data.datasourceId,
+      datasourceName: data.datasourceName,
+      tableName: data.tableName,
+      columns: data.columns,
+      rowCount: data.rowCount,
+      executionTimeMs: data.executionTimeMs,
+      executedSql: data.executedSql
+    };
+    if (format === "object" || format === "both") {
+      result.rowsObject = data.rows;
     }
-    return data.data;
+    if (format === "array" || format === "both") {
+      result.rows = objectRowsToArrayRows(data.rows, data.columns);
+    }
+    return result;
   }
   /**
    * Get selected data sources for this configuration
@@ -2158,19 +2288,6 @@ var metricsServerManager = MetricsServerManager.getInstance();
 // src/tool_lattice/metrics/list_metrics_servers.ts
 import z7 from "zod";
 import { tool as tool6 } from "langchain";
-
-// src/tool_lattice/metrics/utils.ts
-function getTenantIdFromConfig2(exeConfig, getTenantId) {
-  const runConfig = exeConfig?.configurable?.runConfig || {};
-  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
-}
-function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
-  return serverKeys.filter((key) => {
-    return manager.hasServer(tenantId, key);
-  });
-}
-
-// src/tool_lattice/metrics/list_metrics_servers.ts
 var LIST_METRICS_SERVERS_DESCRIPTION = `List all registered metrics servers. Returns a list of available metrics servers with their keys and types. Use this tool first to understand what metrics servers are available.`;
 var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId }) => {
   const availableServersText = serverKeys.length > 0 ? `
@@ -2545,176 +2662,7 @@ ${serverKeys.map(
         if (!foundDetail) {
           return `Metric "${metricName}" not found in the specified data sources.`;
         }
-        const lines = [];
-        lines.push(`# ${foundDetail.displayName} (${foundDetail.metricName})`);
-        lines.push("");
-        lines.push(`## Basic Information`);
-        lines.push("");
-        lines.push(`- **Metric Name**: ${foundDetail.metricName}`);
-        lines.push(`- **Display Name**: ${foundDetail.displayName}`);
-        lines.push(`- **Domain**: ${foundDetail.domain}`);
-        lines.push(`- **Data Type**: ${foundDetail.dataType}`);
-        lines.push(`- **Format**: ${foundDetail.format}`);
-        if (foundDatasourceId) {
-          lines.push(`- **Data Source ID**: ${foundDatasourceId}`);
-        }
-        lines.push("");
-        lines.push(`## Description`);
-        lines.push("");
-        lines.push(foundDetail.description);
-        lines.push("");
-        if (foundDetail.defaultTimeContext) {
-          const dtc = foundDetail.defaultTimeContext;
-          lines.push(`## Time Context`);
-          lines.push("");
-          if (dtc.timeDimension) {
-            lines.push(`- **Time Dimension**: ${dtc.timeDimension}${dtc.label ? ` (${dtc.label})` : ""}`);
-          }
-          if (dtc.granularity) {
-            lines.push(`- **Default Granularity**: ${dtc.granularity}`);
-          }
-          if (dtc.window) {
-            lines.push(`- **Default Window**: ${dtc.window}`);
-          }
-          const grains = dtc.supportedGrains;
-          lines.push(`- **Supported Grains**: ${Array.isArray(grains) && grains.length > 0 ? grains.join(", ") : "Not configured"}`);
-          lines.push("");
-        }
-        if (foundDetail.supportedDimensions && foundDetail.supportedDimensions.length > 0) {
-          const categoricalDims = foundDetail.supportedDimensions.filter((d) => d.type === "categorical");
-          const datetimeDims = foundDetail.supportedDimensions.filter((d) => d.type === "datetime");
-          const timeDimension = foundDetail.defaultTimeContext?.timeDimension;
-          lines.push(`## Supported Dimensions`);
-          lines.push("");
-          if (categoricalDims.length > 0) {
-            lines.push(`### Categorical Dimensions - ${categoricalDims.length}`);
-            lines.push("Supports IN (multiple), EQ (single) operators");
-            lines.push("");
-            const examples = categoricalDims.slice(0, 2);
-            for (const dim of examples) {
-              lines.push(`**${dim.dim_id}** (${dim.field_name})`);
-              lines.push("```json");
-              lines.push(`// Grouping example`);
-              lines.push(`"groupBy": ["${dim.dim_id}"]`);
-              lines.push("");
-              lines.push(`// Filter example`);
-              lines.push(`{"dimension": "${dim.dim_id}", "operator": "IN", "values": ["value1", "value2"]}`);
-              lines.push("```");
-              lines.push("");
-            }
-            if (categoricalDims.length > 2) {
-              const others = categoricalDims.slice(2).map((d) => d.dim_id).join(", ");
-              lines.push(`**Other ${categoricalDims.length - 2} dimensions**: ${others}`);
-              lines.push("");
-            }
-          }
-          if (datetimeDims.length > 0) {
-            lines.push(`### Datetime Dimensions - ${datetimeDims.length}`);
-            lines.push("Supports BETWEEN (range), GT/GTE/LT/LTE (comparison) operators");
-            lines.push("");
-            const primaryDim = datetimeDims.find((d) => d.dim_id === timeDimension) || datetimeDims[0];
-            lines.push(`**${primaryDim.dim_id}** (${primaryDim.field_name})`);
-            lines.push("```json");
-            lines.push(`// Group by time grain`);
-            lines.push(`"groupBy": ["${primaryDim.dim_id}__month"]  // Options: day, week, month, year`);
-            lines.push("");
-            lines.push(`// Time range filter`);
-            lines.push(`{"dimension": "${primaryDim.dim_id}", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"]}`);
-            lines.push("```");
-            lines.push("");
-            if (datetimeDims.length > 1) {
-              const others = datetimeDims.filter((d) => d.dim_id !== primaryDim.dim_id).map((d) => d.dim_id).join(", ");
-              lines.push(`**Other time dimensions**: ${others}`);
-              lines.push("");
-            }
-          }
-          lines.push("### Quick Reference");
-          lines.push("");
-          lines.push("**Time grouping format**: `{timeDimension}__{grain}`");
-          lines.push("- By day: `DocDate__day`");
-          lines.push("- By week: `DocDate__week`");
-          lines.push("- By month: `DocDate__month`");
-          lines.push("- By year: `DocDate__year`");
-          lines.push("");
-        }
-        if (foundDetail.aiAgentContext) {
-          const aiContext = foundDetail.aiAgentContext;
-          lines.push(`## AI Analysis Context`);
-          lines.push("");
-          if (aiContext.polarity) {
-            lines.push(`### Metric Polarity`);
-            lines.push("");
-            lines.push(aiContext.polarity === "positive" ? "Positive metric (higher is better)" : "Negative metric (lower is better)");
-            lines.push("");
-          }
-          if (aiContext.synonyms && aiContext.synonyms.length > 0) {
-            lines.push(`### Synonyms/Aliases`);
-            lines.push("");
-            lines.push(aiContext.synonyms.join(", "));
-            lines.push("");
-          }
-          if (aiContext.thresholds && aiContext.thresholds.length > 0) {
-            lines.push(`### Alert Thresholds`);
-            lines.push("");
-            lines.push("| Metric | Operator | Threshold | Level |");
-            lines.push("|--------|----------|-----------|-------|");
-            for (const t of aiContext.thresholds) {
-              lines.push(`| ${t.metric} | ${t.operator} | ${t.value} | ${t.level} |`);
-            }
-            lines.push("");
-          }
-          if (aiContext.diagnosticWorkflow) {
-            lines.push(`### Diagnostic Workflow`);
-            lines.push("");
-            if (aiContext.diagnosticWorkflow.trigger && aiContext.diagnosticWorkflow.trigger.any_of) {
-              lines.push(`**Trigger Conditions** (satisfy any):`);
-              for (const trigger of aiContext.diagnosticWorkflow.trigger.any_of) {
-                if (trigger.metric && trigger.operator) {
-                  lines.push(`- ${trigger.metric} ${trigger.operator} ${trigger.value ?? "N/A"}`);
-                }
-              }
-              lines.push("");
-            }
-            if (aiContext.diagnosticWorkflow.actions && aiContext.diagnosticWorkflow.actions.length > 0) {
-              lines.push(`**Analysis Actions**:`);
-              for (let i = 0; i < aiContext.diagnosticWorkflow.actions.length; i++) {
-                const action = aiContext.diagnosticWorkflow.actions[i];
-                if (!action) continue;
-                lines.push(`${i + 1}. **${action.type ?? "Unnamed Action"}**`);
-                if (action.metric) {
-                  lines.push(`   - Comparison Metric: ${action.metric}`);
-                }
-                if (action.dimensions && action.dimensions.length > 0) {
-                  lines.push(`   - Drill-down Dimensions: ${action.dimensions.join(", ")}`);
-                }
-                if (action.intent) {
-                  lines.push(`   - Intent: ${action.intent}`);
-                }
-              }
-              lines.push("");
-            }
-            if (aiContext.diagnosticWorkflow.analysis_logic) {
-              lines.push(`**Analysis Logic**: ${aiContext.diagnosticWorkflow.analysis_logic}`);
-              lines.push("");
-            }
-          }
-          if (aiContext.humanReadableExplanation) {
-            lines.push(`### System Recommendations`);
-            lines.push("");
-            lines.push(aiContext.humanReadableExplanation);
-            lines.push("");
-          }
-        }
-        lines.push(`---`);
-        lines.push("");
-        lines.push(`## Usage Example`);
-        lines.push("");
-        lines.push(`To query this metric, use the query_semantic_metric_data tool with parameters:`);
-        lines.push(`- **metricName**: "${foundDetail.metricName}"`);
-        if (foundDatasourceId) {
-          lines.push(`- **datasourceId**: "${foundDatasourceId}"`);
-        }
-        return lines.join("\n");
+        return JSON.stringify(foundDetail, null, 2);
       } catch (error) {
         return `Error querying metric definition: ${error instanceof Error ? error.message : String(error)}`;
       }
@@ -2752,11 +2700,19 @@ Skip using this tool when:
 Prerequisites - MUST Complete First
 1. Call query_metrics_list to discover available metrics
 2. Call query_metric_definition(metricName) to get:
-   - defaultTimeContext.timeDimension (e.g., "DocDate")
+   - defaultTimeContext.timeDimension (e.g., "DocDate","date")
    - defaultTimeContext.supportedGrains (e.g., ["day", "week", "month", "year"])
    - supportedDimensions[].dim_id (use these for groupBy and filters)
    - supportedDimensions[].filter_operators (allowed operators per dimension)
 
+   **Rules**:
+   - To filter by date: Copy the pattern and replace values
+     \`\`\`json
+     {"dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"]}
+     \`\`\`
+   - To group by time: Use \`"{timeDimension}__{supportedGrain}"\` format (e.g., \`"date__month"\`)
+
+
 The Five Query Patterns
 
 Pattern A - Time Trend (most common first query)
@@ -2764,8 +2720,8 @@ Goal: Show how a metric changes over time within a period
 {
   "metrics": ["order_amt_tax_inc"],
   "groupBy": ["DocDate__month"],
-  "filters": [{ "dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"] }],
-  "orderBy": [{ "field": "DocDate__month", "direction": "ASC" }]
+  "filters": [{ "dimension": "date", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"] }],
+  "orderBy": [{ "field": "date__month", "direction": "ASC" }]
 }
 
 Pattern B - Dimension Breakdown (who/what is top or bottom)
@@ -2830,82 +2786,50 @@ Common Mistakes to Avoid
 - Omitting date filter entirely - ALWAYS include at least one DocDate filter
 - Querying a metric by an unsupported dimension - only use dim_id from supportedDimensions
 - Putting display name in orderBy.field - must match exactly what's in groupBy
-
-Recommended Analysis Flow
-User question
-      |
-      \u25BC
-Step 1: query_metrics_list - find matching metric(s)
-      |
-      \u25BC
-Step 2: query_metric_definition - read defaultTimeContext + supportedDimensions
-      |
-      \u25BC
-Step 3a: Pattern A (time trend) - get the big picture
-      |
-      \u251C\u2500 anomaly found? \u2500\u2500\u25BA Step 3c: Pattern C (drill down)
-      \u251C\u2500 user asks "who"? \u2500\u2500\u25BA Step 3b: Pattern B (dimension breakdown)
-      \u2514\u2500 user asks "compare X and Y"? \u2500\u2500\u25BA Step 3d: Pattern D (multi-metric)
-
-Debug Mode
-Set "debug": true to receive executedSqls in the response to verify generated SQL.`;
-function formatSemanticQueryResult(datasourceId, datasourceName, results) {
-  if (results.length === 0) {
+`;
+function formatSemanticQueryResult(result) {
+  const { semanticModel, columns, rowCount } = result;
+  if (!columns || columns.length === 0 || rowCount === 0) {
     return `No data found for the specified query.
-Data Source: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`;
+Semantic Model: ${semanticModel}`;
   }
   const lines = [];
   lines.push(`# Metric Query Results`);
   lines.push(`
-**Data Source**: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`);
-  lines.push(`**Metrics Count**: ${results.length}`);
+**Semantic Model**: ${semanticModel}`);
+  lines.push(`**Columns**: ${columns.length}`);
+  lines.push(`**Rows**: ${rowCount}`);
   lines.push(`
 ---
 `);
-  for (const metric of results) {
-    lines.push(`## ${metric.displayName} (${metric.metricName})`);
-    lines.push(`
-- **Data Type**: ${metric.dataType}`);
-    lines.push(`- **Format**: ${metric.format}`);
-    lines.push(`- **Polarity**: ${metric.polarity}`);
-    lines.push(`- **Execution Time**: ${metric.executionTimeMs}ms`);
-    lines.push(`- **Rows Returned**: ${metric.rowCount}`);
-    if (metric.columns.length > 0 && metric.rows.length > 0) {
-      lines.push(`
-### Data
+  const rows = result.rowsObject ?? result.rows ?? [];
+  if (rows.length === 0) {
+    lines.push(`*No data rows returned*
 `);
-      lines.push(`| ${metric.columns.join(" | ")} |`);
-      lines.push(`|${metric.columns.map(() => "---").join("|")}|`);
-      for (const row of metric.rows) {
-        const rowValues = metric.columns.map((col) => {
-          const val = row[col];
-          return val !== void 0 ? String(val) : "";
-        });
-        lines.push(`| ${rowValues.join(" | ")} |`);
-      }
-    }
-    if (metric.aiHints) {
-      lines.push(`
-### AI Analysis Suggestions
+    return lines.join("\n");
+  }
+  const columnNames = columns.map((col) => col.name);
+  lines.push(`## Data
 `);
-      lines.push(`- **Value Interpretation**: ${metric.aiHints.valueInterpretation}`);
-      if (metric.aiHints.thresholds && metric.aiHints.thresholds.length > 0) {
-        lines.push(`- **Alert Thresholds**:`);
-        for (const t of metric.aiHints.thresholds) {
-          lines.push(`  - ${t.metric} ${t.operator} ${t.value} (${t.level})`);
-        }
-      }
-      if (metric.aiHints.suggestedFollowup && metric.aiHints.suggestedFollowup.length > 0) {
-        lines.push(`- **Suggested Follow-up Analysis**:`);
-        for (const suggestion of metric.aiHints.suggestedFollowup) {
-          lines.push(`  - ${suggestion}`);
-        }
-      }
+  lines.push(`| ${columnNames.join(" | ")} |`);
+  lines.push(`|${columnNames.map(() => "---").join("|")}|`);
+  if (result.rowsObject) {
+    for (const row of result.rowsObject) {
+      const rowValues = columnNames.map((col) => {
+        const val = row[col];
+        return val !== void 0 && val !== null ? String(val) : "";
+      });
+      lines.push(`| ${rowValues.join(" | ")} |`);
     }
-    lines.push(`
+  } else if (result.rows) {
+    for (const row of result.rows) {
+      const rowValues = row.map((val) => val !== void 0 && val !== null ? String(val) : "");
+      lines.push(`| ${rowValues.join(" | ")} |`);
+    }
+  }
+  lines.push(`
 ---
 `);
-  }
   return lines.join("\n");
 }
 var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
@@ -2965,11 +2889,7 @@ ${serverKeys.map(
           filters: semanticFilters,
           limit: limit || 1e3
         });
-        return formatSemanticQueryResult(
-          result.datasourceId,
-          result.datasourceName,
-          result.results
-        );
+        return formatSemanticQueryResult(result);
       } catch (error) {
         return `Error querying semantic metric data: ${error instanceof Error ? error.message : String(error)}`;
       }
@@ -3288,7 +3208,7 @@ ${serverKeys.map(
           params,
           limit: limit || 100
         });
-        const rows = result.result?.rows || [];
+        const rows = result.rowsObject ?? result.rows ?? [];
         return "query_result:\n" + JSON.stringify(rows, null, 2);
       } catch (error) {
         return `Error executing SQL query: ${error instanceof Error ? error.message : String(error)}`;
@@ -8313,7 +8233,7 @@ var ReActAgentGraphBuilder = class {
       let workingDirectory = "/";
       if (workspaceId && projectId) {
         if (tenantId) {
-          workingDirectory = `/tenants/${tenantId}/${workspaceId}/${projectId}`;
+          workingDirectory = `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
         } else {
           workingDirectory = `/${workspaceId}/${projectId}`;
         }
@@ -8715,6 +8635,7 @@ async function executeNode(state) {
   const { assistant_id, thread_id, input, command2, runConfig } = state;
   const callParams = {
     assistant_id,
+    "x-tenant-id": runConfig?.tenantId,
     thread_id,
     input,
     command: command2,
@@ -8971,7 +8892,9 @@ function getSubagents(options) {
       model: defaultModel,
       systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
-      middleware: generalPurposeMiddleware
+      middleware: generalPurposeMiddleware,
+      checkpointer: getCheckpointSaver("default"),
+      name: "general-purpose"
     });
     agents["general-purpose"] = generalPurposeSubagent;
     subagentDescriptions.push(
@@ -8993,7 +8916,8 @@ function getSubagents(options) {
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
-        middleware
+        middleware,
+        checkpointer: getCheckpointSaver("default")
       });
     }
   }
@@ -9021,6 +8945,24 @@ function createTaskTool(options) {
   return tool44(
     async (input, config) => {
       const { description, subagent_type } = input;
+      let assistant_id = subagent_type;
+      if (subagent_type === "general-purpose") {
+        assistant_id = config.configurable?.runConfig?.assistant_id + "-general-purpose";
+        const hasAgentLattice = agentLatticeManager.hasAgentLatticeWithTenant(config.configurable?.runConfig?.tenantId, assistant_id);
+        if (!hasAgentLattice) {
+          const client = subagentGraphs["general-purpose"];
+          agentLatticeManager.registerWithTenant(config.configurable?.runConfig?.tenantId, assistant_id, {
+            config: {
+              key: assistant_id,
+              name: "general-purpose",
+              description: DEFAULT_GENERAL_PURPOSE_DESCRIPTION,
+              type: AgentType.REACT,
+              prompt: DEFAULT_SUBAGENT_PROMPT
+            },
+            client
+          });
+        }
+      }
       try {
         if (!(subagent_type in subagentGraphs)) {
           const allowedTypes = Object.keys(subagentGraphs).map((k) => `\`${k}\``).join(", ");
@@ -9028,19 +8970,18 @@ function createTaskTool(options) {
             `Error: invoked agent of type ${subagent_type}, the only allowed types are ${allowedTypes}`
           );
         }
-        const subagent = subagentGraphs[subagent_type];
         const currentState = getCurrentTaskInput2();
         const subagentState = filterStateForSubagent(currentState);
         subagentState.messages = [new HumanMessage({ content: description })];
-        const subagent_thread_id = config.configurable?.thread_id + "____" + subagent_type + "_" + config.toolCall.id;
+        const subagent_thread_id = config.configurable?.thread_id + "____" + assistant_id + "_" + config.toolCall.id;
         console.log(subagent_thread_id);
         const workerResult = await agentWorkerGraph.invoke({
-          assistant_id: subagent_type,
+          assistant_id,
           thread_id: subagent_thread_id,
           input: { ...subagentState, message: description },
           runConfig: {
             ...config.configurable?.runConfig,
-            assistant_id: subagent_type,
+            assistant_id,
             thread_id: subagent_thread_id
           }
         });
@@ -10580,11 +10521,12 @@ ${BASE_PROMPT}` : BASE_PROMPT;
           unsupportedModelBehavior: "ignore"
         }),
         // Subagent middleware: Patches tool calls for compatibility
-        createPatchToolCallsMiddleware()
+        createPatchToolCallsMiddleware(),
+        ...customMiddleware
       ],
       defaultInterruptOn: interruptOn,
       subagents,
-      generalPurposeAgent: false
+      generalPurposeAgent: true
     }),
     // Automatically summarizes conversation history when token limits are approached
     summarizationMiddleware({
@@ -11565,14 +11507,19 @@ You have access to these tools:
     middleware: [...teamMiddleware ?? [], ...spec.middleware ?? []],
     checkpointer: getCheckpointSaver("default")
   });
-  registerTeammateAgent(assistantId, agent);
+  registerTeammateAgent(assistantId, agent, ctx.tenantId);
   const teammateThreadId = ctx.parentThreadId ? `${ctx.parentThreadId}____${ctx.teamId}_${spec.name}` : `standalone_${ctx.teamId}_${spec.name}`;
   const startMessage = "Start working";
   try {
     await agentWorkerGraph.invoke({
       assistant_id: assistantId,
       thread_id: teammateThreadId,
-      input: { message: startMessage, messages: [{ role: "human", content: startMessage }] }
+      input: { message: startMessage, messages: [{ role: "human", content: startMessage }] },
+      runConfig: {
+        tenantId: ctx.tenantId,
+        workspaceId: ctx.workspaceId,
+        projectId: ctx.projectId
+      }
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : "Unknown error during teammate execution";
@@ -11596,7 +11543,10 @@ async function spawnTeammate(options) {
     defaultModel,
     parentThreadId = "",
     teamTools,
-    teamMiddleware
+    teamMiddleware,
+    tenantId,
+    workspaceId,
+    projectId
   } = options;
   const ctx = {
     teamId,
@@ -11608,12 +11558,15 @@ async function spawnTeammate(options) {
     defaultModel,
     pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
     scheduleLatticeKey: DEFAULT_SCHEDULE_LATTICE_KEY,
-    agentCache: /* @__PURE__ */ new Map()
+    agentCache: /* @__PURE__ */ new Map(),
+    tenantId,
+    workspaceId,
+    projectId
   };
   await getOrCreateTeammateAgent(ctx, spec, teamTools, teamMiddleware);
 }
 function createTeamMiddleware(options) {
-  const { teamConfig, taskListStore, mailboxStore } = options;
+  const { teamConfig, taskListStore, mailboxStore, tenantId } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
   const createTeamTool = tool47(
     async (input, config) => {
@@ -11660,6 +11613,7 @@ function createTeamMiddleware(options) {
         await mailboxStore.registerAgent(teamId, spec.name);
       }
       const parentThreadId = config.configurable?.thread_id ?? "";
+      const runConfig = config.configurable?.runConfig;
       matchedSpecs.forEach((spec) => {
         void spawnTeammate({
           teamId,
@@ -11670,7 +11624,10 @@ function createTeamMiddleware(options) {
           defaultModel,
           parentThreadId,
           teamTools: teamConfig.tools,
-          teamMiddleware: teamConfig.middleware
+          teamMiddleware: teamConfig.middleware,
+          tenantId,
+          workspaceId: runConfig?.workspaceId,
+          projectId: runConfig?.projectId
         });
       });
       const teamJson = JSON.stringify({
@@ -12240,7 +12197,8 @@ function createAgentTeam(config) {
   const teamMiddleware = createTeamMiddleware({
     teamConfig: teamConfigWithFs,
     taskListStore,
-    mailboxStore
+    mailboxStore,
+    tenantId: config.tenantId
   });
   const middleware = [
     teamMiddleware,
@@ -12307,7 +12265,8 @@ var TeamAgentGraphBuilder = class {
       scheduleLatticeKey: config.scheduleLatticeKey,
       pollIntervalMs: config.pollIntervalMs,
       backend: filesystemBackend,
-      middleware: middlewares
+      middleware: middlewares,
+      tenantId: params.tenantId
     };
     const teamLead = createAgentTeam(teamConfig);
     return teamLead;
@@ -12671,8 +12630,9 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    *
    * @param key Unique key (e.g. `team:${teamId}:${agentName}`)
    * @param client Pre-built AgentClient (ReactAgent or CompiledGraph)
+   * @param tenantId Tenant ID (required)
    */
-  registerTeammateAgent(key, client) {
+  registerTeammateAgent(key, client, tenantId) {
     const agentLattice = {
       config: {
         key,
@@ -12682,7 +12642,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
       },
       client
     };
-    this.register(key, agentLattice);
+    this.registerWithTenant(tenantId, key, agentLattice);
   }
   /**
    * Unregister a teammate agent. Call when a team is done to clean up.
@@ -12802,7 +12762,11 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
       this.initializeClient(tenantId, key);
       return this.getAgentLatticeWithTenant(tenantId, key);
     });
-    return paramsBuilder.buildParams(agentLattice, options);
+    const params = paramsBuilder.buildParams(agentLattice, options);
+    return {
+      ...params,
+      tenantId
+    };
   }
   /**
    * Create an AgentClient from AgentLattice config
@@ -12886,7 +12850,7 @@ var registerAgentLattices = (tenantId, configs) => {
 var getAgentConfig = (key) => agentLatticeManager.getAgentConfig(key);
 var getAllAgentConfigs = () => agentLatticeManager.getAllAgentConfigs();
 var validateAgentInput = (key, input) => agentLatticeManager.validateAgentInput(key, input);
-var registerTeammateAgent = (key, client) => agentLatticeManager.registerTeammateAgent(key, client);
+var registerTeammateAgent = (key, client, tenantId) => agentLatticeManager.registerTeammateAgent(key, client, tenantId);
 var unregisterTeammateAgent = (key) => agentLatticeManager.unregisterTeammateAgent(key);
 var getAgentClient = (tenantId, key, options) => agentLatticeManager.initializeClient(tenantId, key, options);
 var createAgentClientFromAgentLattice = async (agentLattice, options) => await agentLatticeManager.createAgentClientFromConfig(agentLattice, options);