@axiom-lattice/core 2.1.24 → 2.1.25

package/dist/index.mjs

@@ -508,11 +508,11 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
    * @param key Lattice键名
    * @param tool 已有的StructuredTool实例
    */
-  registerExistingTool(key, tool38) {
+  registerExistingTool(key, tool46) {
     const config = {
-      name: tool38.name,
-      description: tool38.description,
-      schema: tool38.schema,
+      name: tool46.name,
+      description: tool46.description,
+      schema: tool46.schema,
       // StructuredTool的schema已经是Zod兼容的
       needUserApprove: false
       // MCP工具默认不需要用户批准
@@ -520,7 +520,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool38
+      client: tool46
     };
     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, tool38) => toolLatticeManager.registerExistingTool(key, tool38);
+var registerExistingTool = (key, tool46) => toolLatticeManager.registerExistingTool(key, tool46);
 var getToolLattice = (key) => toolLatticeManager.getToolLattice(key);
 var getToolDefinition = (key) => toolLatticeManager.getToolDefinition(key);
 var getToolClient = (key) => toolLatticeManager.getToolClient(key);
@@ -1217,8 +1217,1595 @@ ${databaseKeys.map(
   );
 };
 
+// src/tool_lattice/metrics/SemanticMetricsClient.ts
+var SemanticMetricsClient = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.serverUrl.replace(/\/$/, "");
+  }
+  /**
+   * Test connection to the semantic metrics server
+   * Attempts to fetch data sources as a connectivity test
+   */
+  async testConnection() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch(`${this.baseUrl}/datasources`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      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 latency = Date.now() - startTime;
+      return { connected: true, latency };
+    } catch (error) {
+      return {
+        connected: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get list of available metrics from all selected data sources
+   * Aggregates metrics across selected datasources
+   */
+  async listMetrics() {
+    const selectedIds = this.config.selectedDataSources || [];
+    if (selectedIds.length === 0) {
+      return [];
+    }
+    const allMetrics = [];
+    const seenMetrics = /* @__PURE__ */ new Set();
+    for (const datasourceId of selectedIds) {
+      try {
+        const metaData = await this.getDatasourceMetrics(datasourceId);
+        for (const item of metaData.index.metrics) {
+          if (!seenMetrics.has(item.metricName)) {
+            seenMetrics.add(item.metricName);
+            const detail = metaData.metricsDetails.find((d) => d.metricName === item.metricName);
+            allMetrics.push({
+              name: item.metricName,
+              type: detail?.dataType || "number",
+              description: item.shortDesc || detail?.description,
+              labels: [],
+              unit: void 0
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to get metrics for datasource ${datasourceId}:`, error);
+      }
+    }
+    return allMetrics;
+  }
+  /**
+   * Get metadata for a specific metric
+   * Searches across selected datasources for the metric
+   */
+  async getMetricMeta(metricName) {
+    const selectedIds = this.config.selectedDataSources || [];
+    for (const datasourceId of selectedIds) {
+      try {
+        const metaData = await this.getDatasourceMetrics(datasourceId);
+        const item = metaData.index.metrics.find((m) => m.metricName === metricName);
+        if (item) {
+          const detail = metaData.metricsDetails.find((d) => d.metricName === metricName);
+          return {
+            name: item.metricName,
+            type: detail?.dataType || "number",
+            description: item.shortDesc || detail?.description,
+            labels: [],
+            unit: void 0
+          };
+        }
+      } catch (error) {
+        console.warn(`Failed to get metric meta from datasource ${datasourceId}:`, error);
+      }
+    }
+    return null;
+  }
+  /**
+   * Query metric data - delegates to semanticQuery
+   * Note: For semantic server, use semanticQuery() directly for full functionality
+   */
+  async queryMetricData(metricName, options) {
+    const selectedIds = this.config.selectedDataSources || [];
+    if (selectedIds.length === 0) {
+      throw new Error("No data sources selected for this semantic metrics server");
+    }
+    const datasourceId = selectedIds[0];
+    const filters = [];
+    if (options.startTime && options.endTime) {
+      filters.push({
+        dimension: "timestamp",
+        operator: "BETWEEN",
+        values: [
+          new Date(options.startTime * 1e3).toISOString(),
+          new Date(options.endTime * 1e3).toISOString()
+        ]
+      });
+    }
+    if (options.labels) {
+      for (const [key, value] of Object.entries(options.labels)) {
+        filters.push({
+          dimension: key,
+          operator: "=",
+          values: [value]
+        });
+      }
+    }
+    const request = {
+      datasourceId,
+      metrics: [metricName],
+      filters,
+      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)])
+      )
+    })) || [];
+    return {
+      metricName,
+      dataPoints,
+      metadata: {
+        startTime: options.startTime ? options.startTime * 1e3 : void 0,
+        endTime: options.endTime ? options.endTime * 1e3 : void 0
+      }
+    };
+  }
+  /**
+   * Get the server type
+   */
+  getServerType() {
+    return "semantic";
+  }
+  /**
+   * Get all available data sources from the semantic server
+   * GET /datasources
+   */
+  async getDataSources() {
+    const response = await fetch(`${this.baseUrl}/datasources`, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    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 metrics meta for a specific data source
+   * GET /datasources/{id}/meta
+   */
+  async getDatasourceMetrics(datasourceId) {
+    const response = await fetch(
+      `${this.baseUrl}/datasources/${encodeURIComponent(datasourceId)}/meta`,
+      {
+        method: "GET",
+        headers: this.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        return { index: { datasourceId: 0, datasourceName: "", catalogVersion: "", domainCategories: [], metrics: [], tables: [] }, metricsDetails: [] };
+      }
+      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;
+  }
+  /**
+   * Execute a semantic metrics query
+   * POST /metrics/query
+   */
+  async semanticQuery(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
+   */
+  getSelectedDataSources() {
+    return this.config.selectedDataSources || [];
+  }
+  /**
+   * Build request headers with authentication
+   */
+  getHeaders() {
+    const headers = {
+      Accept: "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.username && this.config.password) {
+      const auth = Buffer.from(`${this.config.username}:${this.config.password}`).toString("base64");
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    return headers;
+  }
+};
+
+// src/tool_lattice/metrics/MetricsServerManager.ts
+var PrometheusClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async testConnection() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch(`${this.config.serverUrl}/api/v1/status/buildinfo`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const latency = Date.now() - startTime;
+      return { connected: true, latency };
+    } catch (error) {
+      return {
+        connected: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async listMetrics() {
+    try {
+      const response = await fetch(`${this.config.serverUrl}/api/v1/label/__name__/values`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.status !== "success") {
+        throw new Error(`Prometheus error: ${data.error || "Unknown error"}`);
+      }
+      const metrics = [];
+      for (const name of data.data || []) {
+        const meta = await this.getMetricMeta(name);
+        if (meta) {
+          metrics.push(meta);
+        } else {
+          metrics.push({ name });
+        }
+      }
+      return metrics;
+    } catch (error) {
+      throw new Error(`Failed to list metrics: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getMetricMeta(metricName) {
+    try {
+      const response = await fetch(
+        `${this.config.serverUrl}/api/v1/metadata?metric=${encodeURIComponent(metricName)}`,
+        {
+          method: "GET",
+          headers: this.getHeaders()
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.status !== "success" || !data.data[metricName]) {
+        return { name: metricName };
+      }
+      const metadata = data.data[metricName][0];
+      return {
+        name: metricName,
+        type: metadata.type,
+        description: metadata.help,
+        unit: metadata.unit
+      };
+    } catch (error) {
+      console.warn(`Failed to get metric metadata for ${metricName}:`, error);
+      return { name: metricName };
+    }
+  }
+  async queryMetricData(metricName, options) {
+    const endTime = options.endTime || Math.floor(Date.now() / 1e3);
+    const startTime = options.startTime || endTime - 3600;
+    const step = options.step || 60;
+    let query = metricName;
+    if (options.labels && Object.keys(options.labels).length > 0) {
+      const labelSelectors = Object.entries(options.labels).map(([key, value]) => `${key}="${value}"`).join(",");
+      query = `${metricName}{${labelSelectors}}`;
+    }
+    try {
+      const response = await fetch(
+        `${this.config.serverUrl}/api/v1/query_range?query=${encodeURIComponent(query)}&start=${startTime}&end=${endTime}&step=${step}`,
+        {
+          method: "GET",
+          headers: this.getHeaders()
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.status !== "success") {
+        throw new Error(`Prometheus error: ${data.error || "Unknown error"}`);
+      }
+      const dataPoints = [];
+      const result = data.data?.result || [];
+      for (const series of result) {
+        const labels = series.metric || {};
+        for (const [timestamp, value] of series.values || []) {
+          dataPoints.push({
+            timestamp: parseFloat(timestamp) * 1e3,
+            // Convert to milliseconds
+            value: parseFloat(value),
+            labels
+          });
+        }
+      }
+      return {
+        metricName,
+        dataPoints,
+        metadata: {
+          startTime: startTime * 1e3,
+          endTime: endTime * 1e3,
+          step: step * 1e3
+        }
+      };
+    } catch (error) {
+      throw new Error(`Failed to query metric data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getServerType() {
+    return "prometheus";
+  }
+  getHeaders() {
+    const headers = {
+      Accept: "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.username && this.config.password) {
+      const auth = Buffer.from(`${this.config.username}:${this.config.password}`).toString("base64");
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    return headers;
+  }
+};
+var CustomMetricsClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async testConnection() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch(`${this.config.serverUrl}/health`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const latency = Date.now() - startTime;
+      return { connected: true, latency };
+    } catch (error) {
+      return {
+        connected: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async listMetrics() {
+    try {
+      const response = await fetch(`${this.config.serverUrl}/api/metrics`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.metrics || [];
+    } catch (error) {
+      throw new Error(`Failed to list metrics: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getMetricMeta(metricName) {
+    try {
+      const response = await fetch(
+        `${this.config.serverUrl}/api/metrics/${encodeURIComponent(metricName)}/meta`,
+        {
+          method: "GET",
+          headers: this.getHeaders()
+        }
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Failed to get metric metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async queryMetricData(metricName, options) {
+    try {
+      const queryParams = new URLSearchParams();
+      if (options.startTime) queryParams.append("start", options.startTime.toString());
+      if (options.endTime) queryParams.append("end", options.endTime.toString());
+      if (options.step) queryParams.append("step", options.step.toString());
+      if (options.labels) {
+        queryParams.append("labels", JSON.stringify(options.labels));
+      }
+      const response = await fetch(
+        `${this.config.serverUrl}/api/metrics/${encodeURIComponent(metricName)}/data?${queryParams}`,
+        {
+          method: "GET",
+          headers: this.getHeaders()
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Failed to query metric data: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getServerType() {
+    return "custom";
+  }
+  getHeaders() {
+    const headers = {
+      Accept: "application/json",
+      ...this.config.headers
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    } else if (this.config.username && this.config.password) {
+      const auth = Buffer.from(`${this.config.username}:${this.config.password}`).toString("base64");
+      headers["Authorization"] = `Basic ${auth}`;
+    }
+    return headers;
+  }
+};
+var MetricsServerManager = class _MetricsServerManager {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+    this.configs = /* @__PURE__ */ new Map();
+    this.defaultServerKey = null;
+  }
+  /**
+   * Get the singleton instance
+   */
+  static getInstance() {
+    if (!_MetricsServerManager.instance) {
+      _MetricsServerManager.instance = new _MetricsServerManager();
+    }
+    return _MetricsServerManager.instance;
+  }
+  /**
+   * Register a metrics server
+   * @param key - Unique identifier for the server
+   * @param config - Metrics server configuration
+   */
+  registerServer(key, config) {
+    let client;
+    switch (config.type) {
+      case "prometheus":
+        client = new PrometheusClient(config);
+        break;
+      case "custom":
+        client = new CustomMetricsClient(config);
+        break;
+      case "semantic":
+        client = new SemanticMetricsClient(config);
+        break;
+      default:
+        throw new Error(`Unsupported metrics server type: ${config.type}`);
+    }
+    this.clients.set(key, client);
+    this.configs.set(key, config);
+    if (this.defaultServerKey === null) {
+      this.defaultServerKey = key;
+    }
+  }
+  /**
+   * Set the default metrics server
+   * @param key - Server key to set as default
+   */
+  setDefaultServer(key) {
+    if (!this.clients.has(key)) {
+      throw new Error(`Metrics server '${key}' not found`);
+    }
+    this.defaultServerKey = key;
+  }
+  /**
+   * Get a metrics server client by key
+   * @param key - Server key (optional, uses default if not provided)
+   */
+  getClient(key) {
+    const serverKey = key || this.defaultServerKey;
+    if (!serverKey) {
+      throw new Error("No metrics server registered");
+    }
+    const client = this.clients.get(serverKey);
+    if (!client) {
+      throw new Error(`Metrics server '${serverKey}' not found`);
+    }
+    return client;
+  }
+  /**
+   * Get metrics server configuration by key
+   * @param key - Server key (optional, uses default if not provided)
+   */
+  getConfig(key) {
+    const serverKey = key || this.defaultServerKey;
+    if (!serverKey) {
+      throw new Error("No metrics server registered");
+    }
+    const config = this.configs.get(serverKey);
+    if (!config) {
+      throw new Error(`Metrics server '${serverKey}' not found`);
+    }
+    return config;
+  }
+  /**
+   * Check if a metrics server is registered
+   * @param key - Server key
+   */
+  hasServer(key) {
+    return this.clients.has(key);
+  }
+  /**
+   * Get all registered metrics server keys with their types
+   */
+  getServerKeys() {
+    return Array.from(this.configs.entries()).map(([key, config]) => ({
+      key,
+      type: config.type
+    }));
+  }
+  /**
+   * Remove a metrics server
+   * @param key - Server key
+   */
+  removeServer(key) {
+    this.clients.delete(key);
+    this.configs.delete(key);
+    if (this.defaultServerKey === key) {
+      this.defaultServerKey = this.clients.size > 0 ? this.clients.keys().next().value || null : null;
+    }
+  }
+  /**
+   * Load metrics server configurations from a store
+   * and register them with this manager
+   *
+   * @param store - The metrics server configuration store
+   * @param tenantId - Tenant identifier
+   */
+  async loadConfigsFromStore(store, tenantId) {
+    const configs = await store.getAllConfigs(tenantId);
+    for (const entry of configs) {
+      this.registerServer(entry.key, entry.config);
+    }
+  }
+  /**
+   * Load all metrics server configurations from a store
+   * across all tenants and register them with this manager
+   *
+   * @param store - The metrics server configuration store
+   */
+  async loadAllConfigsFromStore(store) {
+    const configs = await store.getAllConfigsWithoutTenant();
+    for (const entry of configs) {
+      this.registerServer(entry.key, entry.config);
+    }
+  }
+};
+var metricsServerManager = MetricsServerManager.getInstance();
+
+// src/tool_lattice/metrics/list_metrics_servers.ts
+import z7 from "zod";
+import { tool as tool6 } from "langchain";
+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 }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool6(
+    async (_input, _exeConfig) => {
+      try {
+        const servers = metricsServerManager.getServerKeys();
+        if (servers.length === 0) {
+          return "No metrics servers registered.";
+        }
+        const lines = servers.map(({ key, type }) => {
+          const desc = serverDescriptions?.[key] ? ` - ${serverDescriptions[key]}` : "";
+          return `- ${key} (${type})${desc}`;
+        });
+        return `Available metrics servers:
+${lines.join("\n")}`;
+      } catch (error) {
+        return `Error listing metrics servers: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "list_metrics_servers",
+      description: `${LIST_METRICS_SERVERS_DESCRIPTION}${availableServersText}`,
+      schema: z7.object({})
+    }
+  );
+};
+
+// src/tool_lattice/metrics/list_metrics_datasources.ts
+import z8 from "zod";
+import { tool as tool7 } from "langchain";
+var LIST_METRICS_DATASOURCES_DESCRIPTION = `List all available datasources from all configured metrics servers. Returns a table with Server Key, DataSource ID, and DataSource Name. Use this tool first to discover what datasources are available before querying metrics.`;
+var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Configured metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool7(
+    async (_input, _exeConfig) => {
+      try {
+        if (serverKeys.length === 0) {
+          return "No metrics servers configured.";
+        }
+        const allDataSources = [];
+        for (const serverKey of serverKeys) {
+          try {
+            const config = metricsServerManager.getConfig(serverKey);
+            if (config.type !== "semantic") {
+              console.warn(`Server "${serverKey}" is not a semantic metrics server, skipping.`);
+              continue;
+            }
+            const client = metricsServerManager.getClient(serverKey);
+            const dataSources = await client.getDataSources();
+            for (const ds of dataSources) {
+              allDataSources.push({
+                serverKey,
+                datasourceId: String(ds.id),
+                datasourceName: ds.name || String(ds.id)
+              });
+            }
+          } catch (error) {
+            console.warn(`Failed to get datasources from server "${serverKey}":`, error);
+          }
+        }
+        if (allDataSources.length === 0) {
+          return `No datasources found in any configured metrics servers.`;
+        }
+        const lines = [];
+        lines.push(`Found ${allDataSources.length} datasource(s) from ${serverKeys.length} server(s):
+`);
+        lines.push("| Server Key | DataSource ID | Name |");
+        lines.push("|------------|---------------|------|");
+        for (const ds of allDataSources) {
+          lines.push(`| ${ds.serverKey} | ${ds.datasourceId} | ${ds.datasourceName} |`);
+        }
+        lines.push("\nUse the Server Key and DataSource ID when calling other metrics tools.");
+        return lines.join("\n");
+      } catch (error) {
+        return `Error listing datasources: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      name: "list_metrics_datasources",
+      description: `${LIST_METRICS_DATASOURCES_DESCRIPTION}${availableServersText}`,
+      schema: z8.object({})
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_metrics_list.ts
+import z9 from "zod";
+import { tool as tool8 } from "langchain";
+var QUERY_METRICS_LIST_DESCRIPTION = `Query Available Metrics - Step 1 of the Metrics Workflow
+
+Discover what metrics exist in the semantic metrics server. This tool returns a list of available metrics with their domains and descriptions.
+
+When to Use This Tool
+Use this tool proactively in these scenarios:
+- When the user asks about business metrics but does not specify exact metric names
+- When you need to find metrics matching a specific domain (e.g., "sales performance", "pricing")
+- At the start of ANY metrics-related conversation to understand available data
+- When the user asks "what metrics do we have?" or "show me available KPIs"
+
+When NOT to Use This Tool
+Skip using this tool when:
+- The user has already provided exact metric names (proceed directly to query_metric_definition)
+- You have cached metric metadata from a recent call (within the same conversation)
+- The query is purely about retrieving data, not discovering what's available
+
+The Three-Step Metrics Workflow
+1. query_metrics_list (THIS TOOL) \u2192 discover available metrics
+2. query_metric_definition \u2192 read metric metadata before querying
+3. query_semantic_metric_data \u2192 execute the query with correct parameters
+
+Response Fields Reference
+| Field | How to Use It |
+|-------|---------------|
+| metricName | The identifier passed to query_metric_definition and query_semantic_metric_data |
+| domain | Groups related metrics (e.g., sales_performance, pricing_and_margin) |
+| shortDesc | One-line description to present to the user |
+| displayName | Human-readable name of the metric |
+
+Next Step
+After finding relevant metrics, call query_metric_definition with the metricName to get detailed metadata including time dimensions and supported filters.`;
+var createQueryMetricsListTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool8(
+    async ({
+      serverKey,
+      datasourceIds
+    }, _exeConfig) => {
+      try {
+        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(", ")}]`;
+        }
+        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 targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : client.getSelectedDataSources();
+        if (targetDatasourceIds.length === 0) {
+          return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
+        }
+        const allMetrics = /* @__PURE__ */ new Map();
+        for (const datasourceId of targetDatasourceIds) {
+          try {
+            const metaData = await client.getDatasourceMetrics(datasourceId);
+            const index = metaData.index;
+            for (const item of index.metrics) {
+              if (allMetrics.has(item.metricName)) {
+                const existing = allMetrics.get(item.metricName);
+                if (!existing.datasources.includes(datasourceId)) {
+                  existing.datasources.push(datasourceId);
+                }
+              } else {
+                allMetrics.set(item.metricName, {
+                  metricName: item.metricName,
+                  displayName: item.displayName,
+                  domain: item.domain,
+                  shortDesc: item.shortDesc,
+                  datasources: [datasourceId]
+                });
+              }
+            }
+          } catch (error) {
+            console.warn(`Failed to get metrics for datasource ${datasourceId}:`, error);
+          }
+        }
+        const metricsByDatasource = /* @__PURE__ */ new Map();
+        for (const metric of allMetrics.values()) {
+          for (const dsId of metric.datasources) {
+            if (!metricsByDatasource.has(dsId)) {
+              metricsByDatasource.set(dsId, []);
+            }
+            metricsByDatasource.get(dsId).push(metric);
+          }
+        }
+        if (metricsByDatasource.size === 0) {
+          return `\u672A\u5728\u6307\u5B9A\u7684\u6570\u636E\u6E90\u4E2D\u627E\u5230\u6307\u6807\u3002`;
+        }
+        const lines = [];
+        lines.push(`## \u4E1A\u52A1\u6307\u6807\u5217\u8868\uFF08serverKey: ${serverKey}\uFF09
+`);
+        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) {
+              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("| metricName | displayName | domain | shortDesc |");
+          lines.push("|------------|-------------|--------|-----------|");
+          for (const metric of sortedMetrics) {
+            const shortDesc = metric.shortDesc || "";
+            lines.push(`| ${metric.metricName} | ${metric.displayName} | ${metric.domain} | ${shortDesc} |`);
+          }
+          lines.push("");
+        }
+        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`");
+        return lines.join("\n");
+      } catch (error) {
+        return `Error querying metrics list: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      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.")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_metric_definition.ts
+import z10 from "zod";
+import { tool as tool9 } from "langchain";
+var QUERY_METRIC_DEFINITION_DESCRIPTION = `Get Metric Definition - Step 2 of the Metrics Workflow
+
+Read detailed metadata for a specific metric before querying it.
+
+When to Use This Tool
+- BEFORE calling query_semantic_metric_data for any metric
+- When you need to understand time dimensions and supported grains
+- When you need to know which dimensions are available for GROUP BY and filtering
+
+When NOT to Use This Tool
+- You have already retrieved the metric definition in this conversation
+- You are only listing available metrics (use query_metrics_list instead)
+
+Key Response Sections
+
+1. defaultTimeContext - Time Configuration
+- timeDimension: Primary date field (e.g., "DocDate")
+- supportedGrains: Available grains ["day", "week", "month", "year"]
+- Format: Use "{timeDimension}__{grain}" for time grouping
+
+2. supportedDimensions - Available Axes
+Each dimension has: dim_id, field_name, type (categorical/datetime)
+
+Filter Patterns by Type:
+- categorical \u2192 {"dimension": "dim_id", "operator": "IN", "values": ["v1", "v2"]}
+- datetime \u2192 {"dimension": "dim_id", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"]}
+
+GroupBy Patterns:
+- categorical \u2192 Use dim_id directly (e.g., "org_region")
+- datetime \u2192 Use "{dim_id}__{grain}" (e.g., "DocDate__month")
+
+Rules
+- Use dim_id (never field_name) in filters and groupBy
+- Time grain format: lowercase (day/week/month/year)
+- Categorical: IN for multiple, EQ for single
+- Datetime: BETWEEN for ranges, GT/LT for open-ended
+
+Next Step
+Call query_semantic_metric_data with parameters derived from this definition.`;
+var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool9(
+    async ({
+      serverKey,
+      metricName,
+      datasourceId
+    }, _exeConfig) => {
+      try {
+        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 (!metricName) {
+          return "Error: metricName parameter is required.";
+        }
+        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 targetDatasourceIds = datasourceId ? [datasourceId] : client.getSelectedDataSources();
+        if (targetDatasourceIds.length === 0) {
+          return `Error: No datasourceId specified and no default data sources configured for server "${serverKey}".`;
+        }
+        let foundDetail = null;
+        let foundDatasourceId = null;
+        for (const dsId of targetDatasourceIds) {
+          try {
+            const metaData = await client.getDatasourceMetrics(dsId);
+            const item = metaData.index.metrics.find((m) => m.metricName === metricName);
+            if (item) {
+              const detail = metaData.metricsDetails.find((d) => d.metricName === metricName);
+              if (detail) {
+                foundDetail = detail;
+                foundDatasourceId = dsId;
+              }
+              break;
+            }
+          } catch (error) {
+            console.warn(`Failed to get metrics for datasource ${dsId}:`, error);
+          }
+        }
+        if (!foundDetail) {
+          return `Metric "${metricName}" not found in the specified data sources.`;
+        }
+        const lines = [];
+        lines.push(`# ${foundDetail.displayName} (${foundDetail.metricName})`);
+        lines.push("");
+        lines.push(`## \u57FA\u672C\u4FE1\u606F`);
+        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}`);
+        if (foundDatasourceId) {
+          lines.push(`- **\u6570\u636E\u6E90ID**: ${foundDatasourceId}`);
+        }
+        lines.push("");
+        lines.push(`## \u6307\u6807\u63CF\u8FF0`);
+        lines.push("");
+        lines.push(foundDetail.description);
+        lines.push("");
+        if (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")}`);
+          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("");
+          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("");
+            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(`"groupBy": ["${dim.dim_id}"]`);
+              lines.push("");
+              lines.push(`// \u8FC7\u6EE4\u793A\u4F8B`);
+              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}`);
+              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("");
+            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("");
+            lines.push(`// \u65F6\u95F4\u8303\u56F4\u8FC7\u6EE4`);
+            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}`);
+              lines.push("");
+            }
+          }
+          lines.push("### \u5FEB\u901F\u53C2\u8003");
+          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("");
+        }
+        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("");
+          if (aiContext.synonyms && aiContext.synonyms.length > 0) {
+            lines.push(`### \u540C\u4E49\u8BCD/\u522B\u540D`);
+            lines.push("");
+            lines.push(aiContext.synonyms.join("\u3001"));
+            lines.push("");
+          }
+          if (aiContext.thresholds && aiContext.thresholds.length > 0) {
+            lines.push(`### \u9884\u8B66\u9608\u503C`);
+            lines.push("");
+            lines.push("| \u6307\u6807 | \u8FD0\u7B97\u7B26 | \u9608\u503C | \u7EA7\u522B |");
+            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("");
+            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}`);
+              }
+              lines.push("");
+            }
+            if (aiContext.diagnosticWorkflow.actions && aiContext.diagnosticWorkflow.actions.length > 0) {
+              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.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}`);
+              }
+              lines.push("");
+            }
+            if (aiContext.diagnosticWorkflow.analysis_logic) {
+              lines.push(`**\u5206\u6790\u903B\u8F91**: ${aiContext.diagnosticWorkflow.analysis_logic}`);
+              lines.push("");
+            }
+          }
+          if (aiContext.humanReadableExplanation) {
+            lines.push(`### \u7CFB\u7EDF\u5EFA\u8BAE`);
+            lines.push("");
+            lines.push(aiContext.humanReadableExplanation);
+            lines.push("");
+          }
+        }
+        lines.push(`---`);
+        lines.push("");
+        lines.push(`## \u4F7F\u7528\u793A\u4F8B`);
+        lines.push("");
+        lines.push(`\u67E5\u8BE2\u6B64\u6307\u6807\u65F6\uFF0C\u4F7F\u7528 query_semantic_metric_data \u5DE5\u5177\uFF0C\u53C2\u6570:`);
+        lines.push(`- **metricName**: "${foundDetail.metricName}"`);
+        if (foundDatasourceId) {
+          lines.push(`- **datasourceId**: "${foundDatasourceId}"`);
+        }
+        return lines.join("\n");
+      } catch (error) {
+        return `Error querying metric definition: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      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(", ")}`),
+        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.")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_semantic_metric_data.ts
+import z11 from "zod";
+import { tool as tool10 } from "langchain";
+var QUERY_SEMANTIC_METRIC_DATA_DESCRIPTION = `Query Metric Data - Step 3 of the Metrics Workflow
+
+Execute queries with the correct parameters derived from metric definitions. This tool requires you to have already discovered and understood the metric metadata.
+
+When to Use This Tool
+Use this tool proactively in these scenarios:
+- When you have the metricName and have read its definition via query_metric_definition
+- When executing time trend analysis, dimension breakdowns, or drill-downs
+- When comparing multiple metrics side-by-side
+
+When NOT to Use This Tool
+Skip using this tool when:
+- You haven't retrieved the metric definition yet (call query_metric_definition first)
+- You're unsure about supported dimensions or time grains for this metric
+
+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.supportedGrains (e.g., ["day", "week", "month", "year"])
+   - supportedDimensions[].dim_id (use these for groupBy and filters)
+   - supportedDimensions[].filter_operators (allowed operators per dimension)
+
+The Five Query Patterns
+
+Pattern A - Time Trend (most common first query)
+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" }]
+}
+
+Pattern B - Dimension Breakdown (who/what is top or bottom)
+Goal: Rank performance across a categorical dimension in a fixed period
+{
+  "metrics": ["order_amt_tax_inc"],
+  "groupBy": ["org_region"],
+  "filters": [{ "dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-01-01", "2025-03-31"] }],
+  "orderBy": [{ "field": "value", "direction": "DESC" }],
+  "limit": 10
+}
+
+Pattern C - Drill Down (zoom into an anomaly)
+Goal: After Pattern A reveals a bad month, find which segment caused it
+Step 1 - Monthly trend to find anomaly (Pattern A)
+Step 2 - Drill into that month by adding categorical dimension:
+{
+  "groupBy": ["sales_person"],
+  "filters": [
+    { "dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-06-01", "2025-06-30"] },
+    { "dimension": "org_region", "operator": "EQ", "values": ["\u534E\u4E1C"] }
+  ],
+  "orderBy": [{ "field": "value", "direction": "ASC" }]
+}
+
+Pattern D - Multi-Metric Comparison
+Goal: Query two or more metrics in one call to compare side-by-side
+{
+  "metrics": ["order_amt_tax_inc", "net_sales_amt"],
+  "groupBy": ["DocDate__month"],
+  "filters": [{ "dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-01-01", "2025-12-31"] }],
+  "orderBy": [{ "field": "DocDate__month", "direction": "ASC" }]
+}
+
+Pattern E - Time x Dimension Cross-Analysis
+Goal: See how a dimension behaves across time (e.g., monthly sales by region)
+{
+  "metrics": ["order_amt_tax_inc"],
+  "groupBy": ["DocDate__month", "org_region"],
+  "filters": [{ "dimension": "DocDate", "operator": "BETWEEN", "values": ["2025-01-01", "2025-06-30"] }],
+  "orderBy": [
+    { "field": "DocDate__month", "direction": "ASC" },
+    { "field": "org_region", "direction": "ASC" }
+  ]
+}
+
+Filter Operator Reference
+| Operator | Applies To | Values Array |
+|----------|------------|--------------|
+| BETWEEN | datetime, number | [min, max] (inclusive) |
+| IN | categorical | ["v1", "v2", ...] |
+| EQ | any | ["v"] |
+| NEQ | any | ["v"] |
+| GT / GTE | datetime, number | ["v"] |
+| LT / LTE | datetime, number | ["v"] |
+| LIKE | string | ["%pattern%"] |
+| NOT_NULL | any | [] |
+
+Common Mistakes to Avoid
+- Using field_name (e.g., "SlpName") instead of dim_id (e.g., "sales_person")
+- Writing "DocDate__Month" (capital M) - always lowercase: "DocDate__month"
+- 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) {
+    return `No data found for the specified query.
+Data Source: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`;
+  }
+  const lines = [];
+  lines.push(`# \u6307\u6807\u67E5\u8BE2\u7ED3\u679C`);
+  lines.push(`
+**\u6570\u636E\u6E90**: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`);
+  lines.push(`**\u6307\u6807\u6570**: ${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}`);
+    if (metric.columns.length > 0 && metric.rows.length > 0) {
+      lines.push(`
+### \u6570\u636E
+`);
+      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 \u5206\u6790\u5EFA\u8BAE
+`);
+      lines.push(`- **\u6307\u6807\u89E3\u91CA**: ${metric.aiHints.valueInterpretation}`);
+      if (metric.aiHints.thresholds && metric.aiHints.thresholds.length > 0) {
+        lines.push(`- **\u9884\u8B66\u9608\u503C**:`);
+        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**:`);
+        for (const suggestion of metric.aiHints.suggestedFollowup) {
+          lines.push(`  - ${suggestion}`);
+        }
+      }
+    }
+    lines.push(`
+---
+`);
+  }
+  return lines.join("\n");
+}
+var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool10(
+    async ({
+      serverKey,
+      datasourceId,
+      metrics,
+      groupBy,
+      filters,
+      limit
+    }, _exeConfig) => {
+      try {
+        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 (!metrics || metrics.length === 0) {
+          return "Error: metrics parameter is required (at least one metric name).";
+        }
+        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 semanticFilters = (filters || []).map((f) => ({
+          dimension: f.dimension,
+          operator: f.operator,
+          values: f.values
+        }));
+        const result = await client.semanticQuery({
+          datasourceId,
+          metrics,
+          groupBy,
+          filters: semanticFilters,
+          limit: limit || 1e3
+        });
+        return formatSemanticQueryResult(
+          result.datasourceId,
+          result.datasourceName,
+          result.results
+        );
+      } catch (error) {
+        return `Error querying semantic metric data: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      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."),
+        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({
+          dimension: z11.string().describe("Dimension/column name to filter on"),
+          operator: z11.string().describe("Operator (e.g., 'BETWEEN', '=', '>', '<')"),
+          values: z11.array(z11.union([z11.string(), z11.number(), z11.boolean()])).describe("Filter values")
+        })).optional().describe("Optional array of filters to apply to the query."),
+        limit: z11.number().optional().describe("Maximum number of results to return (default: 1000).")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_tables_list.ts
+import z12 from "zod";
+import { tool as tool11 } from "langchain";
+var QUERY_TABLES_LIST_DESCRIPTION = `Query available tables from a semantic metrics server. Returns a list of data tables with their schemas and descriptions. Use this tool to discover what tables are available in the data source.`;
+var createQueryTablesListTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool11(
+    async ({
+      serverKey,
+      datasourceIds
+    }, _exeConfig) => {
+      try {
+        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(", ")}]`;
+        }
+        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 targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : client.getSelectedDataSources();
+        if (targetDatasourceIds.length === 0) {
+          return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
+        }
+        const allTables = /* @__PURE__ */ new Map();
+        for (const datasourceId of targetDatasourceIds) {
+          try {
+            const metaData = await client.getDatasourceMetrics(datasourceId);
+            const index = metaData.index;
+            for (const item of index.tables) {
+              const tableKey = item.tableName;
+              if (allTables.has(tableKey)) {
+                const existing = allTables.get(tableKey);
+                if (!existing.datasources.includes(datasourceId)) {
+                  existing.datasources.push(datasourceId);
+                }
+              } else {
+                allTables.set(tableKey, {
+                  tableName: item.tableName,
+                  displayName: item.displayName,
+                  docType: item.docType,
+                  docTypeEn: item.docTypeEn,
+                  mainTable: item.mainTable,
+                  lineTable: item.lineTable,
+                  columnCount: item.columnCount,
+                  shortDesc: item.shortDesc,
+                  datasources: [datasourceId]
+                });
+              }
+            }
+          } catch (error) {
+            console.warn(`Failed to get tables for datasource ${datasourceId}:`, error);
+          }
+        }
+        if (allTables.size === 0) {
+          return `\u672A\u5728\u6307\u5B9A\u7684\u6570\u636E\u6E90\u4E2D\u627E\u5230\u6570\u636E\u8868\u3002`;
+        }
+        const lines = [];
+        lines.push(`## \u6570\u636E\u8868\u5217\u8868\uFF08\u5171 ${allTables.size} \u4E2A\uFF09
+`);
+        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("|------|---------|---------|------|------|");
+        for (const table of sortedTables) {
+          const mainTableInfo = table.mainTable ? ` (\u4E3B\u8868: ${table.mainTable})` : "";
+          const lineTableInfo = table.lineTable ? ` (\u884C\u8868: ${table.lineTable})` : "";
+          const tableRelation = mainTableInfo + lineTableInfo;
+          lines.push(`| ${table.tableName} | ${table.displayName} | ${table.docType}${tableRelation} | ${table.columnCount} | ${table.shortDesc} |`);
+        }
+        return lines.join("\n");
+      } catch (error) {
+        return `Error querying tables list: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      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.")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_table_definition.ts
+import z13 from "zod";
+import { tool as tool12 } from "langchain";
+var QUERY_TABLE_DEFINITION_DESCRIPTION = `Get detailed definition and schema for a specific table from a semantic metrics server. Returns comprehensive information including column definitions, SQL query, and table relationships.`;
+var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions }) => {
+  const availableServersText = serverKeys.length > 0 ? `
+
+Available metrics servers:
+${serverKeys.map(
+    (key) => `- ${key}${serverDescriptions?.[key] ? `: ${serverDescriptions[key]}` : ""}`
+  ).join("\n")}` : "";
+  return tool12(
+    async ({
+      serverKey,
+      tableName,
+      datasourceId
+    }, _exeConfig) => {
+      try {
+        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 (!tableName) {
+          return "Error: tableName parameter is required.";
+        }
+        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 targetDatasourceIds = datasourceId ? [datasourceId] : client.getSelectedDataSources();
+        if (targetDatasourceIds.length === 0) {
+          return `Error: No datasourceId specified and no default data sources configured for server "${serverKey}".`;
+        }
+        let foundTable = null;
+        let foundDatasourceId = null;
+        for (const dsId of targetDatasourceIds) {
+          try {
+            const metaData = await client.getDatasourceMetrics(dsId);
+            const tableDetail = metaData.tablesDetails?.find((t) => t.tableName === tableName);
+            if (tableDetail) {
+              foundTable = tableDetail;
+              foundDatasourceId = dsId;
+              break;
+            }
+          } catch (error) {
+            console.warn(`Failed to get table definition for datasource ${dsId}:`, error);
+          }
+        }
+        if (!foundTable) {
+          return `Table "${tableName}" not found in the specified data sources.`;
+        }
+        const lines = [];
+        lines.push(`# ${foundTable.tableName}`);
+        lines.push("");
+        lines.push(`## \u57FA\u672C\u4FE1\u606F`);
+        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("");
+        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("");
+          lines.push("| \u5217\u540D | \u6807\u7B7E | \u7C7B\u578B | \u793A\u4F8B\u503C |");
+          lines.push("|------|------|------|--------|");
+          for (const col of validColumns) {
+            const type = col.type || "-";
+            const example = col.example || "-";
+            lines.push(`| ${col.name} | ${col.label} | ${type} | ${example} |`);
+          }
+          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)}`;
+      }
+    },
+    {
+      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(", ")}`),
+        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.")
+      })
+    }
+  );
+};
+
 // src/tool_lattice/code_eval/index.ts
-import z7 from "zod";
+import z14 from "zod";
 
 // src/sandbox_lattice/SandboxLatticeManager.ts
 import { SandboxClient } from "@agent-infra/sandbox";
@@ -1457,7 +3044,7 @@ var getSandBoxManager = (key = "default") => {
 };
 
 // src/tool_lattice/code_eval/index.ts
-import { tool as tool6 } from "langchain";
+import { tool as tool13 } from "langchain";
 var CODE_EVAL_DESCRIPTION = `Execute code in Python or JavaScript runtime.
 
 Args:
@@ -1467,7 +3054,7 @@ Args:
 Returns:
     Dict containing output, errors, and execution details`;
 var createCodeEvalTool = ({ isolatedLevel }) => {
-  return tool6(async (input, exe_config) => {
+  return tool13(async (input, exe_config) => {
     try {
       const runConfig = exe_config.configurable?.runConfig;
       const sandboxManager = getSandBoxManager();
@@ -1508,16 +3095,16 @@ ${traceback.join("\n")}`);
   }, {
     name: "execute_code",
     description: CODE_EVAL_DESCRIPTION,
-    schema: z7.object({
-      language: z7.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
-      code: z7.string().describe("Code to execute")
+    schema: z14.object({
+      language: z14.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
+      code: z14.string().describe("Code to execute")
     })
   });
 };
 
 // src/tool_lattice/code_execute_file/index.ts
-import z8 from "zod";
-import { tool as tool7 } from "langchain";
+import z15 from "zod";
+import { tool as tool14 } 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) {
@@ -1530,7 +3117,7 @@ function inferLanguageFromPath(filePath) {
   return null;
 }
 var createCodeExecuteFileTool = ({ isolatedLevel }) => {
-  return tool7(
+  return tool14(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1593,15 +3180,15 @@ ${traceback.join("\n")}`);
     {
       name: "execute_code_file",
       description: CODE_EXECUTE_FILE_DESCRIPTION,
-      schema: z8.object({
-        file_path: z8.string().describe("Path to the code file to execute (absolute path in sandbox filesystem). Only supports .py (Python) and .js/.mjs (JavaScript) files.")
+      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.")
       })
     }
   );
 };
 
 // src/tool_lattice/convert_to_markdown/index.ts
-import z9 from "zod";
+import z16 from "zod";
 var CONVERT_TO_MARKDOWN_DESCRIPTION = `Convert a resource described by an http:, https:, file: or data: URI to markdown.
 
 Args:
@@ -1618,8 +3205,8 @@ registerToolLattice(
     name: "convert_to_markdown",
     description: CONVERT_TO_MARKDOWN_DESCRIPTION,
     needUserApprove: false,
-    schema: z9.object({
-      uri: z9.string().describe("The URI to convert.")
+    schema: z16.object({
+      uri: z16.string().describe("The URI to convert.")
     })
   },
   async (input, exe_config) => {
@@ -1642,15 +3229,15 @@ registerToolLattice(
 );
 
 // src/tool_lattice/browser/browser_navigate.ts
-import z10 from "zod";
-import { tool as tool8 } from "langchain";
+import z17 from "zod";
+import { tool as tool15 } from "langchain";
 var BROWSER_NAVIGATE_DESCRIPTION = `Navigate to a URL.
 
 Args:
     url (str): The URL to navigate to.
 `;
 var createBrowserNavigateTool = ({ isolatedLevel }) => {
-  return tool8(
+  return tool15(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1670,23 +3257,23 @@ var createBrowserNavigateTool = ({ isolatedLevel }) => {
     {
       name: "browser_navigate",
       description: BROWSER_NAVIGATE_DESCRIPTION,
-      schema: z10.object({
-        url: z10.string().describe("The URL to navigate to.")
+      schema: z17.object({
+        url: z17.string().describe("The URL to navigate to.")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_click.ts
-import z11 from "zod";
-import { tool as tool9 } from "langchain";
+import z18 from "zod";
+import { tool as tool16 } 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 tool9(
+  return tool16(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1706,23 +3293,23 @@ var createBrowserClickTool = ({ isolatedLevel }) => {
     {
       name: "browser_click",
       description: BROWSER_CLICK_DESCRIPTION,
-      schema: z11.object({
-        index: z11.number().describe("Index of the element to click")
+      schema: z18.object({
+        index: z18.number().describe("Index of the element to click")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_text.ts
-import z12 from "zod";
-import { tool as tool10 } from "langchain";
+import z19 from "zod";
+import { tool as tool17 } from "langchain";
 var BROWSER_GET_TEXT_DESCRIPTION = `Get the text content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetTextTool = ({ isolatedLevel }) => {
-  return tool10(
+  return tool17(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1740,21 +3327,21 @@ var createBrowserGetTextTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_text",
       description: BROWSER_GET_TEXT_DESCRIPTION,
-      schema: z12.object({})
+      schema: z19.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_markdown.ts
-import z13 from "zod";
-import { tool as tool11 } from "langchain";
+import z20 from "zod";
+import { tool as tool18 } from "langchain";
 var BROWSER_GET_MARKDOWN_DESCRIPTION = `Get the markdown content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
-  return tool11(
+  return tool18(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1772,21 +3359,21 @@ var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_markdown",
       description: BROWSER_GET_MARKDOWN_DESCRIPTION,
-      schema: z13.object({})
+      schema: z20.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_evaluate.ts
-import z14 from "zod";
-import { tool as tool12 } from "langchain";
+import z21 from "zod";
+import { tool as tool19 } from "langchain";
 var BROWSER_EVALUATE_DESCRIPTION = `Execute JavaScript in the browser console.
 
 Args:
     script (str): JavaScript code to execute, () => { /* code */ }
 `;
 var createBrowserEvaluateTool = ({ isolatedLevel }) => {
-  return tool12(
+  return tool19(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1806,16 +3393,16 @@ var createBrowserEvaluateTool = ({ isolatedLevel }) => {
     {
       name: "browser_evaluate",
       description: BROWSER_EVALUATE_DESCRIPTION,
-      schema: z14.object({
-        script: z14.string().describe("JavaScript code to execute, () => { /* code */ }")
+      schema: z21.object({
+        script: z21.string().describe("JavaScript code to execute, () => { /* code */ }")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_screenshot.ts
-import z15 from "zod";
-import { tool as tool13 } from "langchain";
+import z22 from "zod";
+import { tool as tool20 } from "langchain";
 var BROWSER_SCREENSHOT_DESCRIPTION = `Take a screenshot of the current page or a specific element.
 
 Args:
@@ -1828,7 +3415,7 @@ Args:
     highlight (bool): Highlight the element
 `;
 var createBrowserScreenshotTool = ({ isolatedLevel }) => {
-  return tool13(
+  return tool20(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1880,29 +3467,29 @@ var createBrowserScreenshotTool = ({ isolatedLevel }) => {
     {
       name: "browser_screenshot",
       description: BROWSER_SCREENSHOT_DESCRIPTION,
-      schema: z15.object({
-        name: z15.string().optional().describe("Name for the screenshot"),
-        selector: z15.string().optional().describe("CSS selector for element to screenshot"),
-        index: z15.number().optional().describe("index of the element to screenshot"),
-        width: z15.number().optional().describe("Width in pixels (default: viewport width)"),
-        height: z15.number().optional().describe("Height in pixels (default: viewport height)"),
-        fullPage: z15.boolean().optional().describe("Full page screenshot (default: false)"),
-        highlight: z15.boolean().default(false).describe("Highlight the element")
+      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")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_scroll.ts
-import z16 from "zod";
-import { tool as tool14 } from "langchain";
+import z23 from "zod";
+import { tool as tool21 } 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 tool14(
+  return tool21(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1922,16 +3509,16 @@ var createBrowserScrollTool = ({ isolatedLevel }) => {
     {
       name: "browser_scroll",
       description: BROWSER_SCROLL_DESCRIPTION,
-      schema: z16.object({
-        amount: z16.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
+      schema: z23.object({
+        amount: z23.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_form_input_fill.ts
-import z17 from "zod";
-import { tool as tool15 } from "langchain";
+import z24 from "zod";
+import { tool as tool22 } 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:
@@ -1941,7 +3528,7 @@ Args:
     clear (bool): Whether to clear existing text before filling
 `;
 var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
-  return tool15(
+  return tool22(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1964,19 +3551,19 @@ var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
     {
       name: "browser_form_input_fill",
       description: BROWSER_FORM_INPUT_FILL_DESCRIPTION,
-      schema: z17.object({
-        selector: z17.string().optional().describe("CSS selector for input field"),
-        index: z17.number().optional().describe("Index of the element to fill"),
-        value: z17.string().describe("Value to fill"),
-        clear: z17.boolean().default(false).describe("Whether to clear existing text before filling")
+      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")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_select.ts
-import z18 from "zod";
-import { tool as tool16 } from "langchain";
+import z25 from "zod";
+import { tool as tool23 } from "langchain";
 var BROWSER_SELECT_DESCRIPTION = `Select an element on the page with index, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -1985,7 +3572,7 @@ Args:
     value (str): Value to select
 `;
 var createBrowserSelectTool = ({ isolatedLevel }) => {
-  return tool16(
+  return tool23(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2007,18 +3594,18 @@ var createBrowserSelectTool = ({ isolatedLevel }) => {
     {
       name: "browser_select",
       description: BROWSER_SELECT_DESCRIPTION,
-      schema: z18.object({
-        index: z18.number().optional().describe("Index of the element to select"),
-        selector: z18.string().optional().describe("CSS selector for element to select"),
-        value: z18.string().describe("Value to select")
+      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")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_hover.ts
-import z19 from "zod";
-import { tool as tool17 } from "langchain";
+import z26 from "zod";
+import { tool as tool24 } from "langchain";
 var BROWSER_HOVER_DESCRIPTION = `Hover an element on the page, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -2026,7 +3613,7 @@ Args:
     selector (str): CSS selector for element to hover
 `;
 var createBrowserHoverTool = ({ isolatedLevel }) => {
-  return tool17(
+  return tool24(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2047,24 +3634,24 @@ var createBrowserHoverTool = ({ isolatedLevel }) => {
     {
       name: "browser_hover",
       description: BROWSER_HOVER_DESCRIPTION,
-      schema: z19.object({
-        index: z19.number().optional().describe("Index of the element to hover"),
-        selector: z19.string().optional().describe("CSS selector for element to hover")
+      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")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_back.ts
-import z20 from "zod";
-import { tool as tool18 } from "langchain";
+import z27 from "zod";
+import { tool as tool25 } from "langchain";
 var BROWSER_GO_BACK_DESCRIPTION = `Go back to the previous page.
 
 Args:
     None
 `;
 var createBrowserGoBackTool = ({ isolatedLevel }) => {
-  return tool18(
+  return tool25(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2082,21 +3669,21 @@ var createBrowserGoBackTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_back",
       description: BROWSER_GO_BACK_DESCRIPTION,
-      schema: z20.object({})
+      schema: z27.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_forward.ts
-import z21 from "zod";
-import { tool as tool19 } from "langchain";
+import z28 from "zod";
+import { tool as tool26 } from "langchain";
 var BROWSER_GO_FORWARD_DESCRIPTION = `Go forward to the next page.
 
 Args:
     None
 `;
 var createBrowserGoForwardTool = ({ isolatedLevel }) => {
-  return tool19(
+  return tool26(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2114,21 +3701,21 @@ var createBrowserGoForwardTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_forward",
       description: BROWSER_GO_FORWARD_DESCRIPTION,
-      schema: z21.object({})
+      schema: z28.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_new_tab.ts
-import z22 from "zod";
-import { tool as tool20 } from "langchain";
+import z29 from "zod";
+import { tool as tool27 } 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 tool20(
+  return tool27(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2148,23 +3735,23 @@ var createBrowserNewTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_new_tab",
       description: BROWSER_NEW_TAB_DESCRIPTION,
-      schema: z22.object({
-        url: z22.string().describe("URL to open in the new tab")
+      schema: z29.object({
+        url: z29.string().describe("URL to open in the new tab")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_tab_list.ts
-import z23 from "zod";
-import { tool as tool21 } from "langchain";
+import z30 from "zod";
+import { tool as tool28 } from "langchain";
 var BROWSER_TAB_LIST_DESCRIPTION = `Get the list of tabs.
 
 Args:
     None
 `;
 var createBrowserTabListTool = ({ isolatedLevel }) => {
-  return tool21(
+  return tool28(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2182,21 +3769,21 @@ var createBrowserTabListTool = ({ isolatedLevel }) => {
     {
       name: "browser_tab_list",
       description: BROWSER_TAB_LIST_DESCRIPTION,
-      schema: z23.object({})
+      schema: z30.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_switch_tab.ts
-import z24 from "zod";
-import { tool as tool22 } from "langchain";
+import z31 from "zod";
+import { tool as tool29 } from "langchain";
 var BROWSER_SWITCH_TAB_DESCRIPTION = `Switch to a specific tab.
 
 Args:
     index (int): Tab index to switch to
 `;
 var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
-  return tool22(
+  return tool29(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2216,23 +3803,23 @@ var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_switch_tab",
       description: BROWSER_SWITCH_TAB_DESCRIPTION,
-      schema: z24.object({
-        index: z24.number().describe("Tab index to switch to")
+      schema: z31.object({
+        index: z31.number().describe("Tab index to switch to")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close_tab.ts
-import z25 from "zod";
-import { tool as tool23 } from "langchain";
+import z32 from "zod";
+import { tool as tool30 } from "langchain";
 var BROWSER_CLOSE_TAB_DESCRIPTION = `Close the current tab.
 
 Args:
     None
 `;
 var createBrowserCloseTabTool = ({ isolatedLevel }) => {
-  return tool23(
+  return tool30(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2250,21 +3837,21 @@ var createBrowserCloseTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_close_tab",
       description: BROWSER_CLOSE_TAB_DESCRIPTION,
-      schema: z25.object({})
+      schema: z32.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close.ts
-import z26 from "zod";
-import { tool as tool24 } from "langchain";
+import z33 from "zod";
+import { tool as tool31 } 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 tool24(
+  return tool31(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2282,21 +3869,21 @@ var createBrowserCloseTool = ({ isolatedLevel }) => {
     {
       name: "browser_close",
       description: BROWSER_CLOSE_DESCRIPTION,
-      schema: z26.object({})
+      schema: z33.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_press_key.ts
-import z27 from "zod";
-import { tool as tool25 } from "langchain";
+import z34 from "zod";
+import { tool as tool32 } 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 tool25(
+  return tool32(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2316,8 +3903,8 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
     {
       name: "browser_press_key",
       description: BROWSER_PRESS_KEY_DESCRIPTION,
-      schema: z27.object({
-        key: z27.enum([
+      schema: z34.object({
+        key: z34.enum([
           "Enter",
           "Tab",
           "Escape",
@@ -2364,15 +3951,15 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
 };
 
 // src/tool_lattice/browser/browser_read_links.ts
-import z28 from "zod";
-import { tool as tool26 } from "langchain";
+import z35 from "zod";
+import { tool as tool33 } from "langchain";
 var BROWSER_READ_LINKS_DESCRIPTION = `Get all links on the current page.
 
 Args:
     None
 `;
 var createBrowserReadLinksTool = ({ isolatedLevel }) => {
-  return tool26(
+  return tool33(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2390,21 +3977,21 @@ var createBrowserReadLinksTool = ({ isolatedLevel }) => {
     {
       name: "browser_read_links",
       description: BROWSER_READ_LINKS_DESCRIPTION,
-      schema: z28.object({})
+      schema: z35.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_clickable_elements.ts
-import z29 from "zod";
-import { tool as tool27 } from "langchain";
+import z36 from "zod";
+import { tool as tool34 } 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 tool27(
+  return tool34(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2422,21 +4009,21 @@ var createBrowserGetClickableElementsTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_clickable_elements",
       description: BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION,
-      schema: z29.object({})
+      schema: z36.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_download_list.ts
-import z30 from "zod";
-import { tool as tool28 } from "langchain";
+import z37 from "zod";
+import { tool as tool35 } from "langchain";
 var BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION = `Get the list of downloaded files.
 
 Args:
     None
 `;
 var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
-  return tool28(
+  return tool35(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2454,14 +4041,14 @@ var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_download_list",
       description: BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION,
-      schema: z30.object({})
+      schema: z37.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/get_info.ts
-import z31 from "zod";
-import { tool as tool29 } from "langchain";
+import z38 from "zod";
+import { tool as tool36 } from "langchain";
 var BROWSER_GET_INFO_DESCRIPTION = `Get information about browser, like CDP URL, viewport size, etc.
 
 Args:
@@ -2470,7 +4057,7 @@ Args:
 Returns:
     Dict containing browser information including CDP URL, viewport dimensions, and other browser metadata.`;
 var createBrowserGetInfoTool = ({ isolatedLevel }) => {
-  return tool29(
+  return tool36(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2488,7 +4075,7 @@ var createBrowserGetInfoTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_info",
       description: BROWSER_GET_INFO_DESCRIPTION,
-      schema: z31.object({})
+      schema: z38.object({})
     }
   );
 };
@@ -2641,8 +4228,8 @@ var SandboxFilesystem = class {
    */
   toVirtualPath(realPath) {
     const rootPath = path2.join(this.homeDir, this.workingDirectory);
-    const relative3 = path2.relative(rootPath, realPath);
-    const normalized = relative3.split(path2.sep).join("/");
+    const relative4 = path2.relative(rootPath, realPath);
+    const normalized = relative4.split(path2.sep).join("/");
     return "/" + normalized;
   }
   /**
@@ -3595,7 +5182,58 @@ ${body}` : `${frontmatter}
         subSkills.push(subSkill);
       }
     }
-    return subSkills;
+    return subSkills;
+  }
+  /**
+   * List all resources in a skill's resources directory
+   * @param skillName The skill name
+   * @returns Array of resource paths relative to resources/ directory
+   */
+  async listSkillResources(skillName) {
+    const skillDir = this.getSkillDirectoryPath(skillName);
+    const resourcesDir = path3.join(skillDir, "resources");
+    try {
+      const entries = await fs.readdir(resourcesDir, { withFileTypes: true, recursive: true });
+      const resources = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          const fullPath = path3.join(entry.path, entry.name);
+          const relativePath = path3.relative(resourcesDir, fullPath);
+          resources.push(relativePath.replace(/\\/g, "/"));
+        }
+      }
+      return resources.sort();
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Load a specific resource from a skill's resources directory
+   * @param skillName The skill name
+   * @param resourcePath Path to the resource relative to resources/ directory
+   * @returns The resource content as string
+   */
+  async loadSkillResource(skillName, resourcePath) {
+    const skillDir = this.getSkillDirectoryPath(skillName);
+    const resourcesDir = path3.join(skillDir, "resources");
+    const fullPath = path3.join(resourcesDir, resourcePath);
+    const resolvedPath = path3.resolve(fullPath);
+    const resolvedResourcesDir = path3.resolve(resourcesDir);
+    if (!resolvedPath.startsWith(resolvedResourcesDir)) {
+      throw new Error(`Invalid resource path: ${resourcePath}`);
+    }
+    try {
+      const content = await fs.readFile(fullPath, "utf-8");
+      return content;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
   }
 };
 
@@ -3851,6 +5489,291 @@ var InMemoryDatabaseConfigStore = class {
   }
 };
 
+// src/store_lattice/InMemoryMetricsServerConfigStore.ts
+var InMemoryMetricsServerConfigStore = class {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get composite key for storage
+   */
+  getKey(tenantId, id) {
+    return `${tenantId}:${id}`;
+  }
+  /**
+   * Get all metrics server configurations for a tenant
+   */
+  async getAllConfigs(tenantId) {
+    return Array.from(this.configs.values()).filter(
+      (config) => config.tenantId === tenantId
+    );
+  }
+  /**
+   * Get all metrics server configurations across all tenants
+   */
+  async getAllConfigsWithoutTenant() {
+    return Array.from(this.configs.values());
+  }
+  /**
+   * Get metrics server configuration by ID
+   */
+  async getConfigById(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.get(key) || null;
+  }
+  /**
+   * Get metrics server configuration by business key
+   */
+  async getConfigByKey(tenantId, key) {
+    const configs = await this.getAllConfigs(tenantId);
+    return configs.find((config) => config.key === key) || null;
+  }
+  /**
+   * Create a new metrics server configuration
+   */
+  async createConfig(tenantId, id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const entry = {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: now,
+      updatedAt: now
+    };
+    const storageKey = this.getKey(tenantId, id);
+    this.configs.set(storageKey, entry);
+    return entry;
+  }
+  /**
+   * Update an existing metrics server configuration
+   */
+  async updateConfig(tenantId, id, updates) {
+    const key = this.getKey(tenantId, id);
+    const existing = this.configs.get(key);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      config: updates.config ? { ...existing.config, ...updates.config } : existing.config,
+      key: updates.key || existing.key,
+      name: updates.name !== void 0 ? updates.name : existing.name,
+      description: updates.description !== void 0 ? updates.description : existing.description,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.configs.set(key, updated);
+    return updated;
+  }
+  /**
+   * Delete a metrics server configuration by ID
+   */
+  async deleteConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.delete(key);
+  }
+  /**
+   * Check if configuration exists
+   */
+  async hasConfig(tenantId, id) {
+    const key = this.getKey(tenantId, id);
+    return this.configs.has(key);
+  }
+  /**
+   * Clear all configurations (useful for testing)
+   */
+  clear() {
+    this.configs.clear();
+  }
+  /**
+   * Clear configurations for a specific tenant
+   */
+  clearByTenant(tenantId) {
+    for (const key of this.configs.keys()) {
+      if (key.startsWith(`${tenantId}:`)) {
+        this.configs.delete(key);
+      }
+    }
+  }
+};
+
+// src/store_lattice/InMemoryUserStore.ts
+var InMemoryUserStore = class {
+  constructor() {
+    this.users = /* @__PURE__ */ new Map();
+  }
+  async getAllUsers() {
+    return Array.from(this.users.values());
+  }
+  async getUserById(id) {
+    return this.users.get(id) || null;
+  }
+  async getUserByEmail(email) {
+    for (const user of this.users.values()) {
+      if (user.email === email) {
+        return user;
+      }
+    }
+    return null;
+  }
+  async createUser(id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const user = {
+      id,
+      email: data.email,
+      name: data.name,
+      status: data.status || "pending",
+      metadata: data.metadata ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+    this.users.set(id, user);
+    return user;
+  }
+  async updateUser(id, updates) {
+    const existing = this.users.get(id);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      metadata: updates.metadata ?? existing.metadata,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.users.set(id, updated);
+    return updated;
+  }
+  async deleteUser(id) {
+    return this.users.delete(id);
+  }
+  clear() {
+    this.users.clear();
+  }
+};
+
+// src/store_lattice/InMemoryTenantStore.ts
+var InMemoryTenantStore = class {
+  constructor() {
+    this.tenants = /* @__PURE__ */ new Map();
+    this.initDefaultData();
+  }
+  initDefaultData() {
+    const defaultTenant = {
+      id: "default",
+      name: "Default Tenant",
+      description: "Default tenant for single-tenant setups",
+      status: "active",
+      metadata: {},
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.tenants.set("default", defaultTenant);
+  }
+  async getAllTenants() {
+    return Array.from(this.tenants.values());
+  }
+  async getTenantById(id) {
+    return this.tenants.get(id) || null;
+  }
+  async createTenant(id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const tenant = {
+      id,
+      name: data.name,
+      description: data.description,
+      status: data.status || "active",
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+    this.tenants.set(id, tenant);
+    return tenant;
+  }
+  async updateTenant(id, updates) {
+    const existing = this.tenants.get(id);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.tenants.set(id, updated);
+    return updated;
+  }
+  async deleteTenant(id) {
+    return this.tenants.delete(id);
+  }
+  clear() {
+    this.tenants.clear();
+    this.initDefaultData();
+  }
+};
+
+// src/store_lattice/InMemoryUserTenantLinkStore.ts
+var InMemoryUserTenantLinkStore = class {
+  constructor() {
+    this.links = /* @__PURE__ */ new Map();
+  }
+  getKey(userId, tenantId) {
+    return `${userId}:${tenantId}`;
+  }
+  async getTenantsByUser(userId) {
+    return Array.from(this.links.values()).filter(
+      (link) => link.userId === userId
+    );
+  }
+  async getUsersByTenant(tenantId) {
+    return Array.from(this.links.values()).filter(
+      (link) => link.tenantId === tenantId
+    );
+  }
+  async getLink(userId, tenantId) {
+    const key = this.getKey(userId, tenantId);
+    return this.links.get(key) || null;
+  }
+  async createLink(data) {
+    const link = {
+      userId: data.userId,
+      tenantId: data.tenantId,
+      role: data.role || "member",
+      joinedAt: /* @__PURE__ */ new Date(),
+      metadata: data.metadata ?? {}
+    };
+    const key = this.getKey(data.userId, data.tenantId);
+    this.links.set(key, link);
+    return link;
+  }
+  async updateLink(userId, tenantId, updates) {
+    const key = this.getKey(userId, tenantId);
+    const existing = this.links.get(key);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...updates,
+      metadata: updates.metadata ?? existing.metadata
+    };
+    this.links.set(key, updated);
+    return updated;
+  }
+  async deleteLink(userId, tenantId) {
+    const key = this.getKey(userId, tenantId);
+    return this.links.delete(key);
+  }
+  async hasLink(userId, tenantId) {
+    const key = this.getKey(userId, tenantId);
+    return this.links.has(key);
+  }
+  clear() {
+    this.links.clear();
+  }
+};
+
 // src/store_lattice/StoreLatticeManager.ts
 var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
   /**
@@ -3981,6 +5904,7 @@ var defaultSkillStore = new FileSystemSkillStore();
 var defaultWorkspaceStore = new InMemoryWorkspaceStore();
 var defaultProjectStore = new InMemoryProjectStore();
 var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
+var defaultMetricsServerConfigStore = new InMemoryMetricsServerConfigStore();
 storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
 storeLatticeManager.registerLattice(
   "default",
@@ -3991,13 +5915,20 @@ storeLatticeManager.registerLattice("default", "skill", defaultSkillStore);
 storeLatticeManager.registerLattice("default", "workspace", defaultWorkspaceStore);
 storeLatticeManager.registerLattice("default", "project", defaultProjectStore);
 storeLatticeManager.registerLattice("default", "database", defaultDatabaseConfigStore);
+storeLatticeManager.registerLattice("default", "metrics", defaultMetricsServerConfigStore);
+var defaultUserStore = new InMemoryUserStore();
+var defaultTenantStore = new InMemoryTenantStore();
+var defaultUserTenantLinkStore = new InMemoryUserTenantLinkStore();
+storeLatticeManager.registerLattice("default", "user", defaultUserStore);
+storeLatticeManager.registerLattice("default", "tenant", defaultTenantStore);
+storeLatticeManager.registerLattice("default", "userTenantLink", defaultUserTenantLinkStore);
 
 // src/tool_lattice/skill/load_skills.ts
-import z32 from "zod";
-import { tool as tool31 } from "langchain";
+import z39 from "zod";
+import { tool as tool38 } 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 tool31(
+  return tool38(
     async (_input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -4021,17 +5952,17 @@ var createLoadSkillsTool = ({ skills } = {}) => {
     {
       name: "load_skills",
       description: LOAD_SKILLS_DESCRIPTION,
-      schema: z32.object({})
+      schema: z39.object({})
     }
   );
 };
 
 // src/tool_lattice/skill/load_skill_content.ts
-import z33 from "zod";
-import { tool as tool32 } 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. Use this tool to get the complete skill content for a skill that you want to use.`;
+import z40 from "zod";
+import { tool as tool39 } 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 tool32(
+  return tool39(
     async (input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -4065,8 +5996,23 @@ var createLoadSkillContentTool = () => {
         }
         frontmatter.push("---");
         const content = skill.content || "";
-        return `${frontmatter.join("\n")}
+        let result = `${frontmatter.join("\n")}
 ${content}`;
+        const fsStore = skillStore;
+        if (fsStore.listSkillResources) {
+          try {
+            const resources = await fsStore.listSkillResources(input.skill_name);
+            if (resources.length > 0) {
+              result += "\n\n---\n\n**Resources** (use `load_skill_resource` tool to access):\n";
+              resources.forEach((resource) => {
+                result += `- ${resource}
+`;
+              });
+            }
+          } catch {
+          }
+        }
+        return result;
       } catch (error) {
         return `Error loading skill content: ${error instanceof Error ? error.message : String(error)}`;
       }
@@ -4074,16 +6020,55 @@ ${content}`;
     {
       name: "load_skill_content",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: z33.object({
-        skill_name: z33.string().describe("The name of the skill to load")
+      schema: z40.object({
+        skill_name: z40.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";
+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(
+    async (input, _exe_config) => {
+      try {
+        const storeLattice = getStoreLattice("default", "skill");
+        const skillStore = storeLattice.store;
+        const fsStore = skillStore;
+        if (!fsStore.loadSkillResource) {
+          return `Error: This skill store does not support resource loading.`;
+        }
+        const content = await fsStore.loadSkillResource(input.skill_name, input.resource_path);
+        if (!content) {
+          return `Resource "${input.resource_path}" not found for skill "${input.skill_name}".`;
+        }
+        return content;
+      } catch (error) {
+        return `Error loading skill resource: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    {
+      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")
       })
     }
   );
 };
 
 // src/middlewares/skillMiddleware.ts
-var DEFAULT_HEADING = "## Available Skills";
-var DEFAULT_EXTRA_NOTE = "Use the load_skill_content tool when you need detailed information about handling a specific type of request.";
+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 = [],
@@ -4096,7 +6081,8 @@ function createSkillMiddleware(params = {}) {
     name: "skillMiddleware",
     tools: [
       createLoadSkillsTool({ skills: readAll ? void 0 : skills }),
-      createLoadSkillContentTool()
+      createLoadSkillContentTool(),
+      createLoadSkillResourceTool()
     ],
     beforeAgent: async () => {
       try {
@@ -4116,7 +6102,8 @@ function createSkillMiddleware(params = {}) {
       }
     },
     wrapModelCall: (request, handler) => {
-      const skillsPrompt = latestSkills.map((skill) => `- **${skill.name}**: ${skill.description}`).join("\n");
+      const skillsPrompt = latestSkills.map((skill) => `## ${skill.name}
+${skill.description}`).join("\n");
       const skillsAddendum = `
 
 ${heading}
@@ -4135,9 +6122,9 @@ ${extraNote}`;
 }
 
 // src/deep_agent_new/middleware/fs.ts
-import { createMiddleware as createMiddleware5, tool as tool33, ToolMessage } from "langchain";
+import { createMiddleware as createMiddleware5, tool as tool41, ToolMessage } from "langchain";
 import { Command, isCommand, getCurrentTaskInput } from "@langchain/langgraph";
-import { z as z34 } from "zod/v3";
+import { z as z310 } from "zod/v3";
 import { withLangGraph } from "@langchain/langgraph/zod";
 
 // src/deep_agent_new/backends/utils.ts
@@ -4283,15 +6270,15 @@ function globSearchFiles(files, pattern, path5 = "/") {
   const effectivePattern = pattern;
   const matches = [];
   for (const [filePath, fileData] of Object.entries(filtered)) {
-    let relative3 = filePath.substring(normalizedPath.length);
-    if (relative3.startsWith("/")) {
-      relative3 = relative3.substring(1);
+    let relative4 = filePath.substring(normalizedPath.length);
+    if (relative4.startsWith("/")) {
+      relative4 = relative4.substring(1);
     }
-    if (!relative3) {
+    if (!relative4) {
       const parts = filePath.split("/");
-      relative3 = parts[parts.length - 1] || "";
+      relative4 = parts[parts.length - 1] || "";
     }
-    if (micromatch.isMatch(relative3, effectivePattern, {
+    if (micromatch.isMatch(relative4, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -4445,9 +6432,9 @@ var StateBackend = class {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = k.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = k.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -4576,10 +6563,10 @@ var StateBackend = class {
 };
 
 // src/deep_agent_new/middleware/fs.ts
-var FileDataSchema = z34.object({
-  content: z34.array(z34.string()),
-  created_at: z34.string(),
-  modified_at: z34.string()
+var FileDataSchema = z310.object({
+  content: z310.array(z310.string()),
+  created_at: z310.string(),
+  modified_at: z310.string()
 });
 function fileDataReducer(left, right) {
   if (left === void 0) {
@@ -4601,13 +6588,13 @@ function fileDataReducer(left, right) {
   }
   return result;
 }
-var FilesystemStateSchema = z34.object({
+var FilesystemStateSchema = z310.object({
   files: withLangGraph(
-    z34.record(z34.string(), FileDataSchema).default({}),
+    z310.record(z310.string(), FileDataSchema).default({}),
     {
       reducer: {
         fn: fileDataReducer,
-        schema: z34.record(z34.string(), FileDataSchema.nullable())
+        schema: z310.record(z310.string(), FileDataSchema.nullable())
       }
     }
   )
@@ -4634,7 +6621,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 tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4662,15 +6649,15 @@ function createLsTool(backend, options) {
     {
       name: "ls",
       description: customDescription || LS_TOOL_DESCRIPTION,
-      schema: z34.object({
-        path: z34.string().optional().default("/").describe("Directory path to list (default: /)")
+      schema: z310.object({
+        path: z310.string().optional().default("/").describe("Directory path to list (default: /)")
       })
     }
   );
 }
 function createReadFileTool(backend, options) {
   const { customDescription } = options;
-  return tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4685,17 +6672,17 @@ function createReadFileTool(backend, options) {
     {
       name: "read_file",
       description: customDescription || READ_FILE_TOOL_DESCRIPTION,
-      schema: z34.object({
-        file_path: z34.string().describe("Absolute path to the file to read"),
-        offset: z34.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
-        limit: z34.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
+      schema: z310.object({
+        file_path: z310.string().describe("Absolute path to the file to read"),
+        offset: z310.number({ coerce: true }).optional().default(0).describe("Line offset to start reading from (0-indexed)"),
+        limit: z310.number({ coerce: true }).optional().default(2e3).describe("Maximum number of lines to read")
       })
     }
   );
 }
 function createWriteFileTool(backend, options) {
   const { customDescription } = options;
-  return tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4725,16 +6712,16 @@ function createWriteFileTool(backend, options) {
     {
       name: "write_file",
       description: customDescription || WRITE_FILE_TOOL_DESCRIPTION,
-      schema: z34.object({
-        file_path: z34.string().describe("Absolute path to the file to write"),
-        content: z34.string().describe("Content to write to the file")
+      schema: z310.object({
+        file_path: z310.string().describe("Absolute path to the file to write"),
+        content: z310.string().describe("Content to write to the file")
       })
     }
   );
 }
 function createEditFileTool(backend, options) {
   const { customDescription } = options;
-  return tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4769,18 +6756,18 @@ function createEditFileTool(backend, options) {
     {
       name: "edit_file",
       description: customDescription || EDIT_FILE_TOOL_DESCRIPTION,
-      schema: z34.object({
-        file_path: z34.string().describe("Absolute path to the file to edit"),
-        old_string: z34.string().describe("String to be replaced (must match exactly)"),
-        new_string: z34.string().describe("String to replace with"),
-        replace_all: z34.boolean().optional().default(false).describe("Whether to replace all occurrences")
+      schema: z310.object({
+        file_path: z310.string().describe("Absolute path to the file to edit"),
+        old_string: z310.string().describe("String to be replaced (must match exactly)"),
+        new_string: z310.string().describe("String to replace with"),
+        replace_all: z310.boolean().optional().default(false).describe("Whether to replace all occurrences")
       })
     }
   );
 }
 function createGlobTool(backend, options) {
   const { customDescription } = options;
-  return tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4799,16 +6786,16 @@ function createGlobTool(backend, options) {
     {
       name: "glob",
       description: customDescription || GLOB_TOOL_DESCRIPTION,
-      schema: z34.object({
-        pattern: z34.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
-        path: z34.string().optional().default("/").describe("Base path to search from (default: /)")
+      schema: z310.object({
+        pattern: z310.string().describe("Glob pattern (e.g., '*.py', '**/*.ts')"),
+        path: z310.string().optional().default("/").describe("Base path to search from (default: /)")
       })
     }
   );
 }
 function createGrepTool(backend, options) {
   const { customDescription } = options;
-  return tool33(
+  return tool41(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4840,10 +6827,10 @@ ${currentFile}:`);
     {
       name: "grep",
       description: customDescription || GREP_TOOL_DESCRIPTION,
-      schema: z34.object({
-        pattern: z34.string().describe("Regex pattern to search for"),
-        path: z34.string().optional().default("/").describe("Base path to search from (default: /)"),
-        glob: z34.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
+      schema: z310.object({
+        pattern: z310.string().describe("Regex pattern to search for"),
+        path: z310.string().optional().default("/").describe("Base path to search from (default: /)"),
+        glob: z310.string().optional().nullable().describe("Optional glob pattern to filter files (e.g., '*.py')")
       })
     }
   );
@@ -4970,6 +6957,31 @@ ${systemPrompt}` : systemPrompt;
   });
 }
 
+// src/middlewares/metricsMiddleware.ts
+import { createMiddleware as createMiddleware6 } from "langchain";
+function createMetricsMiddleware(params) {
+  const { serverKeys, serverDescriptions } = params;
+  if (!serverKeys || serverKeys.length === 0) {
+    return createMiddleware6({
+      name: "metricsMiddleware",
+      tools: []
+    });
+  }
+  const toolParams = {
+    serverKeys,
+    serverDescriptions
+  };
+  return createMiddleware6({
+    name: "metricsMiddleware",
+    tools: [
+      createListMetricsDataSourcesTool(toolParams),
+      createQueryMetricsListTool(toolParams),
+      createQueryMetricDefinitionTool(toolParams),
+      createQuerySemanticMetricDataTool(toolParams)
+    ]
+  });
+}
+
 // src/agent_lattice/builders/commonMiddleware.ts
 function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
   const middlewares = [];
@@ -5008,6 +7020,14 @@ function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
       case "skill":
         middlewares.push(createSkillMiddleware(config.config));
         break;
+      case "metrics":
+        {
+          const metricsConfig = config.config;
+          if (metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
+            middlewares.push(createMetricsMiddleware(metricsConfig));
+          }
+        }
+        break;
     }
   }
   return middlewares;
@@ -5051,9 +7071,9 @@ var ReActAgentGraphBuilder = class {
    */
   build(agentLattice, params) {
     const tools = params.tools.map((t) => {
-      const tool38 = getToolClient(t.key);
-      return tool38;
-    }).filter((tool38) => tool38 !== void 0);
+      const tool46 = getToolClient(t.key);
+      return tool46;
+    }).filter((tool46) => tool46 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
@@ -5079,11 +7099,11 @@ import {
 } from "langchain";
 
 // src/deep_agent_new/middleware/subagents.ts
-import { z as z35 } from "zod/v3";
+import { z as z42 } from "zod/v3";
 import {
-  createMiddleware as createMiddleware6,
+  createMiddleware as createMiddleware7,
   createAgent as createAgent2,
-  tool as tool34,
+  tool as tool42,
   ToolMessage as ToolMessage2,
   humanInTheLoopMiddleware
 } from "langchain";
@@ -5727,7 +7747,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return tool34(
+  return tool42(
     async (input, config) => {
       const { description, subagent_type } = input;
       try {
@@ -5770,9 +7790,9 @@ function createTaskTool(options) {
     {
       name: "task",
       description: finalTaskDescription,
-      schema: z35.object({
-        description: z35.string().describe("The task to execute with the selected agent"),
-        subagent_type: z35.string().describe(
+      schema: z42.object({
+        description: z42.string().describe("The task to execute with the selected agent"),
+        subagent_type: z42.string().describe(
           `Name of the agent to use. Available: ${Object.keys(
             subagentGraphs
           ).join(", ")}`
@@ -5801,7 +7821,7 @@ function createSubAgentMiddleware(options) {
     generalPurposeAgent,
     taskDescription
   });
-  return createMiddleware6({
+  return createMiddleware7({
     name: "subAgentMiddleware",
     tools: [taskTool],
     wrapModelCall: async (request, handler) => {
@@ -5822,14 +7842,14 @@ ${systemPrompt}` : systemPrompt;
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
 import {
-  createMiddleware as createMiddleware7,
+  createMiddleware as createMiddleware8,
   ToolMessage as ToolMessage3,
   AIMessage as AIMessage2
 } from "langchain";
 import { RemoveMessage } from "@langchain/core/messages";
 import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
 function createPatchToolCallsMiddleware() {
-  return createMiddleware7({
+  return createMiddleware8({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -5983,9 +8003,9 @@ var StoreBackend = class {
       if (!itemKey.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = itemKey.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = itemKey.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -6178,8 +8198,8 @@ var FilesystemBackend = class {
         throw new Error("Path traversal not allowed");
       }
       const full = path4.resolve(this.cwd, vpath.substring(1));
-      const relative3 = path4.relative(this.cwd, full);
-      if (relative3.startsWith("..") || path4.isAbsolute(relative3)) {
+      const relative4 = path4.relative(this.cwd, full);
+      if (relative4.startsWith("..") || path4.isAbsolute(relative4)) {
         throw new Error(`Path: ${full} outside root directory: ${this.cwd}`);
       }
       return full;
@@ -6514,9 +8534,9 @@ var FilesystemBackend = class {
             if (this.virtualMode) {
               try {
                 const resolved = path4.resolve(ftext);
-                const relative3 = path4.relative(this.cwd, resolved);
-                if (relative3.startsWith("..")) continue;
-                const normalizedRelative = relative3.split(path4.sep).join("/");
+                const relative4 = path4.relative(this.cwd, resolved);
+                if (relative4.startsWith("..")) continue;
+                const normalizedRelative = relative4.split(path4.sep).join("/");
                 virtPath = "/" + normalizedRelative;
               } catch {
                 continue;
@@ -6578,9 +8598,9 @@ var FilesystemBackend = class {
             let virtPath;
             if (this.virtualMode) {
               try {
-                const relative3 = path4.relative(this.cwd, fp);
-                if (relative3.startsWith("..")) continue;
-                const normalizedRelative = relative3.split(path4.sep).join("/");
+                const relative4 = path4.relative(this.cwd, fp);
+                if (relative4.startsWith("..")) continue;
+                const normalizedRelative = relative4.split(path4.sep).join("/");
                 virtPath = "/" + normalizedRelative;
               } catch {
                 continue;
@@ -6863,9 +8883,9 @@ var MemoryBackend = class {
       if (!k.startsWith(normalizedPath)) {
         continue;
       }
-      const relative3 = k.substring(normalizedPath.length);
-      if (relative3.includes("/")) {
-        const subdirName = relative3.split("/")[0];
+      const relative4 = k.substring(normalizedPath.length);
+      if (relative4.includes("/")) {
+        const subdirName = relative4.split("/")[0];
         subdirs.add(normalizedPath + subdirName + "/");
         continue;
       }
@@ -6961,8 +8981,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 import { Command as Command3 } from "@langchain/langgraph";
-import { z as z36 } from "zod";
-import { createMiddleware as createMiddleware8, tool as tool35, ToolMessage as ToolMessage4 } from "langchain";
+import { z as z43 } from "zod";
+import { createMiddleware as createMiddleware9, tool as tool43, 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.
@@ -7189,14 +9209,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 = z36.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = z36.object({
-  content: z36.string().describe("Content of the todo item"),
+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"),
   status: TodoStatus
 });
-var stateSchema = z36.object({ todos: z36.array(TodoSchema).default([]) });
+var stateSchema = z43.object({ todos: z43.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = tool35(
+  const writeTodos = tool43(
     ({ todos }, config) => {
       return new Command3({
         update: {
@@ -7213,12 +9233,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: z36.object({
-        todos: z36.array(TodoSchema).describe("List of todo items to update")
+      schema: z43.object({
+        todos: z43.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return createMiddleware8({
+  return createMiddleware9({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -7361,7 +9381,7 @@ var DeepAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool38) => tool38 !== void 0);
+    }).filter((tool46) => tool46 !== void 0);
     const subagents = params.subAgents.map((sa) => {
       if (sa.client) {
         return {
@@ -7399,7 +9419,7 @@ var DeepAgentGraphBuilder = class {
 };
 
 // src/agent_team/agent_team.ts
-import { z as z39 } from "zod/v3";
+import { z as z46 } from "zod/v3";
 import { createAgent as createAgent5 } from "langchain";
 
 // src/agent_team/types.ts
@@ -7835,14 +9855,14 @@ var InMemoryMailboxStore = class {
 };
 
 // src/agent_team/middleware/team.ts
-import { z as z38 } from "zod/v3";
-import { createMiddleware as createMiddleware9, createAgent as createAgent4, tool as tool37, ToolMessage as ToolMessage6 } from "langchain";
+import { z as z45 } from "zod/v3";
+import { createMiddleware as createMiddleware10, createAgent as createAgent4, tool as tool45, 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 z37 } from "zod/v3";
-import { tool as tool36, ToolMessage as ToolMessage5 } from "langchain";
+import { z as z44 } from "zod/v3";
+import { tool as tool44, ToolMessage as ToolMessage5 } from "langchain";
 import { Command as Command4 } from "@langchain/langgraph";
 
 // src/agent_team/middleware/formatMessages.ts
@@ -7867,7 +9887,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = tool36(
+  const claimTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -7892,12 +9912,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: z37.object({
-        task_id: z37.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
+      schema: z44.object({
+        task_id: z44.string().describe("ID of the task to claim (e.g. task-01). Use check_tasks to see IDs.")
       })
     }
   );
-  const completeTaskTool = tool36(
+  const completeTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -7918,13 +9938,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: z37.object({
-        task_id: z37.string().describe("ID of the task to complete"),
-        result: z37.string().describe("Summary of the task result")
+      schema: z44.object({
+        task_id: z44.string().describe("ID of the task to complete"),
+        result: z44.string().describe("Summary of the task result")
       })
     }
   );
-  const failTaskTool = tool36(
+  const failTaskTool = tool44(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -7945,13 +9965,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: z37.object({
-        task_id: z37.string().describe("ID of the task to fail"),
-        error: z37.string().describe("Description of why the task failed")
+      schema: z44.object({
+        task_id: z44.string().describe("ID of the task to fail"),
+        error: z44.string().describe("Description of why the task failed")
       })
     }
   );
-  const sendMessageTool = tool36(
+  const sendMessageTool = tool44(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -7965,11 +9985,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: z37.object({
-        to: z37.string().describe(
+      schema: z44.object({
+        to: z44.string().describe(
           'Recipient agent name (e.g. "team_lead" or a teammate name)'
         ),
-        content: z37.string().describe("Message content")
+        content: z44.string().describe("Message content")
       })
     }
   );
@@ -7989,7 +10009,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = tool36(
+  const readMessagesTool = tool44(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -8048,10 +10068,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: z37.object({})
+      schema: z44.object({})
     }
   );
-  const checkTasksTool = tool36(
+  const checkTasksTool = tool44(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -8059,10 +10079,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: z37.object({})
+      schema: z44.object({})
     }
   );
-  const broadcastMessageTool = tool36(
+  const broadcastMessageTool = tool44(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -8081,8 +10101,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: z37.object({
-        content: z37.string().describe("Message content to broadcast to others")
+      schema: z44.object({
+        content: z44.string().describe("Message content to broadcast to others")
       })
     }
   );
@@ -8305,7 +10325,7 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = tool37(
+  const createTeamTool = tool45(
     async (input, config) => {
       const state = getCurrentTaskInput3();
       if (state?.team?.teamId) {
@@ -8456,20 +10476,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: z38.object({
-        tasks: z38.array(
-          z38.object({
-            id: z38.string().describe("Task ID in format task-01, task-02, etc."),
-            title: z38.string().describe("Short task title"),
-            description: z38.string().describe("Detailed task description - what exactly needs to be done"),
-            dependencies: z38.array(z38.string()).optional().default([]).describe('Array of task IDs that must complete before this task (e.g. ["task-01"])')
+      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"])')
           })
         ).describe("List of tasks for teammates to work on. Each task needs unique ID (task-01, task-02, etc.)."),
-        teammates: z38.array(
-          z38.object({
-            name: z38.string().describe("Teammate name (must match a pre-configured teammate type)"),
-            role: z38.string().describe("Role category (e.g. researcher, writer, coder, reviewer)"),
-            description: z38.string().describe("What this teammate will focus on - specific instructions for their work")
+        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")
           })
         ).describe("Teammate agents to create. Each should have a clear role and focus.")
       })
@@ -8480,7 +10500,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 = tool37(
+  const addTasksTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -8532,20 +10552,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: z38.object({
-        tasks: z38.array(
-          z38.object({
-            id: z38.string().describe("Task ID in format task-01, task-02, etc. Must be unique."),
-            title: z38.string().describe("Short task title"),
-            description: z38.string().describe("Detailed task description - what needs to be done"),
-            assignee: z38.string().optional().describe("Teammate name to assign this task to (use when you need that person to do the work)"),
-            dependencies: z38.array(z38.string()).optional().default([]).describe("Array of task IDs that must complete before this task")
+      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")
           })
         ).describe("New tasks to add to the team")
       })
     }
   );
-  const assignTaskTool = tool37(
+  const assignTaskTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -8567,13 +10587,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: z38.object({
-        task_id: z38.string().describe("Task ID to assign"),
-        assignee: z38.string().describe("Teammate name to assign this task to")
+      schema: z45.object({
+        task_id: z45.string().describe("Task ID to assign"),
+        assignee: z45.string().describe("Teammate name to assign this task to")
       })
     }
   );
-  const setTaskStatusTool = tool37(
+  const setTaskStatusTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -8595,13 +10615,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: z38.object({
-        task_id: z38.string().describe("Task ID to update"),
-        status: z38.enum(["pending", "claimed", "in_progress", "completed", "failed"]).describe("New status for the task")
+      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")
       })
     }
   );
-  const setTaskDependenciesTool = tool37(
+  const setTaskDependenciesTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
@@ -8623,13 +10643,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: z38.object({
-        task_id: z38.string().describe("Task ID to update"),
-        dependencies: z38.array(z38.string()).describe("Task IDs that must complete before this task can be claimed")
+      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")
       })
     }
   );
-  const checkTasksTool = tool37(
+  const checkTasksTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -8669,12 +10689,12 @@ Task Status Values:
 - in_progress: Teammate is actively working on this task
 - completed: Task finished successfully
 - failed: Task encountered an error`,
-      schema: z38.object({
-        team_id: z38.string().optional().describe("Team ID (omit to use active team)")
+      schema: z45.object({
+        team_id: z45.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const sendMessageTool = tool37(
+  const sendMessageTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -8693,13 +10713,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: z38.object({
-        to: z38.string().describe("Recipient teammate name"),
-        content: z38.string().describe("Message content")
+      schema: z45.object({
+        to: z45.string().describe("Recipient teammate name"),
+        content: z45.string().describe("Message content")
       })
     }
   );
-  const readMessagesTool = tool37(
+  const readMessagesTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -8781,12 +10801,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: z38.object({
-        team_id: z38.string().optional().describe("Team ID (omit to use active team)")
+      schema: z45.object({
+        team_id: z45.string().optional().describe("Team ID (omit to use active team)")
       })
     }
   );
-  const disbandTeamTool = tool37(
+  const disbandTeamTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -8807,7 +10827,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 = tool37(
+  const broadcastMessageTool = tool45(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -8825,12 +10845,12 @@ Task Status Values:
     {
       name: "broadcast_message",
       description: "Send a message to all teammates at once. Use this to communicate with everyone in the team. Omit team_id to use the active team from state.",
-      schema: z38.object({
-        content: z38.string().describe("Message content to broadcast to all teammates")
+      schema: z45.object({
+        content: z45.string().describe("Message content to broadcast to all teammates")
       })
     }
   );
-  return createMiddleware9({
+  return createMiddleware10({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -8858,37 +10878,37 @@ ${TEAM_SYSTEM_PROMPT}` : TEAM_SYSTEM_PROMPT;
 }
 
 // src/agent_team/agent_team.ts
-var TeammateInfoSchema = z39.object({
-  name: z39.string().describe("Teammate name"),
-  role: z39.string().describe("Role category (e.g. research, writing, review)"),
-  description: z39.string().describe("What this teammate focuses on")
+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 TeamTaskInfoSchema = z39.object({
-  id: z39.string(),
-  title: z39.string(),
-  description: z39.string(),
-  status: z39.string().optional()
+var TeamTaskInfoSchema = z46.object({
+  id: z46.string(),
+  title: z46.string(),
+  description: z46.string(),
+  status: z46.string().optional()
 });
-var MailboxMessageSchema = z39.object({
-  id: z39.string().describe("Unique message identifier"),
-  from: z39.string().describe("Sender agent name"),
-  to: z39.string().describe("Recipient agent name"),
-  content: z39.string().describe("Message content"),
-  timestamp: z39.string().describe("ISO timestamp when the message was sent"),
-  type: z39.nativeEnum(MessageType).describe("Message type"),
-  read: z39.boolean().describe("Whether the recipient has read this message")
+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 TeamInfoSchema = z39.object({
-  teamId: z39.string().describe("Unique team identifier"),
-  teamLeadId: z39.string().default("team_lead").describe("Team lead agent ID"),
-  teammates: z39.array(TeammateInfoSchema).describe("Active teammates in this team"),
-  tasks: z39.array(TeamTaskInfoSchema).optional().describe("Initial tasks snapshot"),
-  createdAt: z39.string().optional().describe("ISO timestamp when team was created")
+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 TEAM_STATE_SCHEMA = z39.object({
+var TEAM_STATE_SCHEMA = z46.object({
   team: TeamInfoSchema.optional().describe("Team info: teamId, teamLeadId, teammates, tasks. Set when create_team succeeds."),
-  tasks: z39.array(TeamTaskInfoSchema).optional().describe("Current tasks snapshot from check_tasks. Updated on each check."),
-  team_mailbox: z39.array(MailboxMessageSchema).optional().describe("All team mailbox messages for display")
+  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")
 });
 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:
 
@@ -8968,7 +10988,7 @@ var TeamAgentGraphBuilder = class {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
-    }).filter((tool38) => tool38 !== void 0);
+    }).filter((tool46) => tool46 !== void 0);
     const teammates = params.subAgents.map((sa) => {
       const baseConfig = sa.config;
       return {
@@ -11645,10 +13665,10 @@ var McpLatticeManager = class _McpLatticeManager extends BaseLatticeManager {
     }
     const tools = await this.getAllTools();
     console.log(`[MCP] Registering ${tools.length} tools to Tool Lattice...`);
-    for (const tool38 of tools) {
-      const toolKey = prefix ? `${prefix}_${tool38.name}` : tool38.name;
-      tool38.name = toolKey;
-      toolLatticeManager.registerExistingTool(toolKey, tool38);
+    for (const tool46 of tools) {
+      const toolKey = prefix ? `${prefix}_${tool46.name}` : tool46.name;
+      tool46.name = toolKey;
+      toolLatticeManager.registerExistingTool(toolKey, tool46);
       console.log(`[MCP] Registered tool: ${toolKey}`);
     }
     console.log(`[MCP] Successfully registered ${tools.length} tools to Tool Lattice`);
@@ -11732,6 +13752,7 @@ export {
   ChunkBufferLatticeManager,
   CompositeBackend,
   ConsoleLoggerClient,
+  CustomMetricsClient,
   DefaultScheduleClient,
   EMPTY_CONTENT_WARNING,
   EmbeddingsLatticeManager,
@@ -11743,7 +13764,10 @@ export {
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
   InMemoryTaskListStore,
+  InMemoryTenantStore,
   InMemoryThreadStore,
+  InMemoryUserStore,
+  InMemoryUserTenantLinkStore,
   LINE_NUMBER_WIDTH,
   LoggerLatticeManager,
   MAX_LINE_LENGTH,
@@ -11754,14 +13778,17 @@ export {
   MemoryScheduleStorage,
   MemoryType,
   MessageType,
+  MetricsServerManager,
   ModelLatticeManager,
   PinoLoggerClient,
   PostgresDatabase,
+  PrometheusClient,
   Protocols,
   QueueLatticeManager,
   SandboxFilesystem,
   SandboxLatticeManager,
   ScheduleLatticeManager,
+  SemanticMetricsClient,
   SkillLatticeManager,
   SqlDatabaseManager,
   StateBackend,
@@ -11781,9 +13808,16 @@ export {
   createAgentTeam,
   createFileData,
   createInfoSqlTool,
+  createListMetricsDataSourcesTool,
+  createListMetricsServersTool,
   createListTablesSqlTool,
   createQueryCheckerSqlTool,
+  createQueryMetricDefinitionTool,
+  createQueryMetricsListTool,
+  createQuerySemanticMetricDataTool,
   createQuerySqlTool,
+  createQueryTableDefinitionTool,
+  createQueryTablesListTool,
   createTeamMiddleware,
   createTeammateTools,
   decrypt,
@@ -11829,6 +13863,7 @@ export {
   isValidSkillName,
   loggerLatticeManager,
   mcpManager,
+  metricsServerManager,
   modelLatticeManager,
   normalizeSandboxName,
   parseCronExpression,