@axiom-lattice/core 2.1.32 → 2.1.33

package/dist/index.mjs

@@ -12,37 +12,148 @@ var _BaseLatticeManager = class _BaseLatticeManager {
     throw new Error("\u5FC5\u987B\u7531\u5B50\u7C7B\u5B9E\u73B0");
   }
   /**
-   * 构造完整的键名，包含类型前缀
+   * 构造完整的键名，包含类型前缀和租户ID
+   * @param tenantId 租户ID，全局共享使用 "default"
    * @param key 原始键名
    */
-  getFullKey(key) {
-    return `${this.getLatticeType()}.${key}`;
+  getFullKey(tenantId, key) {
+    return `${this.getLatticeType()}:${tenantId}:${key}`;
   }
+  // ========== 带租户的新API ==========
   /**
-   * 注册项目
+   * 带租户的注册项目
+   * @param tenantId 租户ID
    * @param key 项目键名（不含前缀）
    * @param item 项目实例
    */
-  register(key, item) {
-    const fullKey = this.getFullKey(key);
+  registerWithTenant(tenantId, key, item) {
+    const fullKey = this.getFullKey(tenantId, key);
     if (_BaseLatticeManager.registry.has(fullKey)) {
       throw new Error(`\u9879\u76EE "${fullKey}" \u5DF2\u7ECF\u5B58\u5728\uFF0C\u65E0\u6CD5\u91CD\u590D\u6CE8\u518C`);
     }
     _BaseLatticeManager.registry.set(fullKey, item);
   }
   /**
-   * 获取指定项目
+   * 带租户的获取指定项目（同步）
+   * @param tenantId 租户ID
    * @param key 项目键名（不含前缀）
    */
-  get(key) {
-    const fullKey = this.getFullKey(key);
+  getWithTenant(tenantId, key) {
+    const fullKey = this.getFullKey(tenantId, key);
     return _BaseLatticeManager.registry.get(fullKey);
   }
   /**
-   * 获取所有当前类型的项目
+   * 带租户的获取指定项目（异步，支持从store回退加载）
+   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
+   * @param tenantId 租户ID
+   * @param key 项目键名（不含前缀）
+   * @returns 项目实例，如果未找到则返回undefined
+   */
+  async getOrLoadWithTenant(tenantId, key) {
+    const item = this.getWithTenant(tenantId, key);
+    if (item !== void 0) {
+      return item;
+    }
+    if (this.loadItemFromStore) {
+      const loadedItem = await this.loadItemFromStore(tenantId, key);
+      if (loadedItem !== void 0) {
+        this.registerWithTenant(tenantId, key, loadedItem);
+        return loadedItem;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 带租户的检查项目是否存在（同步）
+   * @param tenantId 租户ID
+   * @param key 项目键名（不含前缀）
+   */
+  hasWithTenant(tenantId, key) {
+    const fullKey = this.getFullKey(tenantId, key);
+    return _BaseLatticeManager.registry.has(fullKey);
+  }
+  /**
+   * 带租户的检查项目是否存在（异步，支持从store回退加载）
+   * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
+   * @param tenantId 租户ID
+   * @param key 项目键名（不含前缀）
+   * @returns 如果存在或能从store加载则返回true
+   */
+  async hasOrLoadWithTenant(tenantId, key) {
+    if (this.hasWithTenant(tenantId, key)) {
+      return true;
+    }
+    if (this.loadItemFromStore) {
+      const loadedItem = await this.loadItemFromStore(tenantId, key);
+      if (loadedItem !== void 0) {
+        this.registerWithTenant(tenantId, key, loadedItem);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 带租户的移除项目
+   * @param tenantId 租户ID
+   * @param key 项目键名（不含前缀）
+   */
+  removeWithTenant(tenantId, key) {
+    const fullKey = this.getFullKey(tenantId, key);
+    return _BaseLatticeManager.registry.delete(fullKey);
+  }
+  /**
+   * 获取指定租户的所有项目
+   * @param tenantId 租户ID
+   */
+  getAllByTenant(tenantId) {
+    const prefix = `${this.getLatticeType()}:${tenantId}:`;
+    const result = [];
+    for (const [key, value] of _BaseLatticeManager.registry.entries()) {
+      if (key.startsWith(prefix)) {
+        result.push(value);
+      }
+    }
+    return result;
+  }
+  /**
+   * 清空指定租户的所有项目
+   * @param tenantId 租户ID
+   */
+  clearByTenant(tenantId) {
+    const prefix = `${this.getLatticeType()}:${tenantId}:`;
+    const keysToDelete = [];
+    for (const key of _BaseLatticeManager.registry.keys()) {
+      if (key.startsWith(prefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      _BaseLatticeManager.registry.delete(key);
+    }
+  }
+  // ========== 向后兼容的旧API（使用 default 租户） ==========
+  /**
+   * 注册项目（向后兼容，使用 "default" 租户）
+   * @deprecated Use registerWithTenant(tenantId, key, item) instead
+   * @param key 项目键名（不含前缀）
+   * @param item 项目实例
+   */
+  register(key, item) {
+    this.registerWithTenant("default", key, item);
+  }
+  /**
+   * 获取指定项目（向后兼容，使用 "default" 租户）
+   * @deprecated Use getWithTenant(tenantId, key) instead
+   * @param key 项目键名（不含前缀）
+   */
+  get(key) {
+    return this.getWithTenant("default", key);
+  }
+  /**
+   * 获取所有当前类型的项目（向后兼容，包含所有租户）
    */
   getAll() {
-    const prefix = `${this.getLatticeType()}.`;
+    const prefix = `${this.getLatticeType()}:`;
     const result = [];
     for (const [key, value] of _BaseLatticeManager.registry.entries()) {
       if (key.startsWith(prefix)) {
@@ -52,26 +163,26 @@ var _BaseLatticeManager = class _BaseLatticeManager {
     return result;
   }
   /**
-   * 检查项目是否存在
+   * 检查项目是否存在（向后兼容，使用 "default" 租户）
+   * @deprecated Use hasWithTenant(tenantId, key) instead
    * @param key 项目键名（不含前缀）
    */
   has(key) {
-    const fullKey = this.getFullKey(key);
-    return _BaseLatticeManager.registry.has(fullKey);
+    return this.hasWithTenant("default", key);
   }
   /**
-   * 移除项目
+   * 移除项目（向后兼容，使用 "default" 租户）
+   * @deprecated Use removeWithTenant(tenantId, key) instead
    * @param key 项目键名（不含前缀）
    */
   remove(key) {
-    const fullKey = this.getFullKey(key);
-    return _BaseLatticeManager.registry.delete(fullKey);
+    return this.removeWithTenant("default", key);
   }
   /**
-   * 清空当前类型的所有项目
+   * 清空当前类型的所有项目（向后兼容，包含所有租户）
    */
   clear() {
-    const prefix = `${this.getLatticeType()}.`;
+    const prefix = `${this.getLatticeType()}:`;
     const keysToDelete = [];
     for (const key of _BaseLatticeManager.registry.keys()) {
       if (key.startsWith(prefix)) {
@@ -83,10 +194,10 @@ var _BaseLatticeManager = class _BaseLatticeManager {
     }
   }
   /**
-   * 获取当前类型的项目数量
+   * 获取当前类型的项目数量（向后兼容，包含所有租户）
    */
   count() {
-    const prefix = `${this.getLatticeType()}.`;
+    const prefix = `${this.getLatticeType()}:`;
     let count = 0;
     for (const key of _BaseLatticeManager.registry.keys()) {
       if (key.startsWith(prefix)) {
@@ -96,10 +207,26 @@ var _BaseLatticeManager = class _BaseLatticeManager {
     return count;
   }
   /**
-   * 获取当前类型的项目键名列表（不含前缀）
+   * 获取当前类型的项目键名列表（向后兼容，包含所有租户）
+   * 返回格式: {tenantId}:{key}
    */
   keys() {
-    const prefix = `${this.getLatticeType()}.`;
+    const prefix = `${this.getLatticeType()}:`;
+    const prefixLength = prefix.length;
+    const result = [];
+    for (const key of _BaseLatticeManager.registry.keys()) {
+      if (key.startsWith(prefix)) {
+        result.push(key.substring(prefixLength));
+      }
+    }
+    return result;
+  }
+  /**
+   * 获取当前类型的项目键名列表（仅指定租户，不含租户前缀）
+   * @param tenantId 租户ID
+   */
+  keysByTenant(tenantId) {
+    const prefix = `${this.getLatticeType()}:${tenantId}:`;
     const prefixLength = prefix.length;
     const result = [];
     for (const key of _BaseLatticeManager.registry.keys()) {
@@ -762,7 +889,7 @@ var PostgresDatabase = class {
 var SqlDatabaseManager = class _SqlDatabaseManager {
   constructor() {
     this.databases = /* @__PURE__ */ new Map();
-    this.defaultDatabaseKey = null;
+    this.defaultDatabaseKeys = /* @__PURE__ */ new Map();
   }
   /**
    * Get the singleton instance
@@ -774,11 +901,23 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
     return _SqlDatabaseManager.instance;
   }
   /**
-   * Register a database connection
-   * @param key - Unique identifier for the database
+   * Get or create tenant database map
+   */
+  getTenantDatabases(tenantId) {
+    let tenantDbs = this.databases.get(tenantId);
+    if (!tenantDbs) {
+      tenantDbs = /* @__PURE__ */ new Map();
+      this.databases.set(tenantId, tenantDbs);
+    }
+    return tenantDbs;
+  }
+  /**
+   * Register a database connection for a tenant
+   * @param tenantId - Tenant identifier
+   * @param key - Unique identifier for the database within the tenant
    * @param config - Database configuration
    */
-  registerDatabase(key, config) {
+  registerDatabase(tenantId, key, config) {
     let database;
     switch (config.type) {
       case "postgres":
@@ -791,74 +930,115 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
       default:
         throw new Error(`Unsupported database type: ${config.type}`);
     }
-    this.databases.set(key, database);
-    if (this.defaultDatabaseKey === null) {
-      this.defaultDatabaseKey = key;
+    const tenantDbs = this.getTenantDatabases(tenantId);
+    tenantDbs.set(key, database);
+    if (!this.defaultDatabaseKeys.has(tenantId)) {
+      this.defaultDatabaseKeys.set(tenantId, key);
     }
   }
   /**
-   * Set the default database
+   * Set the default database for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Database key to set as default
    */
-  setDefaultDatabase(key) {
-    if (!this.databases.has(key)) {
-      throw new Error(`Database '${key}' not found`);
+  setDefaultDatabase(tenantId, key) {
+    const tenantDbs = this.databases.get(tenantId);
+    if (!tenantDbs || !tenantDbs.has(key)) {
+      throw new Error(`Database '${key}' not found for tenant '${tenantId}'`);
     }
-    this.defaultDatabaseKey = key;
+    this.defaultDatabaseKeys.set(tenantId, key);
   }
   /**
-   * Get a database by key
+   * Get a database by key for a specific tenant
+   * @param tenantId - Tenant identifier (required)
    * @param key - Database key (optional, uses default if not provided)
+   * @returns ISqlDatabase instance
+   * @throws Error if tenant or database not found
    */
-  getDatabase(key) {
-    const dbKey = key || this.defaultDatabaseKey;
+  getDatabase(tenantId, key) {
+    const tenantDbs = this.databases.get(tenantId);
+    if (!tenantDbs) {
+      throw new Error(`No databases registered for tenant '${tenantId}'`);
+    }
+    const dbKey = key || this.defaultDatabaseKeys.get(tenantId);
     if (!dbKey) {
-      throw new Error("No database registered");
+      throw new Error(`No default database set for tenant '${tenantId}'`);
     }
-    const database = this.databases.get(dbKey);
+    const database = tenantDbs.get(dbKey);
     if (!database) {
-      throw new Error(`Database '${dbKey}' not found`);
+      throw new Error(`Database '${dbKey}' not found for tenant '${tenantId}'`);
     }
     return database;
   }
   /**
-   * Check if a database is registered
+   * Check if a database is registered for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Database key
+   * @returns true if database exists for the tenant
    */
-  hasDatabase(key) {
-    return this.databases.has(key);
+  hasDatabase(tenantId, key) {
+    const tenantDbs = this.databases.get(tenantId);
+    return tenantDbs ? tenantDbs.has(key) : false;
   }
   /**
-   * Get all registered database keys
+   * Get all registered database keys for a tenant
+   * @param tenantId - Tenant identifier
+   * @returns Array of database keys for the tenant
    */
-  getDatabaseKeys() {
-    return Array.from(this.databases.keys());
+  getDatabaseKeys(tenantId) {
+    const tenantDbs = this.databases.get(tenantId);
+    return tenantDbs ? Array.from(tenantDbs.keys()) : [];
   }
   /**
-   * Remove a database connection
+   * Remove a database connection for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Database key
    */
-  async removeDatabase(key) {
-    const database = this.databases.get(key);
+  async removeDatabase(tenantId, key) {
+    const tenantDbs = this.databases.get(tenantId);
+    if (!tenantDbs) return;
+    const database = tenantDbs.get(key);
     if (database) {
       await database.disconnect();
-      this.databases.delete(key);
-      if (this.defaultDatabaseKey === key) {
-        this.defaultDatabaseKey = this.databases.size > 0 ? this.databases.keys().next().value || null : null;
+      tenantDbs.delete(key);
+      if (this.defaultDatabaseKeys.get(tenantId) === key) {
+        const remainingKeys = Array.from(tenantDbs.keys());
+        if (remainingKeys.length > 0) {
+          this.defaultDatabaseKeys.set(tenantId, remainingKeys[0]);
+        } else {
+          this.defaultDatabaseKeys.delete(tenantId);
+          this.databases.delete(tenantId);
+        }
       }
     }
   }
   /**
-   * Disconnect all databases
+   * Disconnect all databases for a tenant
+   * @param tenantId - Tenant identifier (optional, disconnects all if not provided)
    */
-  async disconnectAll() {
-    for (const database of this.databases.values()) {
-      await database.disconnect();
+  async disconnectAll(tenantId) {
+    if (tenantId) {
+      const tenantDbs = this.databases.get(tenantId);
+      if (tenantDbs) {
+        for (const database of tenantDbs.values()) {
+          await database.disconnect();
+        }
+        this.databases.delete(tenantId);
+        this.defaultDatabaseKeys.delete(tenantId);
+      }
+    } else {
+      for (const [tid, tenantDbs] of this.databases) {
+        for (const database of tenantDbs.values()) {
+          await database.disconnect();
+        }
+      }
+      this.databases.clear();
+      this.defaultDatabaseKeys.clear();
     }
   }
   /**
    * Load database configurations from a DatabaseConfigStore
-   * and register them with this manager
+   * and register them with this manager for a specific tenant
    * 
    * @param store - The database configuration store
    * @param tenantId - Tenant identifier
@@ -866,7 +1046,7 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
   async loadConfigsFromStore(store, tenantId) {
     const configs = await store.getAllConfigs(tenantId);
     for (const entry of configs) {
-      this.registerDatabase(entry.key, entry.config);
+      this.registerDatabase(tenantId, entry.key, entry.config);
     }
   }
   /**
@@ -878,7 +1058,21 @@ var SqlDatabaseManager = class _SqlDatabaseManager {
   async loadAllConfigsFromStore(store) {
     const configs = await store.getAllConfigsWithoutTenant();
     for (const entry of configs) {
-      this.registerDatabase(entry.key, entry.config);
+      const tenantId = entry.tenantId || "default";
+      this.registerDatabase(tenantId, entry.key, entry.config);
+    }
+  }
+  /**
+   * Clear all databases for a tenant (useful for testing)
+   * @param tenantId - Tenant identifier (optional, clears all if not provided)
+   */
+  clear(tenantId) {
+    if (tenantId) {
+      this.databases.delete(tenantId);
+      this.defaultDatabaseKeys.delete(tenantId);
+    } else {
+      this.databases.clear();
+      this.defaultDatabaseKeys.clear();
     }
   }
 };
@@ -887,8 +1081,16 @@ var sqlDatabaseManager = SqlDatabaseManager.getInstance();
 // src/tool_lattice/sql/list_tables_sql.ts
 import z3 from "zod";
 import { tool as tool2 } from "langchain";
+
+// src/tool_lattice/sql/utils.ts
+function getTenantIdFromConfig(exeConfig, getTenantId) {
+  const runConfig = exeConfig?.configurable?.runConfig || {};
+  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+}
+
+// src/tool_lattice/sql/list_tables_sql.ts
 var LIST_TABLES_SQL_DESCRIPTION = `List all tables in the connected SQL database. Returns a comma-separated list of table names. Use this tool first to understand what tables are available before querying the database.`;
-var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+var createListTablesSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -896,15 +1098,16 @@ ${databaseKeys.map(
     (key) => `- ${key}${databaseDescriptions?.[key] ? `: ${databaseDescriptions[key]}` : ""}`
   ).join("\n")}` : "";
   return tool2(
-    async ({ databaseKey }, exe_config) => {
+    async ({ databaseKey }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
         if (!databaseKeys.includes(databaseKey)) {
           return `Error: databaseKey "${databaseKey}" is not in the allowed list: [${databaseKeys.join(", ")}]`;
         }
-        const database = sqlDatabaseManager.getDatabase(databaseKey);
+        const database = sqlDatabaseManager.getDatabase(databaseKey, tenantId);
         const tables = await database.listTables();
         if (tables.length === 0) {
           return "No tables found in the database.";
@@ -931,7 +1134,7 @@ ${databaseKeys.map(
 import z4 from "zod";
 import { tool as tool3 } from "langchain";
 var INFO_SQL_DESCRIPTION = `Get detailed schema information for specified tables, including column names, types, constraints (primary keys, foreign keys), and sample rows. Input should be a comma-separated list of table names.`;
-var createInfoSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+var createInfoSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -942,15 +1145,16 @@ ${databaseKeys.map(
     async ({
       tables,
       databaseKey
-    }, exe_config) => {
+    }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
         if (!databaseKeys.includes(databaseKey)) {
           return `Error: databaseKey "${databaseKey}" is not in the allowed list: [${databaseKeys.join(", ")}]`;
         }
-        const database = sqlDatabaseManager.getDatabase(databaseKey);
+        const database = sqlDatabaseManager.getDatabase(databaseKey, tenantId);
         const tableNames = tables.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
         if (tableNames.length === 0) {
           return "Error: No table names provided. Please provide a comma-separated list of table names.";
@@ -1062,7 +1266,7 @@ function checkDangerousOperations(query) {
   }
   return warnings;
 }
-var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions }) => {
+var createQueryCheckerSqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1073,8 +1277,9 @@ ${databaseKeys.map(
     async ({
       query,
       databaseKey
-    }, exe_config) => {
+    }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
         const trimmedQuery = query.trim();
         if (!trimmedQuery) {
           return "Error: Empty query provided. Please provide a SQL query to check.";
@@ -1106,7 +1311,7 @@ ${trimmedQuery}
         }
         if (databaseKey && databaseKeys.includes(databaseKey)) {
           try {
-            const database = sqlDatabaseManager.getDatabase(databaseKey);
+            const database = sqlDatabaseManager.getDatabase(databaseKey, tenantId);
             const dbType = database.getDatabaseType();
             if (dbType === "postgres") {
               try {
@@ -1183,7 +1388,7 @@ function formatQueryResult(rows, fields) {
 Total rows: ${rows.length}`);
   return lines.join("\n");
 }
-var createQuerySqlTool = ({ databaseKeys, databaseDescriptions }) => {
+var createQuerySqlTool = ({ databaseKeys, databaseDescriptions, getTenantId }) => {
   const availableDbsText = databaseKeys.length > 0 ? `
 
 Available databases:
@@ -1194,8 +1399,9 @@ ${databaseKeys.map(
     async ({
       query,
       databaseKey
-    }, exe_config) => {
+    }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig(_exeConfig, getTenantId);
         if (!databaseKey) {
           return "Error: databaseKey parameter is required. Available databases: " + databaseKeys.join(", ");
         }
@@ -1206,7 +1412,7 @@ ${databaseKeys.map(
         if (!trimmedQuery) {
           return "Error: Empty query provided. Please provide a valid SQL query.";
         }
-        const database = sqlDatabaseManager.getDatabase(databaseKey);
+        const database = sqlDatabaseManager.getDatabase(databaseKey, tenantId);
         const result = await database.executeQuery(trimmedQuery);
         return formatQueryResult(result.rows, result.fields);
       } catch (error) {
@@ -1738,7 +1944,7 @@ var MetricsServerManager = class _MetricsServerManager {
   constructor() {
     this.clients = /* @__PURE__ */ new Map();
     this.configs = /* @__PURE__ */ new Map();
-    this.defaultServerKey = null;
+    this.defaultServerKeys = /* @__PURE__ */ new Map();
   }
   /**
    * Get the singleton instance
@@ -1750,11 +1956,34 @@ var MetricsServerManager = class _MetricsServerManager {
     return _MetricsServerManager.instance;
   }
   /**
-   * Register a metrics server
+   * Get or create tenant clients map
+   */
+  getTenantClients(tenantId) {
+    let tenantClients = this.clients.get(tenantId);
+    if (!tenantClients) {
+      tenantClients = /* @__PURE__ */ new Map();
+      this.clients.set(tenantId, tenantClients);
+    }
+    return tenantClients;
+  }
+  /**
+   * Get or create tenant configs map
+   */
+  getTenantConfigs(tenantId) {
+    let tenantConfigs = this.configs.get(tenantId);
+    if (!tenantConfigs) {
+      tenantConfigs = /* @__PURE__ */ new Map();
+      this.configs.set(tenantId, tenantConfigs);
+    }
+    return tenantConfigs;
+  }
+  /**
+   * Register a metrics server for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Unique identifier for the server
    * @param config - Metrics server configuration
    */
-  registerServer(key, config) {
+  registerServer(tenantId, key, config) {
     let client;
     switch (config.type) {
       case "prometheus":
@@ -1769,82 +1998,136 @@ var MetricsServerManager = class _MetricsServerManager {
       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;
+    const tenantClients = this.getTenantClients(tenantId);
+    const tenantConfigs = this.getTenantConfigs(tenantId);
+    tenantClients.set(key, client);
+    tenantConfigs.set(key, config);
+    if (!this.defaultServerKeys.has(tenantId)) {
+      this.defaultServerKeys.set(tenantId, key);
     }
   }
   /**
-   * Set the default metrics server
+   * Set the default metrics server for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Server key to set as default
    */
-  setDefaultServer(key) {
-    if (!this.clients.has(key)) {
-      throw new Error(`Metrics server '${key}' not found`);
+  setDefaultServer(tenantId, key) {
+    const tenantClients = this.clients.get(tenantId);
+    if (!tenantClients || !tenantClients.has(key)) {
+      throw new Error(`Metrics server '${key}' not found for tenant '${tenantId}'`);
     }
-    this.defaultServerKey = key;
+    this.defaultServerKeys.set(tenantId, key);
   }
   /**
-   * Get a metrics server client by key
+   * Get a metrics server client by key for a specific tenant
+   * @param tenantId - Tenant identifier
    * @param key - Server key (optional, uses default if not provided)
    */
-  getClient(key) {
-    const serverKey = key || this.defaultServerKey;
+  getClient(tenantId, key) {
+    const tenantClients = this.clients.get(tenantId);
+    if (!tenantClients) {
+      throw new Error(`No metrics servers registered for tenant '${tenantId}'`);
+    }
+    const serverKey = key || this.defaultServerKeys.get(tenantId);
     if (!serverKey) {
-      throw new Error("No metrics server registered");
+      throw new Error(`No default metrics server set for tenant '${tenantId}'`);
     }
-    const client = this.clients.get(serverKey);
+    const client = tenantClients.get(serverKey);
     if (!client) {
-      throw new Error(`Metrics server '${serverKey}' not found`);
+      throw new Error(`Metrics server '${serverKey}' not found for tenant '${tenantId}'`);
     }
     return client;
   }
   /**
-   * Get metrics server configuration by key
+   * Get metrics server configuration by key for a specific tenant
+   * @param tenantId - Tenant identifier
    * @param key - Server key (optional, uses default if not provided)
    */
-  getConfig(key) {
-    const serverKey = key || this.defaultServerKey;
+  getConfig(tenantId, key) {
+    const tenantConfigs = this.configs.get(tenantId);
+    if (!tenantConfigs) {
+      throw new Error(`No metrics servers registered for tenant '${tenantId}'`);
+    }
+    const serverKey = key || this.defaultServerKeys.get(tenantId);
     if (!serverKey) {
-      throw new Error("No metrics server registered");
+      throw new Error(`No default metrics server set for tenant '${tenantId}'`);
     }
-    const config = this.configs.get(serverKey);
+    const config = tenantConfigs.get(serverKey);
     if (!config) {
-      throw new Error(`Metrics server '${serverKey}' not found`);
+      throw new Error(`Metrics server '${serverKey}' not found for tenant '${tenantId}'`);
     }
     return config;
   }
   /**
-   * Check if a metrics server is registered
+   * Check if a metrics server is registered for a tenant
+   * @param tenantId - Tenant identifier
    * @param key - Server key
    */
-  hasServer(key) {
-    return this.clients.has(key);
+  hasServer(tenantId, key) {
+    const tenantClients = this.clients.get(tenantId);
+    return tenantClients ? tenantClients.has(key) : false;
   }
   /**
-   * Get all registered metrics server keys with their types
+   * Get all registered metrics server keys with their types for a tenant
+   * @param tenantId - Tenant identifier
    */
-  getServerKeys() {
-    return Array.from(this.configs.entries()).map(([key, config]) => ({
+  getServerKeys(tenantId) {
+    const tenantConfigs = this.configs.get(tenantId);
+    if (!tenantConfigs) {
+      return [];
+    }
+    return Array.from(tenantConfigs.entries()).map(([key, config]) => ({
       key,
       type: config.type
     }));
   }
   /**
-   * Remove a metrics server
+   * Remove a metrics server for a tenant
+   * @param tenantId - Tenant identifier
    * @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;
+  removeServer(tenantId, key) {
+    const tenantClients = this.clients.get(tenantId);
+    const tenantConfigs = this.configs.get(tenantId);
+    if (tenantClients) {
+      tenantClients.delete(key);
+      if (tenantClients.size === 0) {
+        this.clients.delete(tenantId);
+      }
+    }
+    if (tenantConfigs) {
+      tenantConfigs.delete(key);
+      if (tenantConfigs.size === 0) {
+        this.configs.delete(tenantId);
+      }
+    }
+    if (this.defaultServerKeys.get(tenantId) === key) {
+      const remainingKeys = tenantClients ? Array.from(tenantClients.keys()) : [];
+      if (remainingKeys.length > 0) {
+        this.defaultServerKeys.set(tenantId, remainingKeys[0]);
+      } else {
+        this.defaultServerKeys.delete(tenantId);
+      }
+    }
+  }
+  /**
+   * Clear all metrics servers for a tenant
+   * @param tenantId - Tenant identifier (optional, clears all if not provided)
+   */
+  clear(tenantId) {
+    if (tenantId) {
+      this.clients.delete(tenantId);
+      this.configs.delete(tenantId);
+      this.defaultServerKeys.delete(tenantId);
+    } else {
+      this.clients.clear();
+      this.configs.clear();
+      this.defaultServerKeys.clear();
     }
   }
   /**
    * Load metrics server configurations from a store
-   * and register them with this manager
+   * and register them with this manager for a specific tenant
    *
    * @param store - The metrics server configuration store
    * @param tenantId - Tenant identifier
@@ -1852,7 +2135,7 @@ var MetricsServerManager = class _MetricsServerManager {
   async loadConfigsFromStore(store, tenantId) {
     const configs = await store.getAllConfigs(tenantId);
     for (const entry of configs) {
-      this.registerServer(entry.key, entry.config);
+      this.registerServer(tenantId, entry.key, entry.config);
     }
   }
   /**
@@ -1860,11 +2143,13 @@ var MetricsServerManager = class _MetricsServerManager {
    * across all tenants and register them with this manager
    *
    * @param store - The metrics server configuration store
+   * @deprecated Use loadConfigsFromStore with specific tenant instead
    */
   async loadAllConfigsFromStore(store) {
     const configs = await store.getAllConfigsWithoutTenant();
     for (const entry of configs) {
-      this.registerServer(entry.key, entry.config);
+      const tenantId = entry.tenantId || "default";
+      this.registerServer(tenantId, entry.key, entry.config);
     }
   }
 };
@@ -1873,8 +2158,21 @@ var metricsServerManager = MetricsServerManager.getInstance();
 // src/tool_lattice/metrics/list_metrics_servers.ts
 import z7 from "zod";
 import { tool as tool6 } from "langchain";
+
+// src/tool_lattice/metrics/utils.ts
+function getTenantIdFromConfig2(exeConfig, getTenantId) {
+  const runConfig = exeConfig?.configurable?.runConfig || {};
+  return runConfig.tenantId || (getTenantId ? getTenantId() : "default");
+}
+function filterServerKeysByTenant(serverKeys, tenantId, manager = metricsServerManager) {
+  return serverKeys.filter((key) => {
+    return manager.hasServer(tenantId, key);
+  });
+}
+
+// src/tool_lattice/metrics/list_metrics_servers.ts
 var LIST_METRICS_SERVERS_DESCRIPTION = `List all registered metrics servers. Returns a list of available metrics servers with their keys and types. Use this tool first to understand what metrics servers are available.`;
-var createListMetricsServersTool = ({ serverKeys, serverDescriptions }) => {
+var createListMetricsServersTool = ({ serverKeys, serverDescriptions, getTenantId }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -1884,7 +2182,8 @@ ${serverKeys.map(
   return tool6(
     async (_input, _exeConfig) => {
       try {
-        const servers = metricsServerManager.getServerKeys();
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        const servers = metricsServerManager.getServerKeys(tenantId);
         if (servers.length === 0) {
           return "No metrics servers registered.";
         }
@@ -1910,7 +2209,7 @@ ${lines.join("\n")}`;
 import z8 from "zod";
 import { tool as tool7 } from "langchain";
 var LIST_METRICS_DATASOURCES_DESCRIPTION = `List all available datasources from all configured metrics servers. Returns a table with Server Key, DataSource ID, and DataSource Name. Use this tool first to discover what datasources are available before querying metrics.`;
-var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions }) => {
+var createListMetricsDataSourcesTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Configured metrics servers:
@@ -1920,6 +2219,12 @@ ${serverKeys.map(
   return tool7(
     async (_input, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         if (metricsDataSource) {
@@ -1934,18 +2239,18 @@ You can directly use other metrics tools (such as query_metrics_list, query_sema
 
 To view all available data sources, please clear the current selection or reopen the data source selector.`;
         }
-        if (serverKeys.length === 0) {
-          return "No metrics servers configured.";
+        if (filteredServerKeys.length === 0) {
+          return `No metrics servers available for tenant "${tenantId}".`;
         }
         const allDataSources = [];
-        for (const serverKey of serverKeys) {
+        for (const serverKey of filteredServerKeys) {
           try {
-            const config = metricsServerManager.getConfig(serverKey);
+            const config = metricsServerManager.getConfig(tenantId, serverKey);
             if (config.type !== "semantic") {
               console.warn(`Server "${serverKey}" is not a semantic metrics server, skipping.`);
               continue;
             }
-            const client = metricsServerManager.getClient(serverKey);
+            const client = metricsServerManager.getClient(tenantId, serverKey);
             const dataSources = await client.getDataSources();
             const selectedIds = config.selectedDataSources || [];
             const filteredDataSources = selectedIds.length > 0 ? dataSources.filter((ds) => selectedIds.includes(String(ds.id))) : dataSources;
@@ -1961,10 +2266,10 @@ To view all available data sources, please clear the current selection or reopen
           }
         }
         if (allDataSources.length === 0) {
-          return `No datasources found in any configured metrics servers.`;
+          return `No datasources found in any configured metrics servers for tenant "${tenantId}".`;
         }
         const lines = [];
-        lines.push(`Found ${allDataSources.length} datasource(s) from ${serverKeys.length} server(s):
+        lines.push(`Found ${allDataSources.length} datasource(s) from ${filteredServerKeys.length} server(s):
 `);
         lines.push("| Server Key | DataSource ID | Name |");
         lines.push("|------------|---------------|------|");
@@ -2020,7 +2325,7 @@ Response Fields Reference
 
 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 }) => {
+var createQueryMetricsListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2033,20 +2338,26 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, serverKey);
         const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : metricsDataSource?.datasourceId ? [metricsDataSource.datasourceId] : client.getSelectedDataSources();
         if (targetDatasourceIds.length === 0) {
           return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
@@ -2171,7 +2482,7 @@ Rules
 
 Next Step
 Call query_semantic_metric_data with parameters derived from this definition.`;
-var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions }) => {
+var createQueryMetricDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2185,24 +2496,30 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         const datasourceId = inputDatasourceId || metricsDataSource?.datasourceId;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
         if (!metricName) {
           return "Error: metricName parameter is required.";
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, 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}".`;
@@ -2591,7 +2908,7 @@ Data Source: ${datasourceId}${datasourceName ? ` (${datasourceName})` : ""}`;
   }
   return lines.join("\n");
 }
-var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions }) => {
+var createQuerySemanticMetricDataTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2608,15 +2925,21 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         const datasourceId = metricsDataSource?.datasourceId || inputDatasourceId;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
         if (!datasourceId) {
           return "Error: datasourceId parameter is required.";
@@ -2624,11 +2947,11 @@ ${serverKeys.map(
         if (!metrics || metrics.length === 0) {
           return "Error: metrics parameter is required (at least one metric name).";
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, serverKey);
         const semanticFilters = (filters || []).map((f) => ({
           dimension: f.dimension,
           operator: f.operator,
@@ -2674,7 +2997,7 @@ ${serverKeys.map(
 import z12 from "zod";
 import { tool as tool11 } from "langchain";
 var QUERY_TABLES_LIST_DESCRIPTION = `Query available tables from a semantic metrics server. Returns a list of data tables with their schemas and descriptions. Use this tool to discover what tables are available in the data source.`;
-var createQueryTablesListTool = ({ serverKeys, serverDescriptions }) => {
+var createQueryTablesListTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2687,20 +3010,26 @@ ${serverKeys.map(
       datasourceIds
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, serverKey);
         const targetDatasourceIds = datasourceIds && datasourceIds.length > 0 ? datasourceIds : metricsDataSource?.datasourceId ? [metricsDataSource.datasourceId] : client.getSelectedDataSources();
         if (targetDatasourceIds.length === 0) {
           return `Error: No data sources specified and no default data sources configured for server "${serverKey}".`;
@@ -2772,7 +3101,7 @@ ${serverKeys.map(
 import z13 from "zod";
 import { tool as tool12 } from "langchain";
 var QUERY_TABLE_DEFINITION_DESCRIPTION = `Get detailed definition and schema for a specific table from a semantic metrics server. Returns comprehensive information including column definitions, SQL query, and table relationships.`;
-var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions }) => {
+var createQueryTableDefinitionTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2786,24 +3115,30 @@ ${serverKeys.map(
       datasourceId: inputDatasourceId
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         const datasourceId = inputDatasourceId || metricsDataSource?.datasourceId;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
         if (!tableName) {
           return "Error: tableName parameter is required.";
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, 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}".`;
@@ -2904,7 +3239,7 @@ Example:
   },
   "limit": 100
 }`;
-var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions }) => {
+var createExecuteSqlQueryTool = ({ serverKeys, serverDescriptions, getTenantId, connectAll }) => {
   const availableServersText = serverKeys.length > 0 ? `
 
 Available metrics servers:
@@ -2920,15 +3255,21 @@ ${serverKeys.map(
       limit
     }, _exeConfig) => {
       try {
+        const tenantId = getTenantIdFromConfig2(_exeConfig, getTenantId);
+        let effectiveServerKeys = serverKeys;
+        if (connectAll) {
+          effectiveServerKeys = metricsServerManager.getServerKeys(tenantId).map((s) => s.key);
+        }
+        const filteredServerKeys = filterServerKeysByTenant(effectiveServerKeys, tenantId);
         const runConfig = _exeConfig?.configurable?.runConfig || {};
         const metricsDataSource = runConfig.metricsDataSource;
         const serverKey = metricsDataSource?.serverKey || inputServerKey;
         const datasourceId = metricsDataSource?.datasourceId || inputDatasourceId;
         if (!serverKey) {
-          return "Error: serverKey parameter is required. Available servers: " + serverKeys.join(", ");
+          return "Error: serverKey parameter is required. Available servers: " + filteredServerKeys.join(", ");
         }
-        if (!serverKeys.includes(serverKey)) {
-          return `Error: serverKey "${serverKey}" is not in the allowed list: [${serverKeys.join(", ")}]`;
+        if (!filteredServerKeys.includes(serverKey)) {
+          return `Error: serverKey "${serverKey}" is not available for tenant "${tenantId}". Available servers: [${filteredServerKeys.join(", ")}]`;
         }
         if (!datasourceId) {
           return "Error: datasourceId parameter is required.";
@@ -2936,11 +3277,11 @@ ${serverKeys.map(
         if (!customSql || customSql.trim().length === 0) {
           return "Error: customSql parameter is required and cannot be empty.";
         }
-        const config = metricsServerManager.getConfig(serverKey);
+        const config = metricsServerManager.getConfig(tenantId, 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 client = metricsServerManager.getClient(tenantId, serverKey);
         const result = await client.executeSqlQuery({
           datasourceId,
           customSql,
@@ -4702,104 +5043,137 @@ import { createMiddleware as createMiddleware4 } from "langchain";
 // src/store_lattice/InMemoryThreadStore.ts
 var InMemoryThreadStore = class {
   constructor() {
-    // Map<assistantId, Map<threadId, Thread>>
+    // Map<tenantId, Map<assistantId, Map<threadId, Thread>>>
     this.threads = /* @__PURE__ */ new Map();
   }
   /**
-   * Get all threads for a specific assistant
+   * Get all threads for a specific tenant and assistant
    */
-  async getThreadsByAssistantId(assistantId) {
-    const assistantThreads = this.threads.get(assistantId);
+  async getThreadsByAssistantId(tenantId, assistantId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
+      return [];
+    }
+    const assistantThreads = tenantThreads.get(assistantId);
     if (!assistantThreads) {
       return [];
     }
     return Array.from(assistantThreads.values());
   }
   /**
-   * Get a thread by ID for a specific assistant
+   * Get a thread by ID for a specific tenant
    */
-  async getThreadById(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
+  async getThreadById(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
       return void 0;
     }
-    return assistantThreads.get(threadId);
+    for (const assistantThreads of tenantThreads.values()) {
+      const thread = assistantThreads.get(threadId);
+      if (thread) {
+        return thread;
+      }
+    }
+    return void 0;
   }
   /**
-   * Create a new thread for an assistant
+   * Create a new thread for a tenant and assistant
    */
-  async createThread(assistantId, threadId, data) {
+  async createThread(tenantId, assistantId, threadId, data) {
     const now = /* @__PURE__ */ new Date();
     const thread = {
       id: threadId,
+      tenantId,
       assistantId,
       metadata: data.metadata || {},
       createdAt: now,
       updatedAt: now
     };
-    if (!this.threads.has(assistantId)) {
-      this.threads.set(assistantId, /* @__PURE__ */ new Map());
+    if (!this.threads.has(tenantId)) {
+      this.threads.set(tenantId, /* @__PURE__ */ new Map());
+    }
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads.has(assistantId)) {
+      tenantThreads.set(assistantId, /* @__PURE__ */ new Map());
     }
-    const assistantThreads = this.threads.get(assistantId);
+    const assistantThreads = tenantThreads.get(assistantId);
     assistantThreads.set(threadId, thread);
     return thread;
   }
   /**
    * Update an existing thread
    */
-  async updateThread(assistantId, threadId, updates) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
+  async updateThread(tenantId, threadId, updates) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
       return null;
     }
-    const existing = assistantThreads.get(threadId);
-    if (!existing) {
-      return null;
+    for (const assistantThreads of tenantThreads.values()) {
+      const existing = assistantThreads.get(threadId);
+      if (existing) {
+        const updated = {
+          ...existing,
+          metadata: {
+            ...existing.metadata,
+            ...updates.metadata || {}
+          },
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        assistantThreads.set(threadId, updated);
+        return updated;
+      }
     }
-    const updated = {
-      ...existing,
-      metadata: {
-        ...existing.metadata,
-        ...updates.metadata || {}
-      },
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    assistantThreads.set(threadId, updated);
-    return updated;
+    return null;
   }
   /**
    * Delete a thread by ID
    */
-  async deleteThread(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
+  async deleteThread(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
       return false;
     }
-    return assistantThreads.delete(threadId);
+    for (const assistantThreads of tenantThreads.values()) {
+      if (assistantThreads.has(threadId)) {
+        return assistantThreads.delete(threadId);
+      }
+    }
+    return false;
   }
   /**
    * Check if thread exists
    */
-  async hasThread(assistantId, threadId) {
-    const assistantThreads = this.threads.get(assistantId);
-    if (!assistantThreads) {
+  async hasThread(tenantId, threadId) {
+    const tenantThreads = this.threads.get(tenantId);
+    if (!tenantThreads) {
       return false;
     }
-    return assistantThreads.has(threadId);
+    for (const assistantThreads of tenantThreads.values()) {
+      if (assistantThreads.has(threadId)) {
+        return true;
+      }
+    }
+    return false;
   }
   /**
-   * Clear all threads (useful for testing)
+   * Clear all threads for a tenant (useful for testing)
    */
-  clear() {
-    this.threads.clear();
+  clear(tenantId) {
+    if (tenantId) {
+      this.threads.delete(tenantId);
+    } else {
+      this.threads.clear();
+    }
   }
   /**
    * Get all threads for all assistants (useful for debugging)
    */
   getAllThreads() {
     const allThreads = [];
-    for (const assistantThreads of this.threads.values()) {
-      allThreads.push(...Array.from(assistantThreads.values()));
+    for (const tenantThreads of this.threads.values()) {
+      for (const assistantThreads of tenantThreads.values()) {
+        allThreads.push(...Array.from(assistantThreads.values()));
+      }
     }
     return allThreads;
   }
@@ -4811,38 +5185,50 @@ var InMemoryAssistantStore = class {
     this.assistants = /* @__PURE__ */ new Map();
   }
   /**
-   * Get all assistants
+   * Get all assistants for a tenant
    */
-  async getAllAssistants() {
-    return Array.from(this.assistants.values());
+  async getAllAssistants(tenantId) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) return [];
+    return Array.from(tenantAssistants.values());
   }
   /**
    * Get assistant by ID
    */
-  async getAssistantById(id) {
-    return this.assistants.get(id) || null;
+  async getAssistantById(tenantId, id) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) return null;
+    return tenantAssistants.get(id) || null;
   }
   /**
    * Create a new assistant
    */
-  async createAssistant(id, data) {
+  async createAssistant(tenantId, id, data) {
+    if (!this.assistants.has(tenantId)) {
+      this.assistants.set(tenantId, /* @__PURE__ */ new Map());
+    }
     const now = /* @__PURE__ */ new Date();
     const assistant = {
       id,
+      tenantId,
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
       createdAt: now,
       updatedAt: now
     };
-    this.assistants.set(id, assistant);
+    this.assistants.get(tenantId).set(id, assistant);
     return assistant;
   }
   /**
    * Update an existing assistant
    */
-  async updateAssistant(id, updates) {
-    const existing = this.assistants.get(id);
+  async updateAssistant(tenantId, id, updates) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) {
+      return null;
+    }
+    const existing = tenantAssistants.get(id);
     if (!existing) {
       return null;
     }
@@ -4851,26 +5237,38 @@ var InMemoryAssistantStore = class {
       ...updates,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    this.assistants.set(id, updated);
+    tenantAssistants.set(id, updated);
     return updated;
   }
   /**
    * Delete an assistant by ID
    */
-  async deleteAssistant(id) {
-    return this.assistants.delete(id);
+  async deleteAssistant(tenantId, id) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) {
+      return false;
+    }
+    return tenantAssistants.delete(id);
   }
   /**
    * Check if assistant exists
    */
-  async hasAssistant(id) {
-    return this.assistants.has(id);
+  async hasAssistant(tenantId, id) {
+    const tenantAssistants = this.assistants.get(tenantId);
+    if (!tenantAssistants) {
+      return false;
+    }
+    return tenantAssistants.has(id);
   }
   /**
-   * Clear all assistants (useful for testing)
+   * Clear all assistants for a tenant (useful for testing)
    */
-  clear() {
-    this.assistants.clear();
+  clear(tenantId) {
+    if (tenantId) {
+      this.assistants.delete(tenantId);
+    } else {
+      this.assistants.clear();
+    }
   }
 };
 
@@ -5116,6 +5514,8 @@ var FileSystemSkillStore = class {
       return {
         id: name,
         // id equals name (name is used for path addressing)
+        tenantId: "default",
+        // FileSystemSkillStore uses default tenant
         name: frontmatter.name,
         description: frontmatter.description,
         license: frontmatter.license,
@@ -5163,9 +5563,11 @@ ${body}` : `${frontmatter}
     await fs.writeFile(filePath, content, "utf-8");
   }
   /**
-   * Get all skills
+   * Get all skills for a tenant
+   * Note: FileSystemSkillStore uses a flat structure. TenantId is accepted for protocol compliance
+   * but all skills are returned regardless of tenant.
    */
-  async getAllSkills() {
+  async getAllSkills(_tenantId) {
     await this.ensureDirectoryExists();
     try {
       const entries = await fs.readdir(this.rootDir, { withFileTypes: true });
@@ -5202,17 +5604,19 @@ ${body}` : `${frontmatter}
     }
   }
   /**
-   * Get skill by ID
+   * Get skill by ID for a tenant
    * ID should equal name (name is used for path addressing)
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async getSkillById(id) {
+  async getSkillById(_tenantId, id) {
     return this.readSkillFile(id);
   }
   /**
-   * Create a new skill
+   * Create a new skill for a tenant
    * id should equal name (name is used for path addressing)
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async createSkill(id, data) {
+  async createSkill(_tenantId, id, data) {
     await this.ensureDirectoryExists();
     validateSkillName(data.name);
     if (id !== data.name) {
@@ -5220,14 +5624,15 @@ ${body}` : `${frontmatter}
         `Skill id "${id}" must equal name "${data.name}" (name is used for path addressing)`
       );
     }
-    const existing = await this.getSkillById(id);
+    const existing = await this.getSkillById(_tenantId, id);
     if (existing) {
-      return this.updateSkill(id, data);
+      return this.updateSkill(_tenantId, id, data);
     }
     const now = /* @__PURE__ */ new Date();
     const skill = {
       id: data.name,
       // id equals name
+      tenantId: _tenantId,
       name: data.name,
       description: data.description,
       license: data.license,
@@ -5242,9 +5647,10 @@ ${body}` : `${frontmatter}
     return skill;
   }
   /**
-   * Update an existing skill
+   * Update an existing skill for a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async updateSkill(id, updates) {
+  async updateSkill(_tenantId, id, updates) {
     const skill = await this.readSkillFile(id);
     if (!skill) {
       return null;
@@ -5268,6 +5674,7 @@ ${body}` : `${frontmatter}
       name: updates.name ?? skill.name,
       id: updates.name ?? skill.id,
       // id equals name
+      tenantId: _tenantId,
       description: updates.description ?? skill.description,
       license: updates.license ?? skill.license,
       compatibility: updates.compatibility ?? skill.compatibility,
@@ -5280,10 +5687,11 @@ ${body}` : `${frontmatter}
     return updatedSkill;
   }
   /**
-   * Delete a skill by ID
+   * Delete a skill by ID for a tenant
    * Deletes the entire directory (name is the directory name)
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async deleteSkill(id) {
+  async deleteSkill(_tenantId, id) {
     await this.ensureDirectoryExists();
     const skillDir = this.getSkillDirectoryPath(id);
     try {
@@ -5297,50 +5705,55 @@ ${body}` : `${frontmatter}
     }
   }
   /**
-   * Check if skill exists
+   * Check if skill exists for a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async hasSkill(id) {
-    const skill = await this.getSkillById(id);
+  async hasSkill(_tenantId, id) {
+    const skill = await this.getSkillById(_tenantId, id);
     return skill !== null;
   }
   /**
-   * Search skills by metadata
+   * Search skills by metadata within a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async searchByMetadata(metadataKey, metadataValue) {
-    const allSkills = await this.getAllSkills();
+  async searchByMetadata(_tenantId, metadataKey, metadataValue) {
+    const allSkills = await this.getAllSkills(_tenantId);
     return allSkills.filter((skill) => {
       return skill.metadata && skill.metadata[metadataKey] === metadataValue;
     });
   }
   /**
-   * Filter skills by compatibility
+   * Filter skills by compatibility within a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async filterByCompatibility(compatibility) {
-    const allSkills = await this.getAllSkills();
+  async filterByCompatibility(_tenantId, compatibility) {
+    const allSkills = await this.getAllSkills(_tenantId);
     return allSkills.filter((skill) => {
       return skill.compatibility === compatibility;
     });
   }
   /**
-   * Filter skills by license
+   * Filter skills by license within a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async filterByLicense(license) {
-    const allSkills = await this.getAllSkills();
+  async filterByLicense(_tenantId, license) {
+    const allSkills = await this.getAllSkills(_tenantId);
     return allSkills.filter((skill) => {
       return skill.license === license;
     });
   }
   /**
-   * Get sub-skills of a parent skill
+   * Get sub-skills of a parent skill within a tenant
+   * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
    */
-  async getSubSkills(parentSkillName) {
-    const parentSkill = await this.getSkillById(parentSkillName);
+  async getSubSkills(_tenantId, parentSkillName) {
+    const parentSkill = await this.getSkillById(_tenantId, parentSkillName);
     if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
       return [];
     }
     const subSkills = [];
     for (const subSkillName of parentSkill.subSkills) {
-      const subSkill = await this.getSkillById(subSkillName);
+      const subSkill = await this.getSkillById(_tenantId, subSkillName);
       if (subSkill) {
         subSkills.push(subSkill);
       }
@@ -5349,10 +5762,11 @@ ${body}` : `${frontmatter}
   }
   /**
    * List all resources in a skill's resources directory
+   * @param tenantId The tenant identifier (accepted for protocol compliance)
    * @param skillName The skill name
    * @returns Array of resource paths relative to resources/ directory
    */
-  async listSkillResources(skillName) {
+  async listSkillResources(_tenantId, skillName) {
     const skillDir = this.getSkillDirectoryPath(skillName);
     const resourcesDir = path3.join(skillDir, "resources");
     try {
@@ -5375,11 +5789,12 @@ ${body}` : `${frontmatter}
   }
   /**
    * Load a specific resource from a skill's resources directory
+   * @param tenantId The tenant identifier (accepted for protocol compliance)
    * @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) {
+  async loadSkillResource(_tenantId, skillName, resourcePath) {
     const skillDir = this.getSkillDirectoryPath(skillName);
     const resourcesDir = path3.join(skillDir, "resources");
     const fullPath = path3.join(resourcesDir, resourcePath);
@@ -6116,93 +6531,520 @@ var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager
     return storeLattice;
   }
   /**
-   * Get StoreLattice without type checking (for backward compatibility)
-   * @param key Lattice key name
-   * @param type Store type
-   * @returns StoreLattice (type may be unknown)
+   * Get StoreLattice without type checking (for backward compatibility)
+   * @param key Lattice key name
+   * @param type Store type
+   * @returns StoreLattice (type may be unknown)
+   */
+  getStoreLatticeUnsafe(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    const storeLattice = this.get(compositeKey);
+    if (!storeLattice) {
+      throw new Error(`StoreLattice ${key}:${type} not found`);
+    }
+    return storeLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * Uses composite key (key + type) to check existence
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  hasLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.has(compositeKey);
+  }
+  /**
+   * Remove Lattice
+   * Uses composite key (key + type) to remove the store
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  removeLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.remove(compositeKey);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var storeLatticeManager = StoreLatticeManager.getInstance();
+var registerStoreLattice = (key, type, store) => storeLatticeManager.registerLattice(key, type, store);
+var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, type);
+var defaultThreadStore = new InMemoryThreadStore();
+var defaultAssistantStore = new InMemoryAssistantStore();
+var defaultSkillStore = new FileSystemSkillStore();
+var defaultWorkspaceStore = new InMemoryWorkspaceStore();
+var defaultProjectStore = new InMemoryProjectStore();
+var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
+var defaultMetricsServerConfigStore = new InMemoryMetricsServerConfigStore();
+var defaultMcpServerConfigStore = new InMemoryMcpServerConfigStore();
+storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
+storeLatticeManager.registerLattice(
+  "default",
+  "assistant",
+  defaultAssistantStore
+);
+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);
+storeLatticeManager.registerLattice("default", "mcp", defaultMcpServerConfigStore);
+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/store_lattice/SandboxSkillStore.ts
+function parseFrontmatter2(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterText = match[1];
+  const body = match[2] || "";
+  const frontmatter = {};
+  const lines = frontmatterText.split("\n");
+  let currentKey = null;
+  let metadataIndent = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+    if (currentKey === "metadata" && indent > metadataIndent) {
+      const colonIndex2 = trimmed.indexOf(":");
+      if (colonIndex2 !== -1) {
+        const key2 = trimmed.substring(0, colonIndex2).trim();
+        let value2 = trimmed.substring(colonIndex2 + 1).trim();
+        if (value2.startsWith('"') && value2.endsWith('"') || value2.startsWith("'") && value2.endsWith("'")) {
+          value2 = value2.slice(1, -1);
+        }
+        if (!frontmatter.metadata) {
+          frontmatter.metadata = {};
+        }
+        frontmatter.metadata[key2] = value2;
+      }
+      continue;
+    }
+    if (currentKey === "subSkills" && indent > metadataIndent) {
+      if (trimmed.startsWith("-")) {
+        let value2 = trimmed.substring(1).trim();
+        if (value2.startsWith('"') && value2.endsWith('"') || value2.startsWith("'") && value2.endsWith("'")) {
+          value2 = value2.slice(1, -1);
+        }
+        if (!frontmatter.subSkills) {
+          frontmatter.subSkills = [];
+        }
+        frontmatter.subSkills.push(value2);
+      }
+      continue;
+    }
+    if ((currentKey === "metadata" || currentKey === "subSkills") && indent <= metadataIndent) {
+      currentKey = null;
+      metadataIndent = 0;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmed.substring(0, colonIndex).trim();
+    let value = trimmed.substring(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key === "metadata") {
+      if (value === "" || value === "{}") {
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1];
+          const nextIndent = nextLine.match(/^(\s*)/)?.[1].length || 0;
+          if (nextIndent > indent) {
+            currentKey = "metadata";
+            metadataIndent = indent;
+            frontmatter.metadata = {};
+            continue;
+          }
+        }
+        frontmatter[key] = {};
+      } else if (value.startsWith("{")) {
+        try {
+          frontmatter[key] = JSON.parse(value);
+        } catch {
+          frontmatter[key] = {};
+        }
+      } else {
+        frontmatter[key] = {};
+      }
+    } else if (key === "subSkills") {
+      if (value === "" || value === "[]") {
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1];
+          const nextIndent = nextLine.match(/^(\s*)/)?.[1].length || 0;
+          if (nextIndent > indent && nextLine.trim().startsWith("-")) {
+            currentKey = "subSkills";
+            metadataIndent = indent;
+            frontmatter.subSkills = [];
+            continue;
+          }
+        }
+        frontmatter[key] = [];
+      } else if (value.startsWith("[")) {
+        try {
+          frontmatter[key] = JSON.parse(value);
+        } catch {
+          frontmatter[key] = [];
+        }
+      } else {
+        frontmatter[key] = [];
+      }
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function generateFrontmatter2(data) {
+  const lines = ["---"];
+  lines.push(`name: ${data.name}`);
+  lines.push(`description: ${data.description}`);
+  if (data.license) {
+    lines.push(`license: ${data.license}`);
+  }
+  if (data.compatibility) {
+    lines.push(`compatibility: ${data.compatibility}`);
+  }
+  if (data.metadata && Object.keys(data.metadata).length > 0) {
+    lines.push("metadata:");
+    for (const [key, value] of Object.entries(data.metadata)) {
+      lines.push(`  ${key}: ${value}`);
+    }
+  }
+  if (data.subSkills && data.subSkills.length > 0) {
+    lines.push("subSkills:");
+    for (const subSkill of data.subSkills) {
+      lines.push(`  - ${subSkill}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+var SandboxSkillStore = class {
+  constructor(options = {}) {
+    this.sandboxManager = options.sandboxManager;
+    this.basePath = options.basePath || "/home/gem/tenants";
+  }
+  /**
+   * Get sandbox manager for a tenant
+   */
+  async getSandboxManager() {
+    if (this.sandboxManager) {
+      return this.sandboxManager;
+    }
+    return getSandBoxManager();
+  }
+  /**
+   * Get skill directory path in sandbox
+   */
+  getSkillDirectoryPath(tenantId, name) {
+    if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+      throw new Error(`Invalid skill name: ${name} (contains invalid characters)`);
+    }
+    return `${this.basePath}/${tenantId}/skills/${name}`;
+  }
+  /**
+   * Get skill file path in sandbox
+   */
+  getSkillFilePath(tenantId, name) {
+    return `${this.getSkillDirectoryPath(tenantId, name)}/SKILL.md`;
+  }
+  /**
+   * Read skill from sandbox
+   */
+  async readSkillFile(tenantId, name) {
+    try {
+      const sandboxManager = await this.getSandboxManager();
+      const sandbox = await sandboxManager.createSandbox("global");
+      const filePath = this.getSkillFilePath(tenantId, name);
+      const result = await sandbox.file.readFile({ file: filePath });
+      if (!result.ok) {
+        return null;
+      }
+      let content;
+      if (typeof result.body === "string") {
+        content = result.body;
+      } else if (result.body && typeof result.body === "object") {
+        const body = result.body;
+        content = body.content || body.data?.content || JSON.stringify(body);
+      } else {
+        content = String(result.body);
+      }
+      const { frontmatter, body: skillBody } = parseFrontmatter2(content);
+      if (!frontmatter.name || !frontmatter.description) {
+        console.warn(`Invalid skill file ${name}: missing required fields`);
+        return null;
+      }
+      return {
+        id: name,
+        tenantId,
+        name: frontmatter.name,
+        description: frontmatter.description,
+        license: frontmatter.license,
+        compatibility: frontmatter.compatibility,
+        metadata: frontmatter.metadata || {},
+        content: skillBody.trim() || void 0,
+        subSkills: Array.isArray(frontmatter.subSkills) ? frontmatter.subSkills : void 0,
+        createdAt: /* @__PURE__ */ new Date(),
+        // Sandbox doesn't provide file stats easily
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      console.error(`Error reading skill ${name} from sandbox:`, error);
+      return null;
+    }
+  }
+  /**
+   * Write skill to sandbox
+   */
+  async writeSkillFile(skill) {
+    const sandboxManager = await this.getSandboxManager();
+    const sandbox = await sandboxManager.createSandbox("global");
+    const filePath = this.getSkillFilePath(skill.tenantId, skill.name);
+    const frontmatter = generateFrontmatter2({
+      name: skill.name,
+      description: skill.description,
+      license: skill.license,
+      compatibility: skill.compatibility,
+      metadata: skill.metadata,
+      subSkills: skill.subSkills
+    });
+    const body = skill.content || "";
+    const content = body ? `${frontmatter}
+${body}` : `${frontmatter}
+`;
+    const result = await sandbox.file.writeFile({
+      file: filePath,
+      content,
+      encoding: "utf-8",
+      append: false
+    });
+    if (!result.ok) {
+      throw new Error(`Failed to write skill to sandbox: ${JSON.stringify(result.error)}`);
+    }
+  }
+  /**
+   * Get all skills for a tenant
+   */
+  async getAllSkills(tenantId) {
+    try {
+      const sandboxManager = await this.getSandboxManager();
+      const sandbox = await sandboxManager.createSandbox("global");
+      const skillsDir = `${this.basePath}/${tenantId}/skills`;
+      const result = await sandbox.file.listPath({
+        path: skillsDir,
+        recursive: false,
+        show_hidden: false
+      });
+      if (!result.ok || !result.body) {
+        return [];
+      }
+      const files = result.body?.data?.files || [];
+      const skills = [];
+      for (const entry of files) {
+        if (entry.is_directory) {
+          const pathParts = entry.path.split("/");
+          const skillName = pathParts[pathParts.length - 1];
+          if (!skillName) continue;
+          try {
+            const skill = await this.readSkillFile(tenantId, skillName);
+            if (skill) {
+              skills.push(skill);
+            }
+          } catch (error) {
+            console.error(`Error loading skill "${skillName}":`, error);
+          }
+        }
+      }
+      return skills.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    } catch (error) {
+      console.error(`Error listing skills for tenant ${tenantId}:`, error);
+      return [];
+    }
+  }
+  /**
+   * Get skill by ID
+   */
+  async getSkillById(tenantId, id) {
+    return this.readSkillFile(tenantId, id);
+  }
+  /**
+   * Create a new skill
+   */
+  async createSkill(tenantId, id, data) {
+    validateSkillName(data.name);
+    if (id !== data.name) {
+      throw new Error(
+        `Skill id "${id}" must equal name "${data.name}" (name is used for path addressing)`
+      );
+    }
+    const existing = await this.getSkillById(tenantId, id);
+    if (existing) {
+      return this.updateSkill(tenantId, id, data);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const skill = {
+      id: data.name,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata || {},
+      content: data.content,
+      subSkills: data.subSkills,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.writeSkillFile(skill);
+    return skill;
+  }
+  /**
+   * Update an existing skill
    */
-  getStoreLatticeUnsafe(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    const storeLattice = this.get(compositeKey);
-    if (!storeLattice) {
-      throw new Error(`StoreLattice ${key}:${type} not found`);
+  async updateSkill(tenantId, id, updates) {
+    const skill = await this.readSkillFile(tenantId, id);
+    if (!skill) {
+      return null;
     }
-    return storeLattice;
+    if (updates.name !== void 0) {
+      validateSkillName(updates.name);
+      if (updates.name !== skill.name) {
+        const newSkill = {
+          ...skill,
+          name: updates.name,
+          id: updates.name,
+          description: updates.description ?? skill.description,
+          license: updates.license ?? skill.license,
+          compatibility: updates.compatibility ?? skill.compatibility,
+          metadata: updates.metadata ?? skill.metadata,
+          content: updates.content !== void 0 ? updates.content : skill.content,
+          subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        await this.writeSkillFile(newSkill);
+        await this.deleteSkill(tenantId, id);
+        return newSkill;
+      }
+    }
+    const updatedSkill = {
+      ...skill,
+      name: updates.name ?? skill.name,
+      description: updates.description ?? skill.description,
+      license: updates.license ?? skill.license,
+      compatibility: updates.compatibility ?? skill.compatibility,
+      metadata: updates.metadata ?? skill.metadata,
+      content: updates.content !== void 0 ? updates.content : skill.content,
+      subSkills: updates.subSkills !== void 0 ? updates.subSkills : skill.subSkills,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.writeSkillFile(updatedSkill);
+    return updatedSkill;
   }
   /**
-   * Get all Lattices
+   * Delete a skill by ID
    */
-  getAllLattices() {
-    return this.getAll();
+  async deleteSkill(tenantId, id) {
+    try {
+      const sandboxManager = await this.getSandboxManager();
+      const sandbox = await sandboxManager.createSandbox("global");
+      const filePath = this.getSkillFilePath(tenantId, id);
+      const deleteResult = await sandbox.shell.execCommand({
+        command: `rm -f "${filePath}"`
+      });
+      if (!deleteResult.ok) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error(`Error deleting skill ${id}:`, error);
+      return false;
+    }
   }
   /**
-   * Check if Lattice exists
-   * Uses composite key (key + type) to check existence
-   * @param key Lattice key name
-   * @param type Store type
+   * Check if skill exists
    */
-  hasLattice(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    return this.has(compositeKey);
+  async hasSkill(tenantId, id) {
+    const skill = await this.getSkillById(tenantId, id);
+    return skill !== null;
   }
   /**
-   * Remove Lattice
-   * Uses composite key (key + type) to remove the store
-   * @param key Lattice key name
-   * @param type Store type
+   * Search skills by metadata within a tenant
    */
-  removeLattice(key, type) {
-    const compositeKey = this.getCompositeKey(key, type);
-    return this.remove(compositeKey);
+  async searchByMetadata(tenantId, metadataKey, metadataValue) {
+    const allSkills = await this.getAllSkills(tenantId);
+    return allSkills.filter(
+      (skill) => skill.metadata && skill.metadata[metadataKey] === metadataValue
+    );
   }
   /**
-   * Clear all Lattices
+   * Filter skills by compatibility within a tenant
    */
-  clearLattices() {
-    this.clear();
+  async filterByCompatibility(tenantId, compatibility) {
+    const allSkills = await this.getAllSkills(tenantId);
+    return allSkills.filter((skill) => skill.compatibility === compatibility);
   }
   /**
-   * Get Lattice count
+   * Filter skills by license within a tenant
    */
-  getLatticeCount() {
-    return this.count();
+  async filterByLicense(tenantId, license) {
+    const allSkills = await this.getAllSkills(tenantId);
+    return allSkills.filter((skill) => skill.license === license);
   }
   /**
-   * Get Lattice key list
+   * Get sub-skills of a parent skill within a tenant
    */
-  getLatticeKeys() {
-    return this.keys();
+  async getSubSkills(tenantId, parentSkillName) {
+    const parentSkill = await this.getSkillById(tenantId, parentSkillName);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+    const subSkills = [];
+    for (const subSkillName of parentSkill.subSkills) {
+      const subSkill = await this.getSkillById(tenantId, subSkillName);
+      if (subSkill) {
+        subSkills.push(subSkill);
+      }
+    }
+    return subSkills;
   }
 };
-var storeLatticeManager = StoreLatticeManager.getInstance();
-var registerStoreLattice = (key, type, store) => storeLatticeManager.registerLattice(key, type, store);
-var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, type);
-var defaultThreadStore = new InMemoryThreadStore();
-var defaultAssistantStore = new InMemoryAssistantStore();
-var defaultSkillStore = new FileSystemSkillStore();
-var defaultWorkspaceStore = new InMemoryWorkspaceStore();
-var defaultProjectStore = new InMemoryProjectStore();
-var defaultDatabaseConfigStore = new InMemoryDatabaseConfigStore();
-var defaultMetricsServerConfigStore = new InMemoryMetricsServerConfigStore();
-var defaultMcpServerConfigStore = new InMemoryMcpServerConfigStore();
-storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
-storeLatticeManager.registerLattice(
-  "default",
-  "assistant",
-  defaultAssistantStore
-);
-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);
-storeLatticeManager.registerLattice("default", "mcp", defaultMcpServerConfigStore);
-var defaultUserStore = new InMemoryUserStore();
-var defaultTenantStore = new InMemoryTenantStore();
-var defaultUserTenantLinkStore = new InMemoryUserTenantLinkStore();
-storeLatticeManager.registerLattice("default", "user", defaultUserStore);
-storeLatticeManager.registerLattice("default", "tenant", defaultTenantStore);
-storeLatticeManager.registerLattice("default", "userTenantLink", defaultUserTenantLinkStore);
 
 // src/tool_lattice/skill/load_skills.ts
 import z40 from "zod";
@@ -6241,9 +7083,11 @@ var createLoadSkillContentTool = () => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
         const skillStore = storeLattice.store;
-        const skill = await skillStore.getSkillById(input.skill_name);
+        const runConfig = _exe_config?.configurable?.runConfig || {};
+        const tenantId = runConfig.tenantId || "default";
+        const skill = await skillStore.getSkillById(tenantId, input.skill_name);
         if (!skill) {
-          const allSkills = await skillStore.getAllSkills();
+          const allSkills = await skillStore.getAllSkills(tenantId);
           const availableSkills = allSkills.map((s) => s.name).join(", ");
           return `Skill "${input.skill_name}" not found. Available skills: ${availableSkills}`;
         }
@@ -6275,7 +7119,7 @@ ${content}`;
         const fsStore = skillStore;
         if (fsStore.listSkillResources) {
           try {
-            const resources = await fsStore.listSkillResources(input.skill_name);
+            const resources = await fsStore.listSkillResources(tenantId, input.skill_name);
             if (resources.length > 0) {
               result += "\n\n---\n\n**Resources** (use `load_skill_resource` tool to access):\n";
               resources.forEach((resource) => {
@@ -6309,7 +7153,8 @@ var createLoadSkillResourceTool = () => {
   return tool41(
     async (input, _exe_config) => {
       try {
-        const storeLattice = getStoreLattice("default", "skill");
+        const tenantId = _exe_config?.configurable?.runConfig?.tenantId || "default";
+        const storeLattice = getStoreLattice(tenantId, "skill");
         const skillStore = storeLattice.store;
         const fsStore = skillStore;
         if (!fsStore.loadSkillResource) {
@@ -6349,15 +7194,16 @@ function createSkillMiddleware(params = {}) {
       createLoadSkillContentTool(),
       createLoadSkillResourceTool()
     ],
-    beforeAgent: async () => {
+    beforeAgent: async (state, runtime) => {
       try {
         const storeLattice = getStoreLattice("default", "skill");
         const skillStore = storeLattice?.store;
+        const tenantId = runtime?.context?.tenantId || state?.tenantId || "default";
         if (readAll) {
-          latestSkills = await skillStore.getAllSkills();
+          latestSkills = await skillStore.getAllSkills(tenantId);
         } else if (skills && skills.length > 0) {
           const skillLatticePromises = skills.map(
-            (skillId) => skillStore.getSkillById(skillId)
+            (skillId) => skillStore.getSkillById(tenantId, skillId)
           );
           const skillLattices = await Promise.all(skillLatticePromises);
           latestSkills = skillLattices.filter((skill) => skill !== void 0);
@@ -7243,19 +8089,20 @@ ${systemPrompt}` : systemPrompt;
 import { createMiddleware as createMiddleware6 } from "langchain";
 function createMetricsMiddleware(params) {
   const { serverKeys, serverDescriptions, connectAll } = params;
-  let effectiveServerKeys = serverKeys;
-  if (connectAll) {
-    effectiveServerKeys = metricsServerManager.getServerKeys().map((s) => s.key);
-  }
-  if (!effectiveServerKeys || effectiveServerKeys.length === 0) {
+  if (!serverKeys || serverKeys.length === 0) {
     return createMiddleware6({
       name: "metricsMiddleware",
       tools: []
     });
   }
   const toolParams = {
-    serverKeys: effectiveServerKeys,
-    serverDescriptions
+    serverKeys,
+    serverDescriptions,
+    // When connectAll is true, tools will dynamically get all servers for the tenant at runtime
+    connectAll,
+    // getTenantId will be called at runtime by each tool
+    getTenantId: void 0
+    // Tools will extract tenantId from _exeConfig.configurable.runConfig
   };
   return createMiddleware6({
     name: "metricsMiddleware",
@@ -7388,7 +8235,7 @@ function createAskUserClarifyMiddleware() {
 }
 
 // src/agent_lattice/builders/commonMiddleware.ts
-function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
+async function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
   const middlewares = [];
   const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
   if (filesystemConfig?.enabled && filesystemBackend) {
@@ -7443,14 +8290,16 @@ function createCommonMiddlewares(middlewareConfigs, filesystemBackend) {
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
 var ReActAgentGraphBuilder = class {
-  createFilesystemBackendFactory(middlewareConfigs) {
+  createFilesystemBackendFactory(middlewareConfigs, agentLattice) {
     const filesystemConfig = middlewareConfigs.find((m) => m.type === "filesystem");
     if (!filesystemConfig || !filesystemConfig.enabled) {
       return void 0;
     }
     const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
-    return async (config) => {
-      const { workspaceId, projectId } = config;
+    const agentTenantId = agentLattice.config.tenantId;
+    return async (stateAndStore) => {
+      const { tenantId: runtimeTenantId, workspaceId, projectId } = stateAndStore;
+      const tenantId = runtimeTenantId || agentTenantId;
       let sandboxName = "global";
       if (isolatedLevel === "agent") {
         sandboxName = "agent";
@@ -7461,14 +8310,22 @@ var ReActAgentGraphBuilder = class {
       if (!sandboxManager) {
         throw new Error("Sandbox manager not found");
       }
+      let workingDirectory = "/";
+      if (workspaceId && projectId) {
+        if (tenantId) {
+          workingDirectory = `/tenants/${tenantId}/${workspaceId}/${projectId}`;
+        } else {
+          workingDirectory = `/${workspaceId}/${projectId}`;
+        }
+      }
       return new SandboxFilesystem({
         sandboxInstance: await sandboxManager.createSandbox(sandboxName),
-        workingDirectory: workspaceId && projectId ? `/${workspaceId}/${projectId}` : "/"
+        workingDirectory
       });
     };
   }
-  createMiddlewares(middlewareConfigs) {
-    return createCommonMiddlewares(middlewareConfigs);
+  async createMiddlewares(middlewareConfigs) {
+    return await createCommonMiddlewares(middlewareConfigs);
   }
   /**
    * 构建ReAct Agent Graph
@@ -7477,15 +8334,15 @@ var ReActAgentGraphBuilder = class {
    * @param params Agent构建参数
    * @returns 返回CompiledGraph对象
    */
-  build(agentLattice, params) {
+  async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
       const tool48 = getToolClient(t.key);
       return tool48;
     }).filter((tool48) => tool48 !== void 0);
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
-    const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = createCommonMiddlewares(middlewareConfigs, filesystemBackend);
+    const filesystemBackend = this.createFilesystemBackendFactory(middlewareConfigs, agentLattice);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend);
     return createAgent({
       model: params.model,
       tools,
@@ -8328,14 +9185,18 @@ var StoreBackend = class {
   /**
    * Get the namespace for store operations.
    *
-   * If an assistant_id is available in stateAndStore, return
-   * [assistant_id, "filesystem"] to provide per-assistant isolation.
+   * If both tenant_id and assistant_id are available, return
+   * [tenant_id, assistant_id, "filesystem"] for full tenant + assistant isolation.
+   * If only assistant_id is available, return [assistant_id, "filesystem"].
    * Otherwise return ["filesystem"].
    */
   getNamespace() {
     const namespace = "filesystem";
+    const tenantId = this.stateAndStore.tenantId;
     const assistantId = this.stateAndStore.assistantId;
-    if (assistantId) {
+    if (tenantId && assistantId) {
+      return [tenantId, assistantId, namespace];
+    } else if (assistantId) {
       return [assistantId, namespace];
     }
     return [namespace];
@@ -9762,8 +10623,8 @@ function createFilesystemBackendFactory(middlewareConfigs) {
     return void 0;
   }
   const isolatedLevel = filesystemConfig.config?.isolatedLevel || "global";
-  return async (config) => {
-    const { workspaceId, projectId } = config;
+  return async (stateAndStore) => {
+    const { tenantId, workspaceId, projectId } = stateAndStore;
     let sandboxName = "global";
     if (isolatedLevel === "agent") {
       sandboxName = "agent";
@@ -9774,9 +10635,17 @@ function createFilesystemBackendFactory(middlewareConfigs) {
     if (!sandboxManager) {
       throw new Error("Sandbox manager not found");
     }
+    let workingDirectory = "/";
+    if (workspaceId && projectId) {
+      if (tenantId) {
+        workingDirectory = `/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`;
+      } else {
+        workingDirectory = `/workspaces/${workspaceId}/${projectId}`;
+      }
+    }
     return new SandboxFilesystem({
       sandboxInstance: await sandboxManager.createSandbox(sandboxName),
-      workingDirectory: workspaceId && projectId ? `/workspaces/${workspaceId}/${projectId}` : "/"
+      workingDirectory
     });
   };
 }
@@ -9786,8 +10655,8 @@ var DeepAgentGraphBuilder = class {
   /**
    * 根据 middleware 配置创建 middlewares
    */
-  createMiddlewares(middlewareConfigs) {
-    return createCommonMiddlewares(middlewareConfigs);
+  async createMiddlewares(middlewareConfigs) {
+    return await createCommonMiddlewares(middlewareConfigs);
   }
   /**
    * 构建Deep Agent Graph
@@ -9796,12 +10665,12 @@ var DeepAgentGraphBuilder = class {
    * @param params Agent构建参数
    * @returns 返回CompiledGraph对象
    */
-  build(agentLattice, params) {
+  async build(agentLattice, params) {
     const tools = params.tools.map((t) => {
       const toolClient = getToolClient(t.key);
       return toolClient;
     }).filter((tool48) => tool48 !== void 0);
-    const subagents = params.subAgents.map((sa) => {
+    const subagents = await Promise.all(params.subAgents.map(async (sa) => {
       if (sa.client) {
         return {
           key: sa.config.key,
@@ -9810,7 +10679,7 @@ var DeepAgentGraphBuilder = class {
           runnable: sa.client
         };
       } else {
-        const subagentClient = createAgentClientFromAgentLattice({
+        const subagentClient = await createAgentClientFromAgentLattice({
           config: sa.config
         });
         return {
@@ -9820,10 +10689,10 @@ var DeepAgentGraphBuilder = class {
           runnable: subagentClient
         };
       }
-    });
+    }));
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = this.createMiddlewares(middlewareConfigs);
+    const middlewares = await this.createMiddlewares(middlewareConfigs);
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
@@ -11399,7 +12268,7 @@ var TeamAgentGraphBuilder = class {
    * @param params - Build params with resolved tools and model
    * @returns AgentClient (the TeamLead ReactAgent)
    */
-  build(agentLattice, params) {
+  async build(agentLattice, params) {
     const config = agentLattice.config;
     if (!isTeamAgentConfig(config)) {
       throw new Error(
@@ -11422,7 +12291,7 @@ var TeamAgentGraphBuilder = class {
     });
     const middlewareConfigs = params.middleware || [];
     let filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = createCommonMiddlewares(middlewareConfigs);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs);
     if (!filesystemBackend) {
       filesystemBackend = async (config2) => {
         return new StateBackend(config2);
@@ -11605,6 +12474,31 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     this.initialized = false;
     this.subscribeToAssistantEvents();
   }
+  /**
+   * 从store异步加载单个AgentLattice
+   * 实现BaseLatticeManager的可选方法，支持从assistant store加载单个agent
+   * @param tenantId 租户ID
+   * @param key Agent键名
+   * @returns AgentLattice或undefined
+   */
+  async loadItemFromStore(tenantId, key) {
+    try {
+      const storeLattice = getStoreLattice("default", "assistant");
+      const assistant = await storeLattice.store.getAssistantById(tenantId, key);
+      if (!assistant) {
+        return void 0;
+      }
+      const config = assistantToConfig(assistant);
+      const agentLattice = {
+        config,
+        client: void 0
+      };
+      return agentLattice;
+    } catch (error) {
+      console.error(`Failed to load agent from store [tenant: ${tenantId}, key: ${key}]:`, error);
+      return void 0;
+    }
+  }
   /**
    * 获取AgentLatticeManager单例实例
    */
@@ -11614,11 +12508,15 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     }
     return _AgentLatticeManager._instance;
   }
+  /**
+   * @deprecated This method loads assistants only for the "default" tenant.
+   * Use initializeStoredAssistantsForTenant(tenantId) for proper tenant isolation.
+   */
   async initializeStoredAssistants() {
     if (this.initialized) return;
     try {
       const storeLattice = getStoreLattice("default", "assistant");
-      const assistants = await storeLattice.store.getAllAssistants();
+      const assistants = await storeLattice.store.getAllAssistants("default");
       for (const assistant of assistants) {
         if (this.has(assistant.id)) continue;
         const config = assistantToConfig(assistant);
@@ -11631,33 +12529,33 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
   }
   subscribeToAssistantEvents() {
     event_bus_default.subscribe("assistant:created", (data) => {
-      this.handleAssistantChange(data.id);
+      this.handleAssistantChange(data.id, data.tenantId ?? "default");
     });
     event_bus_default.subscribe("assistant:updated", (data) => {
-      this.handleAssistantChange(data.id);
+      this.handleAssistantChange(data.id, data.tenantId ?? "default");
     });
     event_bus_default.subscribe("assistant:deleted", (data) => {
-      this.handleAssistantDelete(data.id);
+      this.handleAssistantDelete(data.id, data.tenantId ?? "default");
     });
   }
-  async handleAssistantChange(assistantId) {
+  async handleAssistantChange(assistantId, tenantId = "default") {
     try {
       const storeLattice = getStoreLattice("default", "assistant");
-      const assistant = await storeLattice.store.getAssistantById(assistantId);
+      const assistant = await storeLattice.store.getAssistantById(tenantId, assistantId);
       if (assistant) {
-        if (this.has(assistantId)) {
-          this.remove(assistantId);
+        if (this.hasWithTenant(tenantId, assistantId)) {
+          this.removeWithTenant(tenantId, assistantId);
         }
         const config = assistantToConfig(assistant);
-        this.registerLattice(config);
+        this.registerLatticeWithTenant(tenantId, config);
       }
     } catch (error) {
-      console.error(`Failed to handle assistant change for ${assistantId}:`, error);
+      console.error(`Failed to handle assistant change for ${assistantId} (tenant: ${tenantId}):`, error);
     }
   }
-  handleAssistantDelete(assistantId) {
-    if (this.has(assistantId)) {
-      this.remove(assistantId);
+  handleAssistantDelete(assistantId, tenantId = "default") {
+    if (this.hasWithTenant(tenantId, assistantId)) {
+      this.removeWithTenant(tenantId, assistantId);
     }
   }
   /**
@@ -11666,8 +12564,96 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
   getLatticeType() {
     return "agents";
   }
+  // ========== 带租户的新API ==========
+  /**
+   * 带租户注册Agent Lattice
+   * @param tenantId 租户ID
+   * @param config Agent配置
+   */
+  registerLatticeWithTenant(tenantId, config) {
+    const agentLattice = {
+      config: { ...config, tenantId },
+      client: void 0
+      // 客户端将在需要时由initializeClient创建
+    };
+    this.registerWithTenant(tenantId, config.key, agentLattice);
+  }
+  /**
+   * 带租户获取AgentLattice
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  getAgentLatticeWithTenant(tenantId, key) {
+    return this.getWithTenant(tenantId, key);
+  }
+  /**
+   * 带租户检查Lattice是否存在
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  hasAgentLatticeWithTenant(tenantId, key) {
+    return this.hasWithTenant(tenantId, key);
+  }
+  /**
+   * 带租户移除Lattice
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  removeAgentLatticeWithTenant(tenantId, key) {
+    return this.removeWithTenant(tenantId, key);
+  }
+  /**
+   * 获取指定租户的所有Agent Lattice
+   * @param tenantId 租户ID
+   */
+  getAllAgentLatticesByTenant(tenantId) {
+    return this.getAllByTenant(tenantId);
+  }
+  /**
+   * 清空指定租户的所有Agent Lattice
+   * @param tenantId 租户ID
+   */
+  clearAgentLatticesByTenant(tenantId) {
+    this.clearByTenant(tenantId);
+  }
+  /**
+   * 带租户获取Agent配置
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   */
+  getAgentConfigWithTenant(tenantId, key) {
+    return this.getAgentLatticeWithTenant(tenantId, key)?.config;
+  }
+  /**
+   * 获取指定租户的所有Agent配置
+   * 先从数据库加载该租户的 assistants，然后返回所有配置
+   * @param tenantId 租户ID
+   */
+  async getAllAgentConfigsByTenant(tenantId) {
+    await this.initializeStoredAssistantsForTenant(tenantId);
+    return this.getAllAgentLatticesByTenant(tenantId).map((lattice) => lattice.config);
+  }
+  /**
+   * 从数据库加载指定租户的存储助手
+   * @param tenantId 租户ID
+   */
+  async initializeStoredAssistantsForTenant(tenantId) {
+    try {
+      const storeLattice = getStoreLattice("default", "assistant");
+      const assistants = await storeLattice.store.getAllAssistants(tenantId);
+      for (const assistant of assistants) {
+        if (this.hasAgentLatticeWithTenant(tenantId, assistant.id)) continue;
+        const config = assistantToConfig(assistant);
+        this.registerLatticeWithTenant(tenantId, config);
+      }
+    } catch (error) {
+      console.error(`Failed to initialize stored assistants for tenant ${tenantId}:`, error);
+    }
+  }
+  // ========== 向后兼容的旧API（使用 default 租户） ==========
   /**
-   * 注册Agent Lattice
+   * 注册Agent Lattice（向后兼容，使用 "default" 租户）
+   * @deprecated Use registerLatticeWithTenant(tenantId, config) instead
    * @param config Agent配置
    */
   registerLattice(config) {
@@ -11705,7 +12691,8 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     return this.remove(key);
   }
   /**
-   * 获取AgentLattice
+   * 获取AgentLattice（向后兼容，使用 "default" 租户）
+   * @deprecated Use getAgentLatticeWithTenant(tenantId, key) instead
    * @param key Lattice键名
    */
   getAgentLattice(key) {
@@ -11718,25 +12705,28 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     return this.getAll();
   }
   /**
-   * 检查Lattice是否存在
+   * 检查Lattice是否存在（向后兼容，使用 "default" 租户）
+   * @deprecated Use hasAgentLatticeWithTenant(tenantId, key) instead
    * @param key Lattice键名
    */
   hasLattice(key) {
     return this.has(key);
   }
   /**
-   * 移除Lattice
+   * 移除Lattice（向后兼容，使用 "default" 租户）
+   * @deprecated Use removeAgentLatticeWithTenant(tenantId, key) instead
    * @param key Lattice键名
    */
   removeLattice(key) {
     return this.remove(key);
   }
   /**
-   * 获取Agent配置
+   * 获取Agent配置（向后兼容，使用 "default" 租户）
+   * @deprecated Use getAgentConfigWithTenant(tenantId, key) instead
    * @param key Lattice键名
    */
   getAgentConfig(key) {
-    return this.getAgentLattice(key)?.config;
+    return this.getAgentLatticeWithTenant("default", key)?.config;
   }
   /**
    * 获取所有Agent配置
@@ -11757,8 +12747,9 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
       return false;
     }
     try {
-      if (agentLattice.config.schema) {
-        agentLattice.config.schema.parse(input);
+      const config = agentLattice.config;
+      if ("schema" in config && config.schema) {
+        config.schema.parse(input);
       }
       return true;
     } catch {
@@ -11806,9 +12797,10 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @returns 返回Agent构建参数
    */
   buildAgentParams(agentLattice, options) {
+    const tenantId = agentLattice.config.tenantId || "default";
     const paramsBuilder = new AgentParamsBuilder((key) => {
-      this.initializeClient(key);
-      return this.getAgentLattice(key);
+      this.initializeClient(tenantId, key);
+      return this.getAgentLatticeWithTenant(tenantId, key);
     });
     return paramsBuilder.buildParams(agentLattice, options);
   }
@@ -11819,7 +12811,7 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
    * @param options Build options
    * @returns AgentClient instance
    */
-  createAgentClientFromConfig(agentLattice, options) {
+  async createAgentClientFromConfig(agentLattice, options) {
     const resolvedConfig = this.resolveInheritedConfig(agentLattice.config);
     const resolvedLattice = {
       ...agentLattice,
@@ -11828,26 +12820,50 @@ var AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager
     const factory = AgentGraphBuilderFactory.getInstance();
     const builder = factory.getBuilder(resolvedConfig.type);
     const params = this.buildAgentParams(resolvedLattice, options);
-    return builder.build(resolvedLattice, params);
+    return await builder.build(resolvedLattice, params);
   }
   /**
    * 初始化Agent客户端
    *
    * 使用AgentGraphBuilderFactory构建Graph并设置为客户端
    *
+   * @param tenantId 租户ID
    * @param key Lattice键名
    * @param options 构建选项
    * @returns 返回CompiledGraph对象
    */
-  initializeClient(key, options) {
-    const agentLattice = this.getAgentLattice(key);
+  async initializeClient(tenantId, key, options) {
+    const agentLattice = this.getAgentLatticeWithTenant(tenantId, key);
+    if (!agentLattice) {
+      throw new Error(`Agent Lattice "${key}" \u4E0D\u5B58\u5728 (tenant: ${tenantId})`);
+    }
+    if (agentLattice.client) {
+      return agentLattice.client;
+    }
+    const graph = await this.createAgentClientFromConfig(agentLattice, options);
+    agentLattice.client = graph;
+    return graph;
+  }
+  /**
+   * 异步初始化Agent客户端（支持从store加载）
+   *
+   * 如果内存中不存在，会尝试从store加载
+   * 使用AgentGraphBuilderFactory构建Graph并设置为客户端
+   *
+   * @param tenantId 租户ID
+   * @param key Lattice键名
+   * @param options 构建选项
+   * @returns 返回CompiledGraph对象
+   */
+  async initializeClientAsync(tenantId, key, options) {
+    const agentLattice = await this.getOrLoadWithTenant(tenantId, key);
     if (!agentLattice) {
-      throw new Error(`Agent Lattice "${key}" \u4E0D\u5B58\u5728`);
+      throw new Error(`Agent Lattice "${key}" \u4E0D\u5B58\u5728 (tenant: ${tenantId})`);
     }
     if (agentLattice.client) {
       return agentLattice.client;
     }
-    const graph = this.createAgentClientFromConfig(agentLattice, options);
+    const graph = await this.createAgentClientFromConfig(agentLattice, options);
     agentLattice.client = graph;
     return graph;
   }
@@ -11856,19 +12872,24 @@ var agentLatticeManager = AgentLatticeManager.getInstance();
 var registerAgentLattice = (config) => {
   agentLatticeManager.registerLattice(config);
 };
-var registerAgentLattices = (configs) => {
+var registerAgentLatticeWithTenant = (tenantId, config) => {
+  agentLatticeManager.registerLatticeWithTenant(tenantId, config);
+};
+var registerAgentLattices = (tenantId, configs) => {
+  if (!tenantId) {
+    throw new Error("tenantId is required");
+  }
   configs.forEach((config) => {
-    agentLatticeManager.registerLattice(config);
+    agentLatticeManager.registerLatticeWithTenant(tenantId, config);
   });
 };
-var getAgentLattice = (key) => agentLatticeManager.getAgentLattice(key);
 var getAgentConfig = (key) => agentLatticeManager.getAgentConfig(key);
 var getAllAgentConfigs = () => agentLatticeManager.getAllAgentConfigs();
 var validateAgentInput = (key, input) => agentLatticeManager.validateAgentInput(key, input);
 var registerTeammateAgent = (key, client) => agentLatticeManager.registerTeammateAgent(key, client);
 var unregisterTeammateAgent = (key) => agentLatticeManager.unregisterTeammateAgent(key);
-var getAgentClient = (key, options) => agentLatticeManager.initializeClient(key, options);
-var createAgentClientFromAgentLattice = (agentLattice, options) => agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
+var getAgentClient = (tenantId, key, options) => agentLatticeManager.initializeClient(tenantId, key, options);
+var createAgentClientFromAgentLattice = async (agentLattice, options) => await agentLatticeManager.createAgentClientFromConfig(agentLattice, options);
 
 // src/chunk_buffer_lattice/ChunkBuffer.ts
 var ChunkBuffer = class {
@@ -11950,6 +12971,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       buffer = {
         threadId,
         chunks$: new ReplaySubject(this.config.maxChunks),
+        chunks: [],
         status: "active" /* ACTIVE */,
         createdAt: now,
         updatedAt: now,
@@ -11960,14 +12982,27 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     if (buffer.status !== "active" /* ACTIVE */) {
       buffer.status = "active" /* ACTIVE */;
       buffer.chunks$ = new ReplaySubject(this.config.maxChunks);
+      buffer.chunks = [];
       buffer.updatedAt = Date.now();
       buffer.expiresAt = Date.now() + this.config.ttl;
     }
     return buffer;
   }
-  async addChunk(threadId, content) {
+  async addChunk(threadId, arg2, arg3) {
     const buffer = this.getOrCreateBuffer(threadId);
-    const chunk = content;
+    let chunk;
+    if (typeof arg2 === "string" && arg3 !== void 0) {
+      chunk = {
+        type: "message_chunk",
+        data: {
+          id: arg2,
+          content: arg3
+        }
+      };
+    } else {
+      chunk = arg2;
+    }
+    buffer.chunks.push(chunk);
     buffer.chunks$.next(chunk);
     buffer.updatedAt = Date.now();
     buffer.expiresAt = Date.now() + this.config.ttl;
@@ -11999,7 +13034,25 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
   async getThreadBuffer(threadId) {
     const buffer = this.getBufferIfValid(threadId);
     if (!buffer) return void 0;
-    return buffer;
+    return {
+      ...buffer,
+      chunks: [...buffer.chunks]
+    };
+  }
+  async getChunks(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return [];
+    return [...buffer.chunks];
+  }
+  async getAccumulatedContent(threadId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return "";
+    return buffer.chunks.map((chunk) => chunk.data?.content || "").join("");
+  }
+  async getChunksByMessageId(threadId, messageId) {
+    const buffer = this.getBufferIfValid(threadId);
+    if (!buffer) return [];
+    return buffer.chunks.filter((chunk) => chunk.data?.id === messageId);
   }
   async clearThread(threadId) {
     this.buffers.delete(threadId);
@@ -12129,6 +13182,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     let activeCount = 0;
     let completedCount = 0;
     let abortedCount = 0;
+    let totalChunkCount = 0;
     const validBuffers = [];
     for (const [threadId, buffer] of this.buffers.entries()) {
       if (this.isExpired(buffer)) {
@@ -12149,12 +13203,14 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
           abortedCount++;
           break;
       }
+      totalChunkCount += buffer.chunks.length;
     }
     return {
       totalThreads: validBuffers.length,
       activeThreads: activeCount,
       completedThreads: completedCount,
       abortedThreads: abortedCount,
+      totalChunks: totalChunkCount,
       config: this.config
     };
   }
@@ -12322,6 +13378,9 @@ var MemoryScheduleStorage = class {
     let result = [];
     for (const task of this.tasks.values()) {
       let match = true;
+      if (filters?.tenantId !== void 0 && task.tenantId !== filters.tenantId) {
+        match = false;
+      }
       if (filters?.status !== void 0 && task.status !== filters.status) {
         match = false;
       }
@@ -12358,6 +13417,9 @@ var MemoryScheduleStorage = class {
     let count = 0;
     for (const task of this.tasks.values()) {
       let match = true;
+      if (filters?.tenantId !== void 0 && task.tenantId !== filters.tenantId) {
+        match = false;
+      }
       if (filters?.status !== void 0 && task.status !== filters.status) {
         match = false;
       }
@@ -13697,6 +14759,14 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
   getLatticeType() {
     return "skills";
   }
+  /**
+   * Default tenant ID for store operations
+   * Note: SkillLatticeManager operates without explicit tenant context.
+   * Store methods require tenantId for protocol compliance.
+   */
+  getDefaultTenantId() {
+    return "default";
+  }
   /**
    * Configure store for persistence
    * @param storeKey Store key name registered in StoreLatticeManager
@@ -13737,12 +14807,13 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
     client.store = store;
   }
   /**
-   * Register a skill Lattice
+   * Register a skill Lattice with tenant
+   * @param tenantId Tenant ID
    * @param key Lattice key name
    * @param config Skill configuration
    * @param client Optional skill client implementation
    */
-  async registerLattice(key, config, client) {
+  async registerLatticeWithTenant(tenantId, key, config, client) {
     if (!config.name) {
       throw new Error("Skill name is required");
     }
@@ -13764,10 +14835,10 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
       config,
       client: client ?? null
     };
-    this.register(key, skillLattice);
+    this.registerWithTenant(tenantId, key, skillLattice);
     if (store) {
       try {
-        await store.createSkill(key, {
+        await store.createSkill(tenantId, key, {
           name: config.name,
           description: config.description,
           license: config.license,
@@ -13785,24 +14856,43 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
     }
   }
   /**
-   * Get skill Lattice by key
+   * Register a skill Lattice (backward compatible, uses "default" tenant)
+   * @deprecated Use registerLatticeWithTenant(tenantId, key, config, client) instead
+   * @param key Lattice key name
+   * @param config Skill configuration
+   * @param client Optional skill client implementation
+   */
+  async registerLattice(key, config, client) {
+    return this.registerLatticeWithTenant(this.getDefaultTenantId(), key, config, client);
+  }
+  /**
+   * Get skill Lattice by key with tenant
+   * @param tenantId Tenant ID
+   * @param key Lattice key name
+   */
+  getSkillLatticeWithTenant(tenantId, key) {
+    return this.getWithTenant(tenantId, key);
+  }
+  /**
+   * Get skill Lattice by key (backward compatible, uses "default" tenant)
+   * @deprecated Use getSkillLatticeWithTenant(tenantId, key) instead
    * @param key Lattice key name
    */
   getSkillLattice(key) {
-    return this.get(key);
+    return this.getWithTenant(this.getDefaultTenantId(), key);
   }
   /**
-   * Get all skill Lattices from store
-   * Always reads from the configured store and merges with in-memory clients
+   * Get all skill Lattices from store with tenant
+   * @param tenantId Tenant ID
    */
-  async getAllLattices() {
+  async getAllLatticesWithTenant(tenantId) {
     const store = this.getStore();
     if (!store) {
-      return this.getAll();
+      return this.getAllByTenant(tenantId);
     }
-    const skills = await store.getAllSkills();
+    const skills = await store.getAllSkills(tenantId);
     return skills.map((skill) => {
-      const memoryLattice = this.get(skill.id);
+      const memoryLattice = this.getWithTenant(tenantId, skill.id);
       const client = memoryLattice?.client || null;
       if (client && store) {
         this.injectStoreIntoClient(client, store);
@@ -13823,23 +14913,40 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
     });
   }
   /**
-   * Check if Lattice exists
+   * Get all skill Lattices from store (backward compatible, uses "default" tenant)
+   * @deprecated Use getAllLatticesWithTenant(tenantId) instead
+   */
+  async getAllLattices() {
+    return this.getAllLatticesWithTenant(this.getDefaultTenantId());
+  }
+  /**
+   * Check if Lattice exists with tenant
+   * @param tenantId Tenant ID
+   * @param key Lattice key name
+   */
+  hasLatticeWithTenant(tenantId, key) {
+    return this.hasWithTenant(tenantId, key);
+  }
+  /**
+   * Check if Lattice exists (backward compatible, uses "default" tenant)
+   * @deprecated Use hasLatticeWithTenant(tenantId, key) instead
    * @param key Lattice key name
    */
   hasLattice(key) {
-    return this.has(key);
+    return this.hasWithTenant(this.getDefaultTenantId(), key);
   }
   /**
-   * Remove Lattice
+   * Remove Lattice with tenant
+   * @param tenantId Tenant ID
    * @param key Lattice key name
    */
-  async removeLattice(key) {
-    const removed = this.remove(key);
+  async removeLatticeWithTenant(tenantId, key) {
+    const removed = this.removeWithTenant(tenantId, key);
     if (removed) {
       const store = this.getStore();
       if (store) {
         try {
-          await store.deleteSkill(key);
+          await store.deleteSkill(tenantId, key);
         } catch (error) {
           console.warn(
             `Failed to remove skill ${key} from store:`,
@@ -13850,6 +14957,14 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
     }
     return removed;
   }
+  /**
+   * Remove Lattice (backward compatible, uses "default" tenant)
+   * @deprecated Use removeLatticeWithTenant(tenantId, key) instead
+   * @param key Lattice key name
+   */
+  async removeLattice(key) {
+    return this.removeLatticeWithTenant(this.getDefaultTenantId(), key);
+  }
   /**
    * Clear all Lattices
    */
@@ -13947,7 +15062,7 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
     if (!store) {
       throw new Error("No store configured. Call configureStore() first.");
     }
-    const skills = await store.getAllSkills();
+    const skills = await store.getAllSkills(this.getDefaultTenantId());
     for (const skill of skills) {
       const skillLattice = {
         key: skill.id,
@@ -13984,7 +15099,7 @@ var SkillLatticeManager = class _SkillLatticeManager extends BaseLatticeManager
       ...updates
     };
     skillLattice.config = updatedConfig;
-    await store.updateSkill(key, {
+    await store.updateSkill(this.getDefaultTenantId(), key, {
       name: updatedConfig.name,
       description: updatedConfig.description,
       license: updatedConfig.license,
@@ -14208,6 +15323,7 @@ export {
   QueueLatticeManager,
   SandboxFilesystem,
   SandboxLatticeManager,
+  SandboxSkillStore,
   ScheduleLatticeManager,
   SemanticMetricsClient,
   SkillLatticeManager,
@@ -14255,7 +15371,6 @@ export {
   formatReadResponse,
   getAgentClient,
   getAgentConfig,
-  getAgentLattice,
   getAllAgentConfigs,
   getAllToolDefinitions,
   getCheckpointSaver,
@@ -14292,6 +15407,7 @@ export {
   performStringReplacement,
   queueLatticeManager,
   registerAgentLattice,
+  registerAgentLatticeWithTenant,
   registerAgentLattices,
   registerCheckpointSaver,
   registerChunkBuffer,