@axiom-lattice/core 2.1.24 → 2.1.25

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   ChunkBufferLatticeManager: () => ChunkBufferLatticeManager,
   CompositeBackend: () => CompositeBackend,
   ConsoleLoggerClient: () => ConsoleLoggerClient,
+  CustomMetricsClient: () => CustomMetricsClient,
   DefaultScheduleClient: () => DefaultScheduleClient,
   EMPTY_CONTENT_WARNING: () => EMPTY_CONTENT_WARNING,
   EmbeddingsLatticeManager: () => EmbeddingsLatticeManager,
@@ -50,7 +51,10 @@ __export(index_exports, {
   InMemoryDatabaseConfigStore: () => InMemoryDatabaseConfigStore,
   InMemoryMailboxStore: () => InMemoryMailboxStore,
   InMemoryTaskListStore: () => InMemoryTaskListStore,
+  InMemoryTenantStore: () => InMemoryTenantStore,
   InMemoryThreadStore: () => InMemoryThreadStore,
+  InMemoryUserStore: () => InMemoryUserStore,
+  InMemoryUserTenantLinkStore: () => InMemoryUserTenantLinkStore,
   LINE_NUMBER_WIDTH: () => LINE_NUMBER_WIDTH,
   LoggerLatticeManager: () => LoggerLatticeManager,
   MAX_LINE_LENGTH: () => MAX_LINE_LENGTH,
@@ -61,14 +65,17 @@ __export(index_exports, {
   MemoryScheduleStorage: () => MemoryScheduleStorage,
   MemoryType: () => import_protocols2.MemoryType,
   MessageType: () => MessageType,
+  MetricsServerManager: () => MetricsServerManager,
   ModelLatticeManager: () => ModelLatticeManager,
   PinoLoggerClient: () => PinoLoggerClient,
   PostgresDatabase: () => PostgresDatabase,
+  PrometheusClient: () => PrometheusClient,
   Protocols: () => Protocols,
   QueueLatticeManager: () => QueueLatticeManager,
   SandboxFilesystem: () => SandboxFilesystem,
   SandboxLatticeManager: () => SandboxLatticeManager,
   ScheduleLatticeManager: () => ScheduleLatticeManager,
+  SemanticMetricsClient: () => SemanticMetricsClient,
   SkillLatticeManager: () => SkillLatticeManager,
   SqlDatabaseManager: () => SqlDatabaseManager,
   StateBackend: () => StateBackend,
@@ -88,9 +95,16 @@ __export(index_exports, {
   createAgentTeam: () => createAgentTeam,
   createFileData: () => createFileData,
   createInfoSqlTool: () => createInfoSqlTool,
+  createListMetricsDataSourcesTool: () => createListMetricsDataSourcesTool,
+  createListMetricsServersTool: () => createListMetricsServersTool,
   createListTablesSqlTool: () => createListTablesSqlTool,
   createQueryCheckerSqlTool: () => createQueryCheckerSqlTool,
+  createQueryMetricDefinitionTool: () => createQueryMetricDefinitionTool,
+  createQueryMetricsListTool: () => createQueryMetricsListTool,
+  createQuerySemanticMetricDataTool: () => createQuerySemanticMetricDataTool,
   createQuerySqlTool: () => createQuerySqlTool,
+  createQueryTableDefinitionTool: () => createQueryTableDefinitionTool,
+  createQueryTablesListTool: () => createQueryTablesListTool,
   createTeamMiddleware: () => createTeamMiddleware,
   createTeammateTools: () => createTeammateTools,
   decrypt: () => decrypt,
@@ -136,6 +150,7 @@ __export(index_exports, {
   isValidSkillName: () => isValidSkillName,
   loggerLatticeManager: () => loggerLatticeManager,
   mcpManager: () => mcpManager,
+  metricsServerManager: () => metricsServerManager,
   modelLatticeManager: () => modelLatticeManager,
   normalizeSandboxName: () => normalizeSandboxName,
   parseCronExpression: () => parseCronExpression,
@@ -680,11 +695,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工具默认不需要用户批准
@@ -692,7 +707,7 @@ var ToolLatticeManager = class _ToolLatticeManager extends BaseLatticeManager {
     const toolLattice = {
       key,
       config,
-      client: tool38
+      client: tool46
     };
     this.register(key, toolLattice);
   }
@@ -718,7 +733,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);
@@ -1389,8 +1404,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
+var import_zod7 = __toESM(require("zod"));
+var import_langchain5 = require("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 (0, import_langchain5.tool)(
+    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: import_zod7.default.object({})
+    }
+  );
+};
+
+// src/tool_lattice/metrics/list_metrics_datasources.ts
+var import_zod8 = __toESM(require("zod"));
+var import_langchain6 = require("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 (0, import_langchain6.tool)(
+    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: import_zod8.default.object({})
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_metrics_list.ts
+var import_zod9 = __toESM(require("zod"));
+var import_langchain7 = require("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 (0, import_langchain7.tool)(
+    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: import_zod9.default.object({
+        serverKey: import_zod9.default.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        datasourceIds: import_zod9.default.array(import_zod9.default.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
+var import_zod10 = __toESM(require("zod"));
+var import_langchain8 = require("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 (0, import_langchain8.tool)(
+    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: import_zod10.default.object({
+        serverKey: import_zod10.default.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        metricName: import_zod10.default.string().describe("The name of the metric to get definition for."),
+        datasourceId: import_zod10.default.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
+var import_zod11 = __toESM(require("zod"));
+var import_langchain9 = require("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 (0, import_langchain9.tool)(
+    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: import_zod11.default.object({
+        serverKey: import_zod11.default.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        datasourceId: import_zod11.default.string().describe("The data source ID to query metrics from."),
+        metrics: import_zod11.default.array(import_zod11.default.string()).describe("Array of metric names to query (e.g., ['net_sales_amt', 'gross_profit'])."),
+        groupBy: import_zod11.default.array(import_zod11.default.string()).optional().describe("Optional array of dimensions to group by (e.g., ['DocDate__month', 'CustomerCode'])."),
+        filters: import_zod11.default.array(import_zod11.default.object({
+          dimension: import_zod11.default.string().describe("Dimension/column name to filter on"),
+          operator: import_zod11.default.string().describe("Operator (e.g., 'BETWEEN', '=', '>', '<')"),
+          values: import_zod11.default.array(import_zod11.default.union([import_zod11.default.string(), import_zod11.default.number(), import_zod11.default.boolean()])).describe("Filter values")
+        })).optional().describe("Optional array of filters to apply to the query."),
+        limit: import_zod11.default.number().optional().describe("Maximum number of results to return (default: 1000).")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/metrics/query_tables_list.ts
+var import_zod12 = __toESM(require("zod"));
+var import_langchain10 = require("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 (0, import_langchain10.tool)(
+    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: import_zod12.default.object({
+        serverKey: import_zod12.default.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        datasourceIds: import_zod12.default.array(import_zod12.default.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
+var import_zod13 = __toESM(require("zod"));
+var import_langchain11 = require("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 (0, import_langchain11.tool)(
+    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: import_zod13.default.object({
+        serverKey: import_zod13.default.string().describe(`Target semantic metrics server. Choose from: ${serverKeys.join(", ")}`),
+        tableName: import_zod13.default.string().describe("The name of the table to get definition for."),
+        datasourceId: import_zod13.default.string().optional().describe("Optional specific datasource ID to search in. If not provided, searches all selected datasources.")
+      })
+    }
+  );
+};
+
 // src/tool_lattice/code_eval/index.ts
-var import_zod7 = __toESM(require("zod"));
+var import_zod14 = __toESM(require("zod"));
 
 // src/sandbox_lattice/SandboxLatticeManager.ts
 var import_sandbox = require("@agent-infra/sandbox");
@@ -1629,7 +3231,7 @@ var getSandBoxManager = (key = "default") => {
 };
 
 // src/tool_lattice/code_eval/index.ts
-var import_langchain5 = require("langchain");
+var import_langchain12 = require("langchain");
 var CODE_EVAL_DESCRIPTION = `Execute code in Python or JavaScript runtime.
 
 Args:
@@ -1639,7 +3241,7 @@ Args:
 Returns:
     Dict containing output, errors, and execution details`;
 var createCodeEvalTool = ({ isolatedLevel }) => {
-  return (0, import_langchain5.tool)(async (input, exe_config) => {
+  return (0, import_langchain12.tool)(async (input, exe_config) => {
     try {
       const runConfig = exe_config.configurable?.runConfig;
       const sandboxManager = getSandBoxManager();
@@ -1680,16 +3282,16 @@ ${traceback.join("\n")}`);
   }, {
     name: "execute_code",
     description: CODE_EVAL_DESCRIPTION,
-    schema: import_zod7.default.object({
-      language: import_zod7.default.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
-      code: import_zod7.default.string().describe("Code to execute")
+    schema: import_zod14.default.object({
+      language: import_zod14.default.enum(["python", "javascript"]).describe("Programming language: 'python' or 'javascript'"),
+      code: import_zod14.default.string().describe("Code to execute")
     })
   });
 };
 
 // src/tool_lattice/code_execute_file/index.ts
-var import_zod8 = __toESM(require("zod"));
-var import_langchain6 = require("langchain");
+var import_zod15 = __toESM(require("zod"));
+var import_langchain13 = require("langchain");
 var path = __toESM(require("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) {
@@ -1702,7 +3304,7 @@ function inferLanguageFromPath(filePath) {
   return null;
 }
 var createCodeExecuteFileTool = ({ isolatedLevel }) => {
-  return (0, import_langchain6.tool)(
+  return (0, import_langchain13.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1765,15 +3367,15 @@ ${traceback.join("\n")}`);
     {
       name: "execute_code_file",
       description: CODE_EXECUTE_FILE_DESCRIPTION,
-      schema: import_zod8.default.object({
-        file_path: import_zod8.default.string().describe("Path to the code file to execute (absolute path in sandbox filesystem). Only supports .py (Python) and .js/.mjs (JavaScript) files.")
+      schema: import_zod15.default.object({
+        file_path: import_zod15.default.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
-var import_zod9 = __toESM(require("zod"));
+var import_zod16 = __toESM(require("zod"));
 var CONVERT_TO_MARKDOWN_DESCRIPTION = `Convert a resource described by an http:, https:, file: or data: URI to markdown.
 
 Args:
@@ -1790,8 +3392,8 @@ registerToolLattice(
     name: "convert_to_markdown",
     description: CONVERT_TO_MARKDOWN_DESCRIPTION,
     needUserApprove: false,
-    schema: import_zod9.default.object({
-      uri: import_zod9.default.string().describe("The URI to convert.")
+    schema: import_zod16.default.object({
+      uri: import_zod16.default.string().describe("The URI to convert.")
     })
   },
   async (input, exe_config) => {
@@ -1814,15 +3416,15 @@ registerToolLattice(
 );
 
 // src/tool_lattice/browser/browser_navigate.ts
-var import_zod10 = __toESM(require("zod"));
-var import_langchain7 = require("langchain");
+var import_zod17 = __toESM(require("zod"));
+var import_langchain14 = require("langchain");
 var BROWSER_NAVIGATE_DESCRIPTION = `Navigate to a URL.
 
 Args:
     url (str): The URL to navigate to.
 `;
 var createBrowserNavigateTool = ({ isolatedLevel }) => {
-  return (0, import_langchain7.tool)(
+  return (0, import_langchain14.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1842,23 +3444,23 @@ var createBrowserNavigateTool = ({ isolatedLevel }) => {
     {
       name: "browser_navigate",
       description: BROWSER_NAVIGATE_DESCRIPTION,
-      schema: import_zod10.default.object({
-        url: import_zod10.default.string().describe("The URL to navigate to.")
+      schema: import_zod17.default.object({
+        url: import_zod17.default.string().describe("The URL to navigate to.")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_click.ts
-var import_zod11 = __toESM(require("zod"));
-var import_langchain8 = require("langchain");
+var import_zod18 = __toESM(require("zod"));
+var import_langchain15 = require("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 (0, import_langchain8.tool)(
+  return (0, import_langchain15.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1878,23 +3480,23 @@ var createBrowserClickTool = ({ isolatedLevel }) => {
     {
       name: "browser_click",
       description: BROWSER_CLICK_DESCRIPTION,
-      schema: import_zod11.default.object({
-        index: import_zod11.default.number().describe("Index of the element to click")
+      schema: import_zod18.default.object({
+        index: import_zod18.default.number().describe("Index of the element to click")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_text.ts
-var import_zod12 = __toESM(require("zod"));
-var import_langchain9 = require("langchain");
+var import_zod19 = __toESM(require("zod"));
+var import_langchain16 = require("langchain");
 var BROWSER_GET_TEXT_DESCRIPTION = `Get the text content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetTextTool = ({ isolatedLevel }) => {
-  return (0, import_langchain9.tool)(
+  return (0, import_langchain16.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1912,21 +3514,21 @@ var createBrowserGetTextTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_text",
       description: BROWSER_GET_TEXT_DESCRIPTION,
-      schema: import_zod12.default.object({})
+      schema: import_zod19.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_markdown.ts
-var import_zod13 = __toESM(require("zod"));
-var import_langchain10 = require("langchain");
+var import_zod20 = __toESM(require("zod"));
+var import_langchain17 = require("langchain");
 var BROWSER_GET_MARKDOWN_DESCRIPTION = `Get the markdown content of the current page.
 
 Args:
     None
 `;
 var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
-  return (0, import_langchain10.tool)(
+  return (0, import_langchain17.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1944,21 +3546,21 @@ var createBrowserGetMarkdownTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_markdown",
       description: BROWSER_GET_MARKDOWN_DESCRIPTION,
-      schema: import_zod13.default.object({})
+      schema: import_zod20.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_evaluate.ts
-var import_zod14 = __toESM(require("zod"));
-var import_langchain11 = require("langchain");
+var import_zod21 = __toESM(require("zod"));
+var import_langchain18 = require("langchain");
 var BROWSER_EVALUATE_DESCRIPTION = `Execute JavaScript in the browser console.
 
 Args:
     script (str): JavaScript code to execute, () => { /* code */ }
 `;
 var createBrowserEvaluateTool = ({ isolatedLevel }) => {
-  return (0, import_langchain11.tool)(
+  return (0, import_langchain18.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -1978,16 +3580,16 @@ var createBrowserEvaluateTool = ({ isolatedLevel }) => {
     {
       name: "browser_evaluate",
       description: BROWSER_EVALUATE_DESCRIPTION,
-      schema: import_zod14.default.object({
-        script: import_zod14.default.string().describe("JavaScript code to execute, () => { /* code */ }")
+      schema: import_zod21.default.object({
+        script: import_zod21.default.string().describe("JavaScript code to execute, () => { /* code */ }")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_screenshot.ts
-var import_zod15 = __toESM(require("zod"));
-var import_langchain12 = require("langchain");
+var import_zod22 = __toESM(require("zod"));
+var import_langchain19 = require("langchain");
 var BROWSER_SCREENSHOT_DESCRIPTION = `Take a screenshot of the current page or a specific element.
 
 Args:
@@ -2000,7 +3602,7 @@ Args:
     highlight (bool): Highlight the element
 `;
 var createBrowserScreenshotTool = ({ isolatedLevel }) => {
-  return (0, import_langchain12.tool)(
+  return (0, import_langchain19.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2052,29 +3654,29 @@ var createBrowserScreenshotTool = ({ isolatedLevel }) => {
     {
       name: "browser_screenshot",
       description: BROWSER_SCREENSHOT_DESCRIPTION,
-      schema: import_zod15.default.object({
-        name: import_zod15.default.string().optional().describe("Name for the screenshot"),
-        selector: import_zod15.default.string().optional().describe("CSS selector for element to screenshot"),
-        index: import_zod15.default.number().optional().describe("index of the element to screenshot"),
-        width: import_zod15.default.number().optional().describe("Width in pixels (default: viewport width)"),
-        height: import_zod15.default.number().optional().describe("Height in pixels (default: viewport height)"),
-        fullPage: import_zod15.default.boolean().optional().describe("Full page screenshot (default: false)"),
-        highlight: import_zod15.default.boolean().default(false).describe("Highlight the element")
+      schema: import_zod22.default.object({
+        name: import_zod22.default.string().optional().describe("Name for the screenshot"),
+        selector: import_zod22.default.string().optional().describe("CSS selector for element to screenshot"),
+        index: import_zod22.default.number().optional().describe("index of the element to screenshot"),
+        width: import_zod22.default.number().optional().describe("Width in pixels (default: viewport width)"),
+        height: import_zod22.default.number().optional().describe("Height in pixels (default: viewport height)"),
+        fullPage: import_zod22.default.boolean().optional().describe("Full page screenshot (default: false)"),
+        highlight: import_zod22.default.boolean().default(false).describe("Highlight the element")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_scroll.ts
-var import_zod16 = __toESM(require("zod"));
-var import_langchain13 = require("langchain");
+var import_zod23 = __toESM(require("zod"));
+var import_langchain20 = require("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 (0, import_langchain13.tool)(
+  return (0, import_langchain20.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2094,16 +3696,16 @@ var createBrowserScrollTool = ({ isolatedLevel }) => {
     {
       name: "browser_scroll",
       description: BROWSER_SCROLL_DESCRIPTION,
-      schema: import_zod16.default.object({
-        amount: import_zod16.default.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
+      schema: import_zod23.default.object({
+        amount: import_zod23.default.number().optional().describe("Pixels to scroll (positive for down, negative for up)")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_form_input_fill.ts
-var import_zod17 = __toESM(require("zod"));
-var import_langchain14 = require("langchain");
+var import_zod24 = __toESM(require("zod"));
+var import_langchain21 = require("langchain");
 var BROWSER_FORM_INPUT_FILL_DESCRIPTION = `Fill out an input field, before using the tool, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -2113,7 +3715,7 @@ Args:
     clear (bool): Whether to clear existing text before filling
 `;
 var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
-  return (0, import_langchain14.tool)(
+  return (0, import_langchain21.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2136,19 +3738,19 @@ var createBrowserFormInputFillTool = ({ isolatedLevel }) => {
     {
       name: "browser_form_input_fill",
       description: BROWSER_FORM_INPUT_FILL_DESCRIPTION,
-      schema: import_zod17.default.object({
-        selector: import_zod17.default.string().optional().describe("CSS selector for input field"),
-        index: import_zod17.default.number().optional().describe("Index of the element to fill"),
-        value: import_zod17.default.string().describe("Value to fill"),
-        clear: import_zod17.default.boolean().default(false).describe("Whether to clear existing text before filling")
+      schema: import_zod24.default.object({
+        selector: import_zod24.default.string().optional().describe("CSS selector for input field"),
+        index: import_zod24.default.number().optional().describe("Index of the element to fill"),
+        value: import_zod24.default.string().describe("Value to fill"),
+        clear: import_zod24.default.boolean().default(false).describe("Whether to clear existing text before filling")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_select.ts
-var import_zod18 = __toESM(require("zod"));
-var import_langchain15 = require("langchain");
+var import_zod25 = __toESM(require("zod"));
+var import_langchain22 = require("langchain");
 var BROWSER_SELECT_DESCRIPTION = `Select an element on the page with index, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -2157,7 +3759,7 @@ Args:
     value (str): Value to select
 `;
 var createBrowserSelectTool = ({ isolatedLevel }) => {
-  return (0, import_langchain15.tool)(
+  return (0, import_langchain22.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2179,18 +3781,18 @@ var createBrowserSelectTool = ({ isolatedLevel }) => {
     {
       name: "browser_select",
       description: BROWSER_SELECT_DESCRIPTION,
-      schema: import_zod18.default.object({
-        index: import_zod18.default.number().optional().describe("Index of the element to select"),
-        selector: import_zod18.default.string().optional().describe("CSS selector for element to select"),
-        value: import_zod18.default.string().describe("Value to select")
+      schema: import_zod25.default.object({
+        index: import_zod25.default.number().optional().describe("Index of the element to select"),
+        selector: import_zod25.default.string().optional().describe("CSS selector for element to select"),
+        value: import_zod25.default.string().describe("Value to select")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_hover.ts
-var import_zod19 = __toESM(require("zod"));
-var import_langchain16 = require("langchain");
+var import_zod26 = __toESM(require("zod"));
+var import_langchain23 = require("langchain");
 var BROWSER_HOVER_DESCRIPTION = `Hover an element on the page, Either 'index' or 'selector' must be provided.
 
 Args:
@@ -2198,7 +3800,7 @@ Args:
     selector (str): CSS selector for element to hover
 `;
 var createBrowserHoverTool = ({ isolatedLevel }) => {
-  return (0, import_langchain16.tool)(
+  return (0, import_langchain23.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2219,24 +3821,24 @@ var createBrowserHoverTool = ({ isolatedLevel }) => {
     {
       name: "browser_hover",
       description: BROWSER_HOVER_DESCRIPTION,
-      schema: import_zod19.default.object({
-        index: import_zod19.default.number().optional().describe("Index of the element to hover"),
-        selector: import_zod19.default.string().optional().describe("CSS selector for element to hover")
+      schema: import_zod26.default.object({
+        index: import_zod26.default.number().optional().describe("Index of the element to hover"),
+        selector: import_zod26.default.string().optional().describe("CSS selector for element to hover")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_back.ts
-var import_zod20 = __toESM(require("zod"));
-var import_langchain17 = require("langchain");
+var import_zod27 = __toESM(require("zod"));
+var import_langchain24 = require("langchain");
 var BROWSER_GO_BACK_DESCRIPTION = `Go back to the previous page.
 
 Args:
     None
 `;
 var createBrowserGoBackTool = ({ isolatedLevel }) => {
-  return (0, import_langchain17.tool)(
+  return (0, import_langchain24.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2254,21 +3856,21 @@ var createBrowserGoBackTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_back",
       description: BROWSER_GO_BACK_DESCRIPTION,
-      schema: import_zod20.default.object({})
+      schema: import_zod27.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_go_forward.ts
-var import_zod21 = __toESM(require("zod"));
-var import_langchain18 = require("langchain");
+var import_zod28 = __toESM(require("zod"));
+var import_langchain25 = require("langchain");
 var BROWSER_GO_FORWARD_DESCRIPTION = `Go forward to the next page.
 
 Args:
     None
 `;
 var createBrowserGoForwardTool = ({ isolatedLevel }) => {
-  return (0, import_langchain18.tool)(
+  return (0, import_langchain25.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2286,21 +3888,21 @@ var createBrowserGoForwardTool = ({ isolatedLevel }) => {
     {
       name: "browser_go_forward",
       description: BROWSER_GO_FORWARD_DESCRIPTION,
-      schema: import_zod21.default.object({})
+      schema: import_zod28.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_new_tab.ts
-var import_zod22 = __toESM(require("zod"));
-var import_langchain19 = require("langchain");
+var import_zod29 = __toESM(require("zod"));
+var import_langchain26 = require("langchain");
 var BROWSER_NEW_TAB_DESCRIPTION = `Open a new tab.
 
 Args:
     url (str): URL to open in the new tab
 `;
 var createBrowserNewTabTool = ({ isolatedLevel }) => {
-  return (0, import_langchain19.tool)(
+  return (0, import_langchain26.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2320,23 +3922,23 @@ var createBrowserNewTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_new_tab",
       description: BROWSER_NEW_TAB_DESCRIPTION,
-      schema: import_zod22.default.object({
-        url: import_zod22.default.string().describe("URL to open in the new tab")
+      schema: import_zod29.default.object({
+        url: import_zod29.default.string().describe("URL to open in the new tab")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_tab_list.ts
-var import_zod23 = __toESM(require("zod"));
-var import_langchain20 = require("langchain");
+var import_zod30 = __toESM(require("zod"));
+var import_langchain27 = require("langchain");
 var BROWSER_TAB_LIST_DESCRIPTION = `Get the list of tabs.
 
 Args:
     None
 `;
 var createBrowserTabListTool = ({ isolatedLevel }) => {
-  return (0, import_langchain20.tool)(
+  return (0, import_langchain27.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2354,21 +3956,21 @@ var createBrowserTabListTool = ({ isolatedLevel }) => {
     {
       name: "browser_tab_list",
       description: BROWSER_TAB_LIST_DESCRIPTION,
-      schema: import_zod23.default.object({})
+      schema: import_zod30.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_switch_tab.ts
-var import_zod24 = __toESM(require("zod"));
-var import_langchain21 = require("langchain");
+var import_zod31 = __toESM(require("zod"));
+var import_langchain28 = require("langchain");
 var BROWSER_SWITCH_TAB_DESCRIPTION = `Switch to a specific tab.
 
 Args:
     index (int): Tab index to switch to
 `;
 var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
-  return (0, import_langchain21.tool)(
+  return (0, import_langchain28.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2388,23 +3990,23 @@ var createBrowserSwitchTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_switch_tab",
       description: BROWSER_SWITCH_TAB_DESCRIPTION,
-      schema: import_zod24.default.object({
-        index: import_zod24.default.number().describe("Tab index to switch to")
+      schema: import_zod31.default.object({
+        index: import_zod31.default.number().describe("Tab index to switch to")
       })
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close_tab.ts
-var import_zod25 = __toESM(require("zod"));
-var import_langchain22 = require("langchain");
+var import_zod32 = __toESM(require("zod"));
+var import_langchain29 = require("langchain");
 var BROWSER_CLOSE_TAB_DESCRIPTION = `Close the current tab.
 
 Args:
     None
 `;
 var createBrowserCloseTabTool = ({ isolatedLevel }) => {
-  return (0, import_langchain22.tool)(
+  return (0, import_langchain29.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2422,21 +4024,21 @@ var createBrowserCloseTabTool = ({ isolatedLevel }) => {
     {
       name: "browser_close_tab",
       description: BROWSER_CLOSE_TAB_DESCRIPTION,
-      schema: import_zod25.default.object({})
+      schema: import_zod32.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_close.ts
-var import_zod26 = __toESM(require("zod"));
-var import_langchain23 = require("langchain");
+var import_zod33 = __toESM(require("zod"));
+var import_langchain30 = require("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 (0, import_langchain23.tool)(
+  return (0, import_langchain30.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2454,21 +4056,21 @@ var createBrowserCloseTool = ({ isolatedLevel }) => {
     {
       name: "browser_close",
       description: BROWSER_CLOSE_DESCRIPTION,
-      schema: import_zod26.default.object({})
+      schema: import_zod33.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_press_key.ts
-var import_zod27 = __toESM(require("zod"));
-var import_langchain24 = require("langchain");
+var import_zod34 = __toESM(require("zod"));
+var import_langchain31 = require("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 (0, import_langchain24.tool)(
+  return (0, import_langchain31.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2488,8 +4090,8 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
     {
       name: "browser_press_key",
       description: BROWSER_PRESS_KEY_DESCRIPTION,
-      schema: import_zod27.default.object({
-        key: import_zod27.default.enum([
+      schema: import_zod34.default.object({
+        key: import_zod34.default.enum([
           "Enter",
           "Tab",
           "Escape",
@@ -2536,15 +4138,15 @@ var createBrowserPressKeyTool = ({ isolatedLevel }) => {
 };
 
 // src/tool_lattice/browser/browser_read_links.ts
-var import_zod28 = __toESM(require("zod"));
-var import_langchain25 = require("langchain");
+var import_zod35 = __toESM(require("zod"));
+var import_langchain32 = require("langchain");
 var BROWSER_READ_LINKS_DESCRIPTION = `Get all links on the current page.
 
 Args:
     None
 `;
 var createBrowserReadLinksTool = ({ isolatedLevel }) => {
-  return (0, import_langchain25.tool)(
+  return (0, import_langchain32.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2562,21 +4164,21 @@ var createBrowserReadLinksTool = ({ isolatedLevel }) => {
     {
       name: "browser_read_links",
       description: BROWSER_READ_LINKS_DESCRIPTION,
-      schema: import_zod28.default.object({})
+      schema: import_zod35.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_clickable_elements.ts
-var import_zod29 = __toESM(require("zod"));
-var import_langchain26 = require("langchain");
+var import_zod36 = __toESM(require("zod"));
+var import_langchain33 = require("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 (0, import_langchain26.tool)(
+  return (0, import_langchain33.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2594,21 +4196,21 @@ var createBrowserGetClickableElementsTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_clickable_elements",
       description: BROWSER_GET_CLICKABLE_ELEMENTS_DESCRIPTION,
-      schema: import_zod29.default.object({})
+      schema: import_zod36.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/browser_get_download_list.ts
-var import_zod30 = __toESM(require("zod"));
-var import_langchain27 = require("langchain");
+var import_zod37 = __toESM(require("zod"));
+var import_langchain34 = require("langchain");
 var BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION = `Get the list of downloaded files.
 
 Args:
     None
 `;
 var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
-  return (0, import_langchain27.tool)(
+  return (0, import_langchain34.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2626,14 +4228,14 @@ var createBrowserGetDownloadListTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_download_list",
       description: BROWSER_GET_DOWNLOAD_LIST_DESCRIPTION,
-      schema: import_zod30.default.object({})
+      schema: import_zod37.default.object({})
     }
   );
 };
 
 // src/tool_lattice/browser/get_info.ts
-var import_zod31 = __toESM(require("zod"));
-var import_langchain28 = require("langchain");
+var import_zod38 = __toESM(require("zod"));
+var import_langchain35 = require("langchain");
 var BROWSER_GET_INFO_DESCRIPTION = `Get information about browser, like CDP URL, viewport size, etc.
 
 Args:
@@ -2642,7 +4244,7 @@ Args:
 Returns:
     Dict containing browser information including CDP URL, viewport dimensions, and other browser metadata.`;
 var createBrowserGetInfoTool = ({ isolatedLevel }) => {
-  return (0, import_langchain28.tool)(
+  return (0, import_langchain35.tool)(
     async (input, exe_config) => {
       try {
         const runConfig = exe_config.configurable?.runConfig;
@@ -2660,7 +4262,7 @@ var createBrowserGetInfoTool = ({ isolatedLevel }) => {
     {
       name: "browser_get_info",
       description: BROWSER_GET_INFO_DESCRIPTION,
-      schema: import_zod31.default.object({})
+      schema: import_zod38.default.object({})
     }
   );
 };
@@ -2749,14 +4351,14 @@ var memory = new import_langgraph2.MemorySaver();
 registerCheckpointSaver("default", memory);
 
 // src/agent_lattice/builders/state.ts
-var import_zod32 = require("@langchain/langgraph/zod");
+var import_zod39 = require("@langchain/langgraph/zod");
 var import_langgraph3 = require("@langchain/langgraph");
 var createReactAgentSchema = (schema) => {
   return schema ? import_langgraph3.MessagesZodState.extend(schema.shape) : void 0;
 };
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
-var import_langchain36 = require("langchain");
+var import_langchain45 = require("langchain");
 
 // src/deep_agent_new/backends/sandboxFiles.ts
 var import_sandbox2 = require("@agent-infra/sandbox");
@@ -2799,8 +4401,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;
   }
   /**
@@ -3035,18 +4637,18 @@ var SandboxFilesystem = class {
 };
 
 // src/middlewares/codeEvalMiddleware.ts
-var import_langchain29 = require("langchain");
+var import_langchain36 = require("langchain");
 function createCodeEvalMiddleware(params = { isolatedLevel: "global" }) {
   const codeEvalTool = createCodeEvalTool({ isolatedLevel: params.isolatedLevel });
   const codeExecuteFileTool = createCodeExecuteFileTool({ isolatedLevel: params.isolatedLevel });
-  return (0, import_langchain29.createMiddleware)({
+  return (0, import_langchain36.createMiddleware)({
     name: "codeEvalMiddleware",
     tools: [codeEvalTool, codeExecuteFileTool, getToolClient("convert_to_markdown")]
   });
 }
 
 // src/middlewares/browserMiddleware.ts
-var import_langchain30 = require("langchain");
+var import_langchain37 = require("langchain");
 function createBrowserMiddleware(params = { isolatedLevel: "global" }) {
   const isolatedLevel = params.isolatedLevel || "global";
   const tools = [
@@ -3073,18 +4675,18 @@ function createBrowserMiddleware(params = { isolatedLevel: "global" }) {
     createBrowserGetDownloadListTool({ isolatedLevel }),
     createBrowserGetInfoTool({ isolatedLevel })
   ];
-  return (0, import_langchain30.createMiddleware)({
+  return (0, import_langchain37.createMiddleware)({
     name: "browserMiddleware",
     tools
   });
 }
 
 // src/middlewares/sqlMiddleware.ts
-var import_langchain31 = require("langchain");
+var import_langchain38 = require("langchain");
 function createSqlMiddleware(params) {
   const { databaseKeys, databaseDescriptions } = params;
   if (!databaseKeys || databaseKeys.length === 0) {
-    return (0, import_langchain31.createMiddleware)({
+    return (0, import_langchain38.createMiddleware)({
       name: "sqlMiddleware",
       tools: []
     });
@@ -3093,7 +4695,7 @@ function createSqlMiddleware(params) {
     databaseKeys,
     databaseDescriptions
   };
-  return (0, import_langchain31.createMiddleware)({
+  return (0, import_langchain38.createMiddleware)({
     name: "sqlMiddleware",
     tools: [
       createListTablesSqlTool(toolParams),
@@ -3105,7 +4707,7 @@ function createSqlMiddleware(params) {
 }
 
 // src/middlewares/skillMiddleware.ts
-var import_langchain34 = require("langchain");
+var import_langchain42 = require("langchain");
 
 // src/store_lattice/InMemoryThreadStore.ts
 var InMemoryThreadStore = class {
@@ -3753,7 +5355,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;
+    }
   }
 };
 
@@ -4009,6 +5662,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 {
   /**
@@ -4139,6 +6077,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",
@@ -4149,13 +6088,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
-var import_zod33 = __toESM(require("zod"));
-var import_langchain32 = require("langchain");
+var import_zod40 = __toESM(require("zod"));
+var import_langchain39 = require("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 (0, import_langchain32.tool)(
+  return (0, import_langchain39.tool)(
     async (_input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -4179,17 +6125,17 @@ var createLoadSkillsTool = ({ skills } = {}) => {
     {
       name: "load_skills",
       description: LOAD_SKILLS_DESCRIPTION,
-      schema: import_zod33.default.object({})
+      schema: import_zod40.default.object({})
     }
   );
 };
 
 // src/tool_lattice/skill/load_skill_content.ts
-var import_zod34 = __toESM(require("zod"));
-var import_langchain33 = require("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.`;
+var import_zod41 = __toESM(require("zod"));
+var import_langchain40 = require("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 (0, import_langchain33.tool)(
+  return (0, import_langchain40.tool)(
     async (input, _exe_config) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
@@ -4223,8 +6169,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)}`;
       }
@@ -4232,16 +6193,55 @@ ${content}`;
     {
       name: "load_skill_content",
       description: LOAD_SKILL_CONTENT_DESCRIPTION,
-      schema: import_zod34.default.object({
-        skill_name: import_zod34.default.string().describe("The name of the skill to load")
+      schema: import_zod41.default.object({
+        skill_name: import_zod41.default.string().describe("The name of the skill to load")
+      })
+    }
+  );
+};
+
+// src/tool_lattice/skill/load_skill_resource.ts
+var import_zod42 = __toESM(require("zod"));
+var import_langchain41 = require("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 (0, import_langchain41.tool)(
+    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: import_zod42.default.object({
+        skill_name: import_zod42.default.string().describe("The name of the skill containing the resource"),
+        resource_path: import_zod42.default.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 = [],
@@ -4250,11 +6250,12 @@ function createSkillMiddleware(params = {}) {
     extraNote = DEFAULT_EXTRA_NOTE
   } = params;
   let latestSkills = [];
-  return (0, import_langchain34.createMiddleware)({
+  return (0, import_langchain42.createMiddleware)({
     name: "skillMiddleware",
     tools: [
       createLoadSkillsTool({ skills: readAll ? void 0 : skills }),
-      createLoadSkillContentTool()
+      createLoadSkillContentTool(),
+      createLoadSkillResourceTool()
     ],
     beforeAgent: async () => {
       try {
@@ -4274,7 +6275,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}
@@ -4293,10 +6295,10 @@ ${extraNote}`;
 }
 
 // src/deep_agent_new/middleware/fs.ts
-var import_langchain35 = require("langchain");
+var import_langchain43 = require("langchain");
 var import_langgraph4 = require("@langchain/langgraph");
 var import_v3 = require("zod/v3");
-var import_zod35 = require("@langchain/langgraph/zod");
+var import_zod43 = require("@langchain/langgraph/zod");
 
 // src/deep_agent_new/backends/utils.ts
 var import_micromatch = __toESM(require("micromatch"));
@@ -4441,15 +6443,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 (import_micromatch.default.isMatch(relative3, effectivePattern, {
+    if (import_micromatch.default.isMatch(relative4, effectivePattern, {
       dot: true,
       nobrace: false
     })) {
@@ -4603,9 +6605,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;
       }
@@ -4760,7 +6762,7 @@ function fileDataReducer(left, right) {
   return result;
 }
 var FilesystemStateSchema = import_v3.z.object({
-  files: (0, import_zod35.withLangGraph)(
+  files: (0, import_zod43.withLangGraph)(
     import_v3.z.record(import_v3.z.string(), FileDataSchema).default({}),
     {
       reducer: {
@@ -4792,7 +6794,7 @@ var GLOB_TOOL_DESCRIPTION = "Find files matching a glob pattern (e.g., '**/*.py'
 var GREP_TOOL_DESCRIPTION = "Search for a regex pattern in files. Returns matching files and line numbers";
 function createLsTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4828,7 +6830,7 @@ function createLsTool(backend, options) {
 }
 function createReadFileTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4853,7 +6855,7 @@ function createReadFileTool(backend, options) {
 }
 function createWriteFileTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4867,7 +6869,7 @@ function createWriteFileTool(backend, options) {
       if (result.error) {
         return result.error;
       }
-      const message = new import_langchain35.ToolMessage({
+      const message = new import_langchain43.ToolMessage({
         content: `Successfully wrote to '${file_path}'`,
         tool_call_id: config.toolCall?.id,
         name: "write_file",
@@ -4892,7 +6894,7 @@ function createWriteFileTool(backend, options) {
 }
 function createEditFileTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4911,7 +6913,7 @@ function createEditFileTool(backend, options) {
       if (result.error) {
         return result.error;
       }
-      const message = new import_langchain35.ToolMessage({
+      const message = new import_langchain43.ToolMessage({
         content: `Successfully replaced ${result.occurrences} occurrence(s) in '${file_path}'`,
         tool_call_id: config.toolCall?.id,
         name: "edit_file",
@@ -4938,7 +6940,7 @@ function createEditFileTool(backend, options) {
 }
 function createGlobTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -4966,7 +6968,7 @@ function createGlobTool(backend, options) {
 }
 function createGrepTool(backend, options) {
   const { customDescription } = options;
-  return (0, import_langchain35.tool)(
+  return (0, import_langchain43.tool)(
     async (input, config) => {
       const { runConfig } = config.configurable;
       const stateAndStore = {
@@ -5034,7 +7036,7 @@ function createFilesystemMiddleware(options = {}) {
       customDescription: customToolDescriptions?.grep
     })
   ];
-  return (0, import_langchain35.createMiddleware)({
+  return (0, import_langchain43.createMiddleware)({
     name: "FilesystemMiddleware",
     stateSchema: FilesystemStateSchema,
     tools,
@@ -5065,7 +7067,7 @@ ${systemPrompt}` : systemPrompt;
           if (writeResult.error) {
             return { message: msg, filesUpdate: null };
           }
-          const truncatedMessage = new import_langchain35.ToolMessage({
+          const truncatedMessage = new import_langchain43.ToolMessage({
             content: `Tool result too large (${Math.round(
               msg.content.length / 4
             )} tokens). Content saved to ${evictPath}`,
@@ -5079,7 +7081,7 @@ ${systemPrompt}` : systemPrompt;
         }
         return { message: msg, filesUpdate: null };
       }
-      if (result instanceof import_langchain35.ToolMessage) {
+      if (result instanceof import_langchain43.ToolMessage) {
         const processed = await processToolMessage(result);
         if (processed.filesUpdate) {
           return new import_langgraph4.Command({
@@ -5102,7 +7104,7 @@ ${systemPrompt}` : systemPrompt;
         };
         const processedMessages = [];
         for (const msg of update.messages) {
-          if (msg instanceof import_langchain35.ToolMessage) {
+          if (msg instanceof import_langchain43.ToolMessage) {
             const processed = await processToolMessage(msg);
             processedMessages.push(processed.message);
             if (processed.filesUpdate) {
@@ -5128,6 +7130,31 @@ ${systemPrompt}` : systemPrompt;
   });
 }
 
+// src/middlewares/metricsMiddleware.ts
+var import_langchain44 = require("langchain");
+function createMetricsMiddleware(params) {
+  const { serverKeys, serverDescriptions } = params;
+  if (!serverKeys || serverKeys.length === 0) {
+    return (0, import_langchain44.createMiddleware)({
+      name: "metricsMiddleware",
+      tools: []
+    });
+  }
+  const toolParams = {
+    serverKeys,
+    serverDescriptions
+  };
+  return (0, import_langchain44.createMiddleware)({
+    name: "metricsMiddleware",
+    tools: [
+      createListMetricsDataSourcesTool(toolParams),
+      createQueryMetricsListTool(toolParams),
+      createQueryMetricDefinitionTool(toolParams),
+      createQuerySemanticMetricDataTool(toolParams)
+    ]
+  });
+}
+
 // src/agent_lattice/builders/commonMiddleware.ts
 function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
   const middlewares = [];
@@ -5166,6 +7193,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;
@@ -5209,14 +7244,14 @@ 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);
     const middlewares = createCommonMiddlewares(middlewareConfigs, filesystemBackend);
-    return (0, import_langchain36.createAgent)({
+    return (0, import_langchain45.createAgent)({
       model: params.model,
       tools,
       systemPrompt: params.prompt,
@@ -5229,11 +7264,11 @@ var ReActAgentGraphBuilder = class {
 };
 
 // src/deep_agent_new/agent.ts
-var import_langchain40 = require("langchain");
+var import_langchain49 = require("langchain");
 
 // src/deep_agent_new/middleware/subagents.ts
 var import_v32 = require("zod/v3");
-var import_langchain37 = require("langchain");
+var import_langchain46 = require("langchain");
 var import_langgraph6 = require("@langchain/langgraph");
 var import_messages = require("@langchain/core/messages");
 
@@ -5788,7 +7823,7 @@ function returnCommandWithStateUpdate(result, toolCallId) {
     update: {
       ...stateUpdate,
       messages: [
-        new import_langchain37.ToolMessage({
+        new import_langchain46.ToolMessage({
           content: lastMessage?.content || "Task Failed to complete",
           tool_call_id: toolCallId,
           name: "task"
@@ -5813,10 +7848,10 @@ function getSubagents(options) {
     const generalPurposeMiddleware = [...defaultSubagentMiddleware];
     if (defaultInterruptOn) {
       generalPurposeMiddleware.push(
-        (0, import_langchain37.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
+        (0, import_langchain46.humanInTheLoopMiddleware)({ interruptOn: defaultInterruptOn })
       );
     }
-    const generalPurposeSubagent = (0, import_langchain37.createAgent)({
+    const generalPurposeSubagent = (0, import_langchain46.createAgent)({
       model: defaultModel,
       systemPrompt: DEFAULT_SUBAGENT_PROMPT,
       tools: defaultTools,
@@ -5837,8 +7872,8 @@ function getSubagents(options) {
       const middleware = agentParams.middleware ? [...defaultSubagentMiddleware, ...agentParams.middleware] : [...defaultSubagentMiddleware];
       const interruptOn = agentParams.interruptOn || defaultInterruptOn;
       if (interruptOn)
-        middleware.push((0, import_langchain37.humanInTheLoopMiddleware)({ interruptOn }));
-      agents[agentParams.name] = (0, import_langchain37.createAgent)({
+        middleware.push((0, import_langchain46.humanInTheLoopMiddleware)({ interruptOn }));
+      agents[agentParams.name] = (0, import_langchain46.createAgent)({
         model: agentParams.model ?? defaultModel,
         systemPrompt: agentParams.systemPrompt,
         tools: agentParams.tools ?? defaultTools,
@@ -5867,7 +7902,7 @@ function createTaskTool(options) {
     generalPurposeAgent
   });
   const finalTaskDescription = taskDescription ? taskDescription : getTaskToolDescription(subagentDescriptions);
-  return (0, import_langchain37.tool)(
+  return (0, import_langchain46.tool)(
     async (input, config) => {
       const { description, subagent_type } = input;
       try {
@@ -5897,7 +7932,7 @@ function createTaskTool(options) {
         return new import_langgraph6.Command({
           update: {
             messages: [
-              new import_langchain37.ToolMessage({
+              new import_langchain46.ToolMessage({
                 content: error instanceof Error ? error.message : "Task Failed to complete",
                 tool_call_id: config.toolCall.id,
                 name: "task"
@@ -5941,7 +7976,7 @@ function createSubAgentMiddleware(options) {
     generalPurposeAgent,
     taskDescription
   });
-  return (0, import_langchain37.createMiddleware)({
+  return (0, import_langchain46.createMiddleware)({
     name: "subAgentMiddleware",
     tools: [taskTool],
     wrapModelCall: async (request, handler) => {
@@ -5961,11 +7996,11 @@ ${systemPrompt}` : systemPrompt;
 }
 
 // src/deep_agent_new/middleware/patch_tool_calls.ts
-var import_langchain38 = require("langchain");
+var import_langchain47 = require("langchain");
 var import_messages2 = require("@langchain/core/messages");
 var import_langgraph7 = require("@langchain/langgraph");
 function createPatchToolCallsMiddleware() {
-  return (0, import_langchain38.createMiddleware)({
+  return (0, import_langchain47.createMiddleware)({
     name: "patchToolCallsMiddleware",
     beforeAgent: async (state) => {
       const messages = state.messages;
@@ -5976,15 +8011,15 @@ function createPatchToolCallsMiddleware() {
       for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
         patchedMessages.push(msg);
-        if (import_langchain38.AIMessage.isInstance(msg) && msg.tool_calls != null) {
+        if (import_langchain47.AIMessage.isInstance(msg) && msg.tool_calls != null) {
           for (const toolCall of msg.tool_calls) {
             const correspondingToolMsg = messages.slice(i).find(
-              (m) => import_langchain38.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
+              (m) => import_langchain47.ToolMessage.isInstance(m) && m.tool_call_id === toolCall.id
             );
             if (!correspondingToolMsg) {
               const toolMsg = `Tool call ${toolCall.name} with id ${toolCall.id} was cancelled - another message came in before it could be completed.`;
               patchedMessages.push(
-                new import_langchain38.ToolMessage({
+                new import_langchain47.ToolMessage({
                   content: toolMsg,
                   name: toolCall.name,
                   tool_call_id: toolCall.id
@@ -6119,9 +8154,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;
       }
@@ -6314,8 +8349,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;
@@ -6650,9 +8685,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;
@@ -6714,9 +8749,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;
@@ -6999,9 +9034,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;
       }
@@ -7097,8 +9132,8 @@ var MemoryBackend = class {
 
 // src/deep_agent_new/middleware/todos.ts
 var import_langgraph8 = require("@langchain/langgraph");
-var import_zod36 = require("zod");
-var import_langchain39 = require("langchain");
+var import_zod44 = require("zod");
+var import_langchain48 = require("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.
@@ -7325,20 +9360,20 @@ Writing todos takes time and tokens, use it when it is helpful for managing comp
 ## Important To-Do List Usage Notes to Remember
 - The \`write_todos\` tool should never be called multiple times in parallel.
 - Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.`;
-var TodoStatus = import_zod36.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
-var TodoSchema = import_zod36.z.object({
-  content: import_zod36.z.string().describe("Content of the todo item"),
+var TodoStatus = import_zod44.z.enum(["pending", "in_progress", "completed"]).describe("Status of the todo");
+var TodoSchema = import_zod44.z.object({
+  content: import_zod44.z.string().describe("Content of the todo item"),
   status: TodoStatus
 });
-var stateSchema = import_zod36.z.object({ todos: import_zod36.z.array(TodoSchema).default([]) });
+var stateSchema = import_zod44.z.object({ todos: import_zod44.z.array(TodoSchema).default([]) });
 function todoListMiddleware(options) {
-  const writeTodos = (0, import_langchain39.tool)(
+  const writeTodos = (0, import_langchain48.tool)(
     ({ todos }, config) => {
       return new import_langgraph8.Command({
         update: {
           todos,
           messages: [
-            new import_langchain39.ToolMessage({
+            new import_langchain48.ToolMessage({
               content: genUIMarkdown("todo_list", todos),
               tool_call_id: config.toolCall?.id
             })
@@ -7349,12 +9384,12 @@ function todoListMiddleware(options) {
     {
       name: "write_todos",
       description: options?.toolDescription ?? WRITE_TODOS_DESCRIPTION,
-      schema: import_zod36.z.object({
-        todos: import_zod36.z.array(TodoSchema).describe("List of todo items to update")
+      schema: import_zod44.z.object({
+        todos: import_zod44.z.array(TodoSchema).describe("List of todo items to update")
       })
     }
   );
-  return (0, import_langchain39.createMiddleware)({
+  return (0, import_langchain48.createMiddleware)({
     name: "todoListMiddleware",
     stateSchema,
     tools: [writeTodos],
@@ -7406,13 +9441,13 @@ ${BASE_PROMPT}` : BASE_PROMPT;
           backend: filesystemBackend
         }),
         // Subagent middleware: Automatic conversation summarization when token limits are approached
-        (0, import_langchain40.summarizationMiddleware)({
+        (0, import_langchain49.summarizationMiddleware)({
           model,
           trigger: { tokens: 17e4 },
           keep: { messages: 6 }
         }),
         // Subagent middleware: Anthropic prompt caching for improved performance
-        (0, import_langchain40.anthropicPromptCachingMiddleware)({
+        (0, import_langchain49.anthropicPromptCachingMiddleware)({
           unsupportedModelBehavior: "ignore"
         }),
         // Subagent middleware: Patches tool calls for compatibility
@@ -7423,23 +9458,23 @@ ${BASE_PROMPT}` : BASE_PROMPT;
       generalPurposeAgent: false
     }),
     // Automatically summarizes conversation history when token limits are approached
-    (0, import_langchain40.summarizationMiddleware)({
+    (0, import_langchain49.summarizationMiddleware)({
       model,
       trigger: { tokens: 17e4 },
       keep: { messages: 6 }
     }),
     // Enables Anthropic prompt caching for improved performance and reduced costs
-    (0, import_langchain40.anthropicPromptCachingMiddleware)({
+    (0, import_langchain49.anthropicPromptCachingMiddleware)({
       unsupportedModelBehavior: "ignore"
     }),
     // Patches tool calls to ensure compatibility across different model providers
     createPatchToolCallsMiddleware()
   ];
   if (interruptOn) {
-    middleware.push((0, import_langchain40.humanInTheLoopMiddleware)({ interruptOn }));
+    middleware.push((0, import_langchain49.humanInTheLoopMiddleware)({ interruptOn }));
   }
   middleware.push(...customMiddleware);
-  return (0, import_langchain40.createAgent)({
+  return (0, import_langchain49.createAgent)({
     model,
     systemPrompt: finalSystemPrompt,
     tools,
@@ -7497,7 +9532,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 {
@@ -7536,7 +9571,7 @@ var DeepAgentGraphBuilder = class {
 
 // src/agent_team/agent_team.ts
 var import_v35 = require("zod/v3");
-var import_langchain43 = require("langchain");
+var import_langchain52 = require("langchain");
 
 // src/agent_team/types.ts
 var TaskStatus = /* @__PURE__ */ ((TaskStatus3) => {
@@ -7972,13 +10007,13 @@ var InMemoryMailboxStore = class {
 
 // src/agent_team/middleware/team.ts
 var import_v34 = require("zod/v3");
-var import_langchain42 = require("langchain");
+var import_langchain51 = require("langchain");
 var import_langgraph10 = require("@langchain/langgraph");
 var import_uuid = require("uuid");
 
 // src/agent_team/middleware/teammate_tools.ts
 var import_v33 = require("zod/v3");
-var import_langchain41 = require("langchain");
+var import_langchain50 = require("langchain");
 var import_langgraph9 = require("@langchain/langgraph");
 
 // src/agent_team/middleware/formatMessages.ts
@@ -8003,7 +10038,7 @@ ${meta}${body}`;
 // src/agent_team/middleware/teammate_tools.ts
 function createTeammateTools(options) {
   const { teamId, agentId, taskListStore, mailboxStore } = options;
-  const claimTaskTool = (0, import_langchain41.tool)(
+  const claimTaskTool = (0, import_langchain50.tool)(
     async (input) => {
       const task = await taskListStore.claimTaskById(
         teamId,
@@ -8033,7 +10068,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const completeTaskTool = (0, import_langchain41.tool)(
+  const completeTaskTool = (0, import_langchain50.tool)(
     async (input) => {
       const task = await taskListStore.completeTask(
         teamId,
@@ -8060,7 +10095,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const failTaskTool = (0, import_langchain41.tool)(
+  const failTaskTool = (0, import_langchain50.tool)(
     async (input) => {
       const task = await taskListStore.failTask(
         teamId,
@@ -8087,7 +10122,7 @@ function createTeammateTools(options) {
       })
     }
   );
-  const sendMessageTool = (0, import_langchain41.tool)(
+  const sendMessageTool = (0, import_langchain50.tool)(
     async (input) => {
       await mailboxStore.sendMessage(
         teamId,
@@ -8125,7 +10160,7 @@ function createTeammateTools(options) {
       read: msg.read
     }));
   };
-  const readMessagesTool = (0, import_langchain41.tool)(
+  const readMessagesTool = (0, import_langchain50.tool)(
     async (input, config) => {
       const formatAndMarkAsRead = async (msgs2) => {
         for (const msg of msgs2) {
@@ -8137,7 +10172,7 @@ function createTeammateTools(options) {
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const relevantMsgs2 = await getRelevantMessagesForState();
-        const toolMessage2 = new import_langchain41.ToolMessage({
+        const toolMessage2 = new import_langchain50.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -8162,7 +10197,7 @@ function createTeammateTools(options) {
       });
       const relevantMsgs = await getRelevantMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain41.ToolMessage({
+        const toolMessage2 = new import_langchain50.ToolMessage({
           content: "No unread messages.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -8172,7 +10207,7 @@ function createTeammateTools(options) {
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain41.ToolMessage({
+      const toolMessage = new import_langchain50.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -8187,7 +10222,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const checkTasksTool = (0, import_langchain41.tool)(
+  const checkTasksTool = (0, import_langchain50.tool)(
     async () => {
       const tasks = await taskListStore.getAllTasks(teamId);
       return formatTaskSummary(tasks);
@@ -8198,7 +10233,7 @@ function createTeammateTools(options) {
       schema: import_v33.z.object({})
     }
   );
-  const broadcastMessageTool = (0, import_langchain41.tool)(
+  const broadcastMessageTool = (0, import_langchain50.tool)(
     async (input) => {
       const allAgents = await mailboxStore.getRegisteredAgents(teamId);
       const recipients = allAgents.filter((a) => a !== agentId);
@@ -8383,7 +10418,7 @@ You have access to these tools:
 - \`read_messages\`: Read messages from team_lead or teammates
 - \`check_tasks\`: Get current status of all tasks in the team`;
   const assistantId = getTeammateAssistantId(ctx.teamId, spec.name);
-  agent = (0, import_langchain42.createAgent)({
+  agent = (0, import_langchain51.createAgent)({
     model: spec.model ?? ctx.defaultModel,
     systemPrompt: teammatePrompt,
     tools: allTools,
@@ -8441,12 +10476,12 @@ async function spawnTeammate(options) {
 function createTeamMiddleware(options) {
   const { teamConfig, taskListStore, mailboxStore } = options;
   const defaultModel = teamConfig.model ?? "claude-sonnet-4-5-20250929";
-  const createTeamTool = (0, import_langchain42.tool)(
+  const createTeamTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const state = (0, import_langgraph10.getCurrentTaskInput)();
       if (state?.team?.teamId) {
         const existingId = state.team.teamId;
-        const msg = new import_langchain42.ToolMessage({
+        const msg = new import_langchain51.ToolMessage({
           content: `A team is already active (id: ${existingId}). Use this team_id for \`check_tasks\`, \`read_messages\`, \`add_tasks\`, \`send_message\`, \`assign_task\`, \`set_task_status\`, and \`set_task_dependencies\`. Do not call \`create_team\` again unless you need a fresh team for a new objective.`,
           tool_call_id: config.toolCall?.id,
           name: "create_team"
@@ -8531,7 +10566,7 @@ Teammates are now working in the background. Keep calling \`check_tasks\` and \`
 \`\`\`json
 ${teamJson}
 \`\`\``;
-      const toolMessage = new import_langchain42.ToolMessage({
+      const toolMessage = new import_langchain51.ToolMessage({
         content: summary,
         tool_call_id: config.toolCall?.id,
         name: "create_team"
@@ -8616,7 +10651,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 = (0, import_langchain42.tool)(
+  const addTasksTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const created = await taskListStore.addTasks(
@@ -8630,7 +10665,7 @@ After calling create_team, you MUST:
         }))
       );
       const summary = created.map((t) => `- ${t.id}: "${t.title}"`).join("\n");
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Added ${created.length} task(s) to team ${teamId}:
 ${summary}
 Sleeping teammates will wake up and claim these.`,
@@ -8681,20 +10716,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const assignTaskTool = (0, import_langchain42.tool)(
+  const assignTaskTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         assignee: input.assignee
       });
       if (!task) {
-        return new import_langchain42.ToolMessage({
+        return new import_langchain51.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "assign_task"
         });
       }
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Task "${task.title}" (${task.id}) assigned to ${input.assignee}.`,
         tool_call_id: config.toolCall?.id,
         name: "assign_task"
@@ -8709,20 +10744,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskStatusTool = (0, import_langchain42.tool)(
+  const setTaskStatusTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         status: input.status
       });
       if (!task) {
-        return new import_langchain42.ToolMessage({
+        return new import_langchain51.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_status"
         });
       }
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Task "${task.title}" (${task.id}) status set to ${input.status}.`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_status"
@@ -8737,20 +10772,20 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const setTaskDependenciesTool = (0, import_langchain42.tool)(
+  const setTaskDependenciesTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const task = await taskListStore.updateTask(teamId, input.task_id, {
         dependencies: input.dependencies
       });
       if (!task) {
-        return new import_langchain42.ToolMessage({
+        return new import_langchain51.ToolMessage({
           content: `Task ${input.task_id} not found in team ${teamId}.`,
           tool_call_id: config.toolCall?.id,
           name: "set_task_dependencies"
         });
       }
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Task "${task.title}" (${task.id}) dependencies set to [${input.dependencies.join(", ")}].`,
         tool_call_id: config.toolCall?.id,
         name: "set_task_dependencies"
@@ -8765,7 +10800,7 @@ IMPORTANT: Assigning to a specific teammate
       })
     }
   );
-  const checkTasksTool = (0, import_langchain42.tool)(
+  const checkTasksTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const tasks = await taskListStore.getAllTasks(teamId);
@@ -8774,7 +10809,7 @@ IMPORTANT: Assigning to a specific teammate
         update: {
           tasks: tasksSnapshot,
           messages: [
-            new import_langchain42.ToolMessage({
+            new import_langchain51.ToolMessage({
               content: formatTaskSummary(tasks),
               tool_call_id: config.toolCall?.id,
               name: "check_tasks"
@@ -8810,7 +10845,7 @@ Task Status Values:
       })
     }
   );
-  const sendMessageTool = (0, import_langchain42.tool)(
+  const sendMessageTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.sendMessage(
@@ -8820,7 +10855,7 @@ Task Status Values:
         input.content,
         "direct_message" /* DIRECT_MESSAGE */
       );
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Message sent to ${input.to}.`,
         tool_call_id: config.toolCall?.id,
         name: "send_message"
@@ -8835,7 +10870,7 @@ Task Status Values:
       })
     }
   );
-  const readMessagesTool = (0, import_langchain42.tool)(
+  const readMessagesTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       const formatAndMarkAsRead = async (msgs2) => {
@@ -8863,7 +10898,7 @@ Task Status Values:
       if (msgs.length > 0) {
         const formatted2 = await formatAndMarkAsRead(msgs);
         const allTeamMessages2 = await getAllTeamMessagesForState();
-        const toolMessage2 = new import_langchain42.ToolMessage({
+        const toolMessage2 = new import_langchain51.ToolMessage({
           content: formatted2,
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -8895,7 +10930,7 @@ Task Status Values:
       );
       const allTeamMessages = await getAllTeamMessagesForState();
       if (msgs.length === 0) {
-        const toolMessage2 = new import_langchain42.ToolMessage({
+        const toolMessage2 = new import_langchain51.ToolMessage({
           content: "No unread messages from teammates.",
           tool_call_id: config.toolCall?.id,
           name: "read_messages"
@@ -8905,7 +10940,7 @@ Task Status Values:
         });
       }
       const formatted = await formatAndMarkAsRead(msgs);
-      const toolMessage = new import_langchain42.ToolMessage({
+      const toolMessage = new import_langchain51.ToolMessage({
         content: formatted,
         tool_call_id: config.toolCall?.id,
         name: "read_messages"
@@ -8922,7 +10957,7 @@ Task Status Values:
       })
     }
   );
-  const disbandTeamTool = (0, import_langchain42.tool)(
+  const disbandTeamTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -8932,7 +10967,7 @@ Task Status Values:
         "shutdown_request" /* SHUTDOWN_REQUEST */
       );
       await new Promise((r) => setTimeout(r, 2e3));
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Team ${teamId} has been disbanded. All teammates notified and resources cleaned up.`,
         tool_call_id: config.toolCall?.id,
         name: "disband_team"
@@ -8943,7 +10978,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 = (0, import_langchain42.tool)(
+  const broadcastMessageTool = (0, import_langchain51.tool)(
     async (input, config) => {
       const teamId = resolveTeamId();
       await mailboxStore.broadcastMessage(
@@ -8952,7 +10987,7 @@ Task Status Values:
         input.content,
         "broadcast" /* BROADCAST */
       );
-      return new import_langchain42.ToolMessage({
+      return new import_langchain51.ToolMessage({
         content: `Broadcast message sent to all teammates.`,
         tool_call_id: config.toolCall?.id,
         name: "broadcast_message"
@@ -8966,7 +11001,7 @@ Task Status Values:
       })
     }
   );
-  return (0, import_langchain42.createMiddleware)({
+  return (0, import_langchain51.createMiddleware)({
     name: "teamMiddleware",
     tools: [
       createTeamTool,
@@ -9074,7 +11109,7 @@ function createAgentTeam(config) {
   ];
   const systemPrompt = config.systemPrompt + "\n\n" + TEAM_LEAD_BASE_PROMPT;
   const stateSchema2 = createReactAgentSchema(TEAM_STATE_SCHEMA);
-  return (0, import_langchain43.createAgent)({
+  return (0, import_langchain52.createAgent)({
     model: config.model ?? "claude-sonnet-4-5-20250929",
     systemPrompt,
     tools: [],
@@ -9104,7 +11139,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 {
@@ -11764,10 +13799,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`);
@@ -11852,6 +13887,7 @@ function clearEncryptionKeyCache() {
   ChunkBufferLatticeManager,
   CompositeBackend,
   ConsoleLoggerClient,
+  CustomMetricsClient,
   DefaultScheduleClient,
   EMPTY_CONTENT_WARNING,
   EmbeddingsLatticeManager,
@@ -11863,7 +13899,10 @@ function clearEncryptionKeyCache() {
   InMemoryDatabaseConfigStore,
   InMemoryMailboxStore,
   InMemoryTaskListStore,
+  InMemoryTenantStore,
   InMemoryThreadStore,
+  InMemoryUserStore,
+  InMemoryUserTenantLinkStore,
   LINE_NUMBER_WIDTH,
   LoggerLatticeManager,
   MAX_LINE_LENGTH,
@@ -11874,14 +13913,17 @@ function clearEncryptionKeyCache() {
   MemoryScheduleStorage,
   MemoryType,
   MessageType,
+  MetricsServerManager,
   ModelLatticeManager,
   PinoLoggerClient,
   PostgresDatabase,
+  PrometheusClient,
   Protocols,
   QueueLatticeManager,
   SandboxFilesystem,
   SandboxLatticeManager,
   ScheduleLatticeManager,
+  SemanticMetricsClient,
   SkillLatticeManager,
   SqlDatabaseManager,
   StateBackend,
@@ -11901,9 +13943,16 @@ function clearEncryptionKeyCache() {
   createAgentTeam,
   createFileData,
   createInfoSqlTool,
+  createListMetricsDataSourcesTool,
+  createListMetricsServersTool,
   createListTablesSqlTool,
   createQueryCheckerSqlTool,
+  createQueryMetricDefinitionTool,
+  createQueryMetricsListTool,
+  createQuerySemanticMetricDataTool,
   createQuerySqlTool,
+  createQueryTableDefinitionTool,
+  createQueryTablesListTool,
   createTeamMiddleware,
   createTeammateTools,
   decrypt,
@@ -11949,6 +13998,7 @@ function clearEncryptionKeyCache() {
   isValidSkillName,
   loggerLatticeManager,
   mcpManager,
+  metricsServerManager,
   modelLatticeManager,
   normalizeSandboxName,
   parseCronExpression,