@axiom-lattice/core 2.1.27 → 2.1.29

package/dist/index.mjs

@@ -218,7 +218,10 @@ var ModelLattice = class extends BaseChatModel {
         timeout: config.timeout,
         maxRetries: config.maxRetries || 2,
         apiKey: config.apiKey || process.env[config.apiKeyEnvName || "DEEPSEEK_API_KEY"],
-        streaming: config.streaming
+        streaming: config.streaming,
+        configuration: {
+          baseURL: config.baseURL
+        }
       });
     } else if (config.provider === "siliconcloud") {
       return new ChatOpenAI({
@@ -1911,6 +1914,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 **Current Data Source Selected**
+
+You have selected a specific data source through the interface. All metrics queries will focus on:
+- **Server**: ${serverKey}
+- **Data Source ID**: ${datasourceId}
+
+You can directly use other metrics tools (such as query_metrics_list, query_semantic_metric_data, etc.) without specifying the serverKey and datasourceId parameters.
+
+To view all available data sources, please clear the current selection or reopen the data source selector.`;
+        }
         if (serverKeys.length === 0) {
           return "No metrics servers configured.";
         }
@@ -2006,10 +2023,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(", ");
         }
@@ -2021,7 +2041,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}".`;
         }
@@ -2060,21 +2080,21 @@ ${serverKeys.map(
           }
         }
         if (metricsByDatasource.size === 0) {
-          return `\u672A\u5728\u6307\u5B9A\u7684\u6570\u636E\u6E90\u4E2D\u627E\u5230\u6307\u6807\u3002`;
+          return `No metrics found in the specified data sources.`;
         }
         const lines = [];
-        lines.push(`## \u4E1A\u52A1\u6307\u6807\u5217\u8868\uFF08serverKey: ${serverKey}\uFF09
+        lines.push(`## Business Metrics List (serverKey: ${serverKey})
 `);
         const sortedDatasourceIds = Array.from(metricsByDatasource.keys()).sort();
         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);
           });
-          lines.push(`### datasourceId: ${dsId}\uFF08${metrics.length} \u4E2A\u6307\u6807\uFF09
+          lines.push(`### datasourceId: ${dsId} (${metrics.length} metrics)
 `);
           lines.push("| metricName | displayName | domain | shortDesc |");
           lines.push("|------------|-------------|--------|-----------|");
@@ -2086,7 +2106,7 @@ ${serverKeys.map(
         }
         lines.push("---");
         lines.push("");
-        lines.push("\u5982\u9700\u67E5\u770B\u6307\u6807\u7684\u8BE6\u7EC6\u5B9A\u4E49\uFF0C\u8BF7\u4F7F\u7528 **query_metric_definition** \u5DE5\u5177\uFF0C\u4F20\u5165\u53C2\u6570\uFF1A`serverKey`\u3001`metricName`\u3001`datasourceId`");
+        lines.push("To view detailed metric definitions, use the **query_metric_definition** tool with parameters: `serverKey`, `metricName`, `datasourceId`");
         return lines.join("\n");
       } catch (error) {
         return `Error querying metrics list: ${error instanceof Error ? error.message : String(error)}`;
@@ -2096,8 +2116,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.")
       })
     }
   );
@@ -2154,11 +2174,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(", ");
         }
@@ -2201,143 +2225,158 @@ ${serverKeys.map(
         const lines = [];
         lines.push(`# ${foundDetail.displayName} (${foundDetail.metricName})`);
         lines.push("");
-        lines.push(`## \u57FA\u672C\u4FE1\u606F`);
+        lines.push(`## Basic Information`);
         lines.push("");
-        lines.push(`- **\u6307\u6807\u540D\u79F0**: ${foundDetail.metricName}`);
-        lines.push(`- **\u663E\u793A\u540D\u79F0**: ${foundDetail.displayName}`);
-        lines.push(`- **\u6240\u5C5E\u9886\u57DF**: ${foundDetail.domain}`);
-        lines.push(`- **\u6570\u636E\u7C7B\u578B**: ${foundDetail.dataType}`);
-        lines.push(`- **\u663E\u793A\u683C\u5F0F**: ${foundDetail.format}`);
+        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(`- **\u6570\u636E\u6E90ID**: ${foundDatasourceId}`);
+          lines.push(`- **Data Source ID**: ${foundDatasourceId}`);
         }
         lines.push("");
-        lines.push(`## \u6307\u6807\u63CF\u8FF0`);
+        lines.push(`## Description`);
         lines.push("");
         lines.push(foundDetail.description);
         lines.push("");
         if (foundDetail.defaultTimeContext) {
-          lines.push(`## \u65F6\u95F4\u4E0A\u4E0B\u6587`);
+          const dtc = foundDetail.defaultTimeContext;
+          lines.push(`## Time Context`);
           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(`- **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(`## \u652F\u6301\u7684\u7EF4\u5EA6`);
+          lines.push(`## Supported Dimensions`);
           lines.push("");
           if (categoricalDims.length > 0) {
-            lines.push(`### \u5206\u7C7B\u7EF4\u5EA6 (categorical) - ${categoricalDims.length} \u4E2A`);
-            lines.push("\u652F\u6301 IN\uFF08\u591A\u9009\uFF09\u3001EQ\uFF08\u5355\u9009\uFF09\u64CD\u4F5C\u7B26");
+            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(`// \u5206\u7EC4\u793A\u4F8B`);
+              lines.push(`// Grouping example`);
               lines.push(`"groupBy": ["${dim.dim_id}"]`);
               lines.push("");
-              lines.push(`// \u8FC7\u6EE4\u793A\u4F8B`);
+              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("\u3001");
-              lines.push(`**\u5176\u4ED6 ${categoricalDims.length - 2} \u4E2A\u7EF4\u5EA6**: ${others}`);
+              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(`### \u65F6\u95F4\u7EF4\u5EA6 (datetime) - ${datetimeDims.length} \u4E2A`);
-            lines.push("\u652F\u6301 BETWEEN\uFF08\u8303\u56F4\uFF09\u3001GT/GTE/LT/LTE\uFF08\u6BD4\u8F83\uFF09\u64CD\u4F5C\u7B26");
+            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(`// \u6309\u65F6\u95F4\u7C92\u5EA6\u5206\u7EC4`);
-            lines.push(`"groupBy": ["${primaryDim.dim_id}__month"]  // \u53EF\u9009: day, week, month, year`);
+            lines.push(`// Group by time grain`);
+            lines.push(`"groupBy": ["${primaryDim.dim_id}__month"]  // Options: day, week, month, year`);
             lines.push("");
-            lines.push(`// \u65F6\u95F4\u8303\u56F4\u8FC7\u6EE4`);
+            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("\u3001");
-              lines.push(`**\u5176\u4ED6\u65F6\u95F4\u7EF4\u5EA6**: ${others}`);
+              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("### \u5FEB\u901F\u53C2\u8003");
+          lines.push("### Quick Reference");
           lines.push("");
-          lines.push("**\u65F6\u95F4\u5206\u7EC4\u683C\u5F0F**: `{timeDimension}__{grain}`");
-          lines.push("- \u6309\u5929: `DocDate__day`");
-          lines.push("- \u6309\u5468: `DocDate__week`");
-          lines.push("- \u6309\u6708: `DocDate__month`");
-          lines.push("- \u6309\u5E74: `DocDate__year`");
+          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 \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(`## 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(`### \u540C\u4E49\u8BCD/\u522B\u540D`);
+            lines.push(`### Synonyms/Aliases`);
             lines.push("");
-            lines.push(aiContext.synonyms.join("\u3001"));
+            lines.push(aiContext.synonyms.join(", "));
             lines.push("");
           }
           if (aiContext.thresholds && aiContext.thresholds.length > 0) {
-            lines.push(`### \u9884\u8B66\u9608\u503C`);
+            lines.push(`### Alert Thresholds`);
             lines.push("");
-            lines.push("| \u6307\u6807 | \u8FD0\u7B97\u7B26 | \u9608\u503C | \u7EA7\u522B |");
-            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(`### \u8BCA\u65AD\u5DE5\u4F5C\u6D41`);
+            lines.push(`### Diagnostic Workflow`);
             lines.push("");
             if (aiContext.diagnosticWorkflow.trigger && aiContext.diagnosticWorkflow.trigger.any_of) {
-              lines.push(`**\u89E6\u53D1\u6761\u4EF6** (\u6EE1\u8DB3\u4EFB\u4E00):`);
+              lines.push(`**Trigger Conditions** (satisfy any):`);
               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("");
             }
             if (aiContext.diagnosticWorkflow.actions && aiContext.diagnosticWorkflow.actions.length > 0) {
-              lines.push(`**\u5206\u6790\u52A8\u4F5C**:`);
+              lines.push(`**Analysis Actions**:`);
               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 ?? "Unnamed Action"}**`);
                 if (action.metric) {
-                  lines.push(`   - \u5BF9\u6BD4\u6307\u6807: ${action.metric}`);
+                  lines.push(`   - Comparison Metric: ${action.metric}`);
                 }
                 if (action.dimensions && action.dimensions.length > 0) {
-                  lines.push(`   - \u4E0B\u94BB\u7EF4\u5EA6: ${action.dimensions.join("\u3001")}`);
+                  lines.push(`   - Drill-down Dimensions: ${action.dimensions.join(", ")}`);
+                }
+                if (action.intent) {
+                  lines.push(`   - Intent: ${action.intent}`);
                 }
-                lines.push(`   - \u76EE\u7684: ${action.intent}`);
               }
               lines.push("");
             }
             if (aiContext.diagnosticWorkflow.analysis_logic) {
-              lines.push(`**\u5206\u6790\u903B\u8F91**: ${aiContext.diagnosticWorkflow.analysis_logic}`);
+              lines.push(`**Analysis Logic**: ${aiContext.diagnosticWorkflow.analysis_logic}`);
               lines.push("");
             }
           }
           if (aiContext.humanReadableExplanation) {
-            lines.push(`### \u7CFB\u7EDF\u5EFA\u8BAE`);
+            lines.push(`### System Recommendations`);
             lines.push("");
             lines.push(aiContext.humanReadableExplanation);
             lines.push("");
@@ -2345,9 +2384,9 @@ ${serverKeys.map(
         }
         lines.push(`---`);
         lines.push("");
-        lines.push(`## \u4F7F\u7528\u793A\u4F8B`);
+        lines.push(`## Usage Example`);
         lines.push("");
-        lines.push(`\u67E5\u8BE2\u6B64\u6307\u6807\u65F6\uFF0C\u4F7F\u7528 query_semantic_metric_data \u5DE5\u5177\uFF0C\u53C2\u6570:`);
+        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}"`);
@@ -2361,9 +2400,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.")
       })
     }
   );
@@ -2493,24 +2532,24 @@ function formatSemanticQueryResult(datasourceId, datasourceName, results) {
 Data Source: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`;
   }
   const lines = [];
-  lines.push(`# \u6307\u6807\u67E5\u8BE2\u7ED3\u679C`);
+  lines.push(`# Metric Query Results`);
   lines.push(`
-**\u6570\u636E\u6E90**: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`);
-  lines.push(`**\u6307\u6807\u6570**: ${results.length}`);
+**Data Source**: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`);
+  lines.push(`**Metrics Count**: ${results.length}`);
   lines.push(`
 ---
 `);
   for (const metric of results) {
     lines.push(`## ${metric.displayName} (${metric.metricName})`);
     lines.push(`
-- **\u6570\u636E\u7C7B\u578B**: ${metric.dataType}`);
-    lines.push(`- **\u683C\u5F0F**: ${metric.format}`);
-    lines.push(`- **\u6781\u6027**: ${metric.polarity}`);
-    lines.push(`- **\u6267\u884C\u8017\u65F6**: ${metric.executionTimeMs}ms`);
-    lines.push(`- **\u8FD4\u56DE\u884C\u6570**: ${metric.rowCount}`);
+- **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(`
-### \u6570\u636E
+### Data
 `);
       lines.push(`| ${metric.columns.join(" | ")} |`);
       lines.push(`|${metric.columns.map(() => "---").join("|")}|`);
@@ -2524,17 +2563,17 @@ Data Source: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`;
     }
     if (metric.aiHints) {
       lines.push(`
-### AI \u5206\u6790\u5EFA\u8BAE
+### AI Analysis Suggestions
 `);
-      lines.push(`- **\u6307\u6807\u89E3\u91CA**: ${metric.aiHints.valueInterpretation}`);
+      lines.push(`- **Value Interpretation**: ${metric.aiHints.valueInterpretation}`);
       if (metric.aiHints.thresholds && metric.aiHints.thresholds.length > 0) {
-        lines.push(`- **\u9884\u8B66\u9608\u503C**:`);
+        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(`- **\u5EFA\u8BAE\u540E\u7EED\u5206\u6790**:`);
+        lines.push(`- **Suggested Follow-up Analysis**:`);
         for (const suggestion of metric.aiHints.suggestedFollowup) {
           lines.push(`  - ${suggestion}`);
         }
@@ -2555,14 +2594,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(", ");
         }
@@ -2585,6 +2628,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,
@@ -2605,8 +2649,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({
@@ -2633,10 +2677,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(", ");
         }
@@ -2648,7 +2695,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}".`;
         }
@@ -2683,19 +2730,19 @@ ${serverKeys.map(
           }
         }
         if (allTables.size === 0) {
-          return `\u672A\u5728\u6307\u5B9A\u7684\u6570\u636E\u6E90\u4E2D\u627E\u5230\u6570\u636E\u8868\u3002`;
+          return `No tables found in the specified data sources.`;
         }
         const lines = [];
-        lines.push(`## \u6570\u636E\u8868\u5217\u8868\uFF08\u5171 ${allTables.size} \u4E2A\uFF09
+        lines.push(`## Table List (Total: ${allTables.size})
 `);
         const sortedTables = Array.from(allTables.values()).sort(
           (a, b) => a.tableName.localeCompare(b.tableName)
         );
-        lines.push("| \u8868\u540D | \u663E\u793A\u540D\u79F0 | \u5355\u636E\u7C7B\u578B | \u5217\u6570 | \u63CF\u8FF0 |");
-        lines.push("|------|---------|---------|------|------|");
+        lines.push("| Table Name | Display Name | Document Type | Columns | Description |");
+        lines.push("|------------|--------------|---------------|---------|-------------|");
         for (const table of sortedTables) {
-          const mainTableInfo = table.mainTable ? ` (\u4E3B\u8868: ${table.mainTable})` : "";
-          const lineTableInfo = table.lineTable ? ` (\u884C\u8868: ${table.lineTable})` : "";
+          const mainTableInfo = table.mainTable ? ` (Main: ${table.mainTable})` : "";
+          const lineTableInfo = table.lineTable ? ` (Line: ${table.lineTable})` : "";
           const tableRelation = mainTableInfo + lineTableInfo;
           lines.push(`| ${table.tableName} | ${table.displayName} | ${table.docType}${tableRelation} | ${table.columnCount} | ${table.shortDesc} |`);
         }
@@ -2708,8 +2755,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.")
       })
     }
   );
@@ -2728,11 +2775,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(", ");
         }
@@ -2772,30 +2823,18 @@ ${serverKeys.map(
         const lines = [];
         lines.push(`# ${foundTable.tableName}`);
         lines.push("");
-        lines.push(`## \u57FA\u672C\u4FE1\u606F`);
+        lines.push(`## Basic Information`);
         lines.push("");
-        lines.push(`- **\u8868\u540D**: ${foundTable.tableName}`);
-        lines.push(`- **\u5355\u636E\u7C7B\u578B**: ${foundTable.docType}`);
-        lines.push(`- **\u5355\u636E\u7C7B\u578B(\u82F1\u6587)**: ${foundTable.docTypeEn}`);
-        if (foundTable.objTypeCode) {
-          lines.push(`- **\u5BF9\u8C61\u7C7B\u578B\u4EE3\u7801**: ${foundTable.objTypeCode}`);
-        }
-        if (foundTable.mainTable) {
-          lines.push(`- **\u4E3B\u8868**: ${foundTable.mainTable}`);
-        }
-        if (foundTable.lineTable) {
-          lines.push(`- **\u884C\u8868**: ${foundTable.lineTable}`);
-        }
-        if (foundDatasourceId) {
-          lines.push(`- **\u6570\u636E\u6E90ID**: ${foundDatasourceId}`);
-        }
+        lines.push(`- **Table Name**: ${foundTable.tableName}`);
+        lines.push(`- **Document Type**: ${foundTable.docType}`);
+        lines.push(`- **Document Type (EN)**: ${foundTable.docTypeEn}`);
         lines.push("");
         if (foundTable.columns && foundTable.columns.length > 0) {
           const validColumns = foundTable.columns.filter((col) => col !== null);
-          lines.push(`## \u5217\u5B9A\u4E49 (${validColumns.length} \u5217)`);
+          lines.push(`## Column Definitions (${validColumns.length} columns)`);
           lines.push("");
-          lines.push("| \u5217\u540D | \u6807\u7B7E | \u7C7B\u578B | \u793A\u4F8B\u503C |");
-          lines.push("|------|------|------|--------|");
+          lines.push("| Column Name | Label | Type | Example |");
+          lines.push("|-------------|-------|------|---------|");
           for (const col of validColumns) {
             const type = col.type || "-";
             const example = col.example || "-";
@@ -2803,14 +2842,6 @@ ${serverKeys.map(
           }
           lines.push("");
         }
-        if (foundTable.selectSql) {
-          lines.push(`## SQL \u67E5\u8BE2`);
-          lines.push("");
-          lines.push("```sql");
-          lines.push(foundTable.selectSql);
-          lines.push("```");
-          lines.push("");
-        }
         return lines.join("\n");
       } catch (error) {
         return `Error querying table definition: ${error instanceof Error ? error.message : String(error)}`;
@@ -2820,9 +2851,9 @@ ${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.")
       })
     }
   );
@@ -2876,13 +2907,17 @@ ${serverKeys.map(
   ).join("\n")}` : "";
   return tool13(
     async ({
-      serverKey,
-      datasourceId,
+      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(", ");
         }
@@ -2915,8 +2950,8 @@ ${serverKeys.map(
       name: "execute_sql_query",
       description: `${EXECUTE_SQL_QUERY_DESCRIPTION}${availableServersText}`,
       schema: z14.object({
-        serverKey: z14.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
-        datasourceId: z14.string().describe("The data source ID to execute SQL against."),
+        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).")
@@ -6047,41 +6082,34 @@ storeLatticeManager.registerLattice("default", "userTenantLink", defaultUserTena
 // src/tool_lattice/skill/load_skills.ts
 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 tool39(
-    async (_input, _exe_config) => {
-      try {
-        const storeLattice = getStoreLattice("default", "skill");
-        const skillStore = storeLattice.store;
-        const allSkills = await skillStore.getAllSkills();
-        const filteredSkills = skills && skills.length > 0 ? allSkills.filter((skill) => skills.includes(skill.id)) : allSkills;
-        const skillsMeta = filteredSkills.map((skill) => ({
-          id: skill.id,
-          name: skill.name,
-          description: skill.description,
-          license: skill.license,
-          compatibility: skill.compatibility,
-          metadata: skill.metadata,
-          subSkills: skill.subSkills
-        }));
-        return JSON.stringify(skillsMeta, null, 2);
-      } catch (error) {
-        return `Error loading skills: ${error instanceof Error ? error.message : String(error)}`;
-      }
-    },
-    {
-      name: "load_skills",
-      description: LOAD_SKILLS_DESCRIPTION,
-      schema: z40.object({})
-    }
-  );
-};
 
 // src/tool_lattice/skill/load_skill_content.ts
 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 LOAD_SKILL_CONTENT_DESCRIPTION = `
+Execute a skill within the main conversation
+
+when users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+When users ask you to run a "slash command" or reference "/<something>" (e.g., "/commit", "/review-pr"),they are referring to a skill. Use this tool to invoke the corresponding skill.
+Example:
+	User: "run /commit"
+	Assistant: [Calls Skill tool with skill: "commit"]
+
+How to invoke:
+- Use this tool with the skill name 
+- Examples:
+	- skill: "pdf"  -invoke the pdf skill
+
+Important:
+- When a skill is relevant, you must invoke this tool IMMEDIATELY as your first action
+- NEVER just announce or mention a skill in your text response without actually calling this tool
+- This is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
+- Only use skills listed in "<available_skills>" tag below
+- Do not invoke a skill that is already running
+- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
+- If you see a command-name> tag in the current conversation turn (e.g., <command-name>/commit</command-name>), the skill has ALREADY been loaded and its instructions follow in the next message. 
+Do NOT call this tool - just follow the skill instructions directly.`;
 var createLoadSkillContentTool = () => {
   return tool40(
     async (input, _exe_config) => {
@@ -6139,7 +6167,7 @@ ${content}`;
       }
     },
     {
-      name: "load_skill_content",
+      name: "skill",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
       schema: z41.object({
         skill_name: z41.string().describe("The name of the skill to load")
@@ -6183,25 +6211,16 @@ var createLoadSkillResourceTool = () => {
 };
 
 // src/middlewares/skillMiddleware.ts
-var DEFAULT_HEADING = "To better accomplish the user's objective, you can use the following skills to access best practices.";
-var DEFAULT_EXTRA_NOTE = `
-you must:
-1) systematically evaluate every available skill for relevance,
-2) explicitly activate all skills you judge relevant using the \`load_skill_content\` tool to get the best practices *before* working on the task, and
-3) implement your solution using the guidance and best practices from those activated skills, explaining trade\u2011offs when they matter.
-`;
 function createSkillMiddleware(params = {}) {
   const {
     skills = [],
-    readAll = false,
-    heading = DEFAULT_HEADING,
-    extraNote = DEFAULT_EXTRA_NOTE
+    readAll = false
   } = params;
   let latestSkills = [];
   return createMiddleware4({
     name: "skillMiddleware",
     tools: [
-      createLoadSkillsTool({ skills: readAll ? void 0 : skills }),
+      // createLoadSkillsTool({ skills: readAll ? undefined : skills }),
       createLoadSkillContentTool(),
       createLoadSkillResourceTool()
     ],
@@ -6227,11 +6246,11 @@ function createSkillMiddleware(params = {}) {
 ${skill.description}`).join("\n");
       const skillsAddendum = `
 
-${heading}
+<available_skills>
 
 ${skillsPrompt}
 
-${extraNote}`;
+</available_skills>`;
       const existingSystemPrompt = request.systemPrompt ?? "";
       const newSystemPrompt = existingSystemPrompt.length > 0 ? `${existingSystemPrompt}${skillsAddendum}` : skillsAddendum.trimStart();
       return handler({
@@ -7081,15 +7100,19 @@ ${systemPrompt}` : systemPrompt;
 // src/middlewares/metricsMiddleware.ts
 import { createMiddleware as createMiddleware6 } from "langchain";
 function createMetricsMiddleware(params) {
-  const { serverKeys, serverDescriptions } = params;
-  if (!serverKeys || serverKeys.length === 0) {
+  const { serverKeys, serverDescriptions, connectAll } = params;
+  let effectiveServerKeys = serverKeys;
+  if (connectAll) {
+    effectiveServerKeys = metricsServerManager.getServerKeys().map((s) => s.key);
+  }
+  if (!effectiveServerKeys || effectiveServerKeys.length === 0) {
     return createMiddleware6({
       name: "metricsMiddleware",
       tools: []
     });
   }
   const toolParams = {
-    serverKeys,
+    serverKeys: effectiveServerKeys,
     serverDescriptions
   };
   return createMiddleware6({
@@ -7147,7 +7170,7 @@ function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
       case "metrics":
         {
           const metricsConfig = config.config;
-          if (metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
+          if (metricsConfig.connectAll || metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
             middlewares.push(createMetricsMiddleware(metricsConfig));
           }
         }
@@ -7549,6 +7572,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,
@@ -7566,12 +7594,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,
@@ -7636,7 +7665,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:
@@ -7746,7 +7775,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)
 
@@ -7833,16 +7862,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,
@@ -7890,7 +7919,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) {
@@ -9509,6 +9543,7 @@ var DeepAgentGraphBuilder = class {
     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
@@ -9518,6 +9553,7 @@ var DeepAgentGraphBuilder = class {
           config: sa.config
         });
         return {
+          key: sa.config.key,
           name: sa.config.name,
           description: sa.config.description,
           runnable: subagentClient