@axiom-lattice/core 2.1.32 → 2.1.33

package/dist/index.d.mts

@@ -25,6 +25,7 @@ import { Connection, MultiServerMCPClient } from '@langchain/mcp-adapters';
 /**
  * BaseLatticeManager - 抽象基类，为各种Lattice管理器提供通用功能
  * 使用统一的Lattice注册表，不同类型的Lattice通过前缀区分
+ * 支持租户隔离，键格式: {type}:{tenantId}:{key}
  * @template TItem - 管理的项目类型
  */
 declare abstract class BaseLatticeManager<TItem = any> {
@@ -43,47 +44,118 @@ declare abstract class BaseLatticeManager<TItem = any> {
      */
     protected abstract getLatticeType(): string;
     /**
-     * 构造完整的键名，包含类型前缀
+     * 从store异步加载单个项目（可选实现）
+     * 子类可以重写此方法以支持从持久化存储加载单个项目
+     * 方法名使用 loadItemFromStore 以避免与子类可能已有的 loadFromStore 冲突
+     * @param tenantId 租户ID
+     * @param key 项目键名
+     * @returns 加载的项目，如果未找到则返回undefined
+     */
+    protected loadItemFromStore?(tenantId: string, key: string): Promise<TItem | undefined>;
+    /**
+     * 构造完整的键名，包含类型前缀和租户ID
+     * @param tenantId 租户ID，全局共享使用 "default"
      * @param key 原始键名
      */
-    protected getFullKey(key: string): string;
+    protected getFullKey(tenantId: string, key: string): string;
     /**
-     * 注册项目
+     * 带租户的注册项目
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     * @param item 项目实例
+     */
+    registerWithTenant(tenantId: string, key: string, item: TItem): void;
+    /**
+     * 带租户的获取指定项目（同步）
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     */
+    getWithTenant(tenantId: string, key: string): TItem | undefined;
+    /**
+     * 带租户的获取指定项目（异步，支持从store回退加载）
+     * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     * @returns 项目实例，如果未找到则返回undefined
+     */
+    getOrLoadWithTenant(tenantId: string, key: string): Promise<TItem | undefined>;
+    /**
+     * 带租户的检查项目是否存在（同步）
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     */
+    hasWithTenant(tenantId: string, key: string): boolean;
+    /**
+     * 带租户的检查项目是否存在（异步，支持从store回退加载）
+     * 如果内存中不存在且子类实现了loadItemFromStore，则尝试从store加载
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     * @returns 如果存在或能从store加载则返回true
+     */
+    hasOrLoadWithTenant(tenantId: string, key: string): Promise<boolean>;
+    /**
+     * 带租户的移除项目
+     * @param tenantId 租户ID
+     * @param key 项目键名（不含前缀）
+     */
+    removeWithTenant(tenantId: string, key: string): boolean;
+    /**
+     * 获取指定租户的所有项目
+     * @param tenantId 租户ID
+     */
+    getAllByTenant(tenantId: string): TItem[];
+    /**
+     * 清空指定租户的所有项目
+     * @param tenantId 租户ID
+     */
+    clearByTenant(tenantId: string): void;
+    /**
+     * 注册项目（向后兼容，使用 "default" 租户）
+     * @deprecated Use registerWithTenant(tenantId, key, item) instead
      * @param key 项目键名（不含前缀）
      * @param item 项目实例
      */
     register(key: string, item: TItem): void;
     /**
-     * 获取指定项目
+     * 获取指定项目（向后兼容，使用 "default" 租户）
+     * @deprecated Use getWithTenant(tenantId, key) instead
      * @param key 项目键名（不含前缀）
      */
     get(key: string): TItem | undefined;
     /**
-     * 获取所有当前类型的项目
+     * 获取所有当前类型的项目（向后兼容，包含所有租户）
      */
     getAll(): TItem[];
     /**
-     * 检查项目是否存在
+     * 检查项目是否存在（向后兼容，使用 "default" 租户）
+     * @deprecated Use hasWithTenant(tenantId, key) instead
      * @param key 项目键名（不含前缀）
      */
     has(key: string): boolean;
     /**
-     * 移除项目
+     * 移除项目（向后兼容，使用 "default" 租户）
+     * @deprecated Use removeWithTenant(tenantId, key) instead
      * @param key 项目键名（不含前缀）
      */
     remove(key: string): boolean;
     /**
-     * 清空当前类型的所有项目
+     * 清空当前类型的所有项目（向后兼容，包含所有租户）
      */
     clear(): void;
     /**
-     * 获取当前类型的项目数量
+     * 获取当前类型的项目数量（向后兼容，包含所有租户）
      */
     count(): number;
     /**
-     * 获取当前类型的项目键名列表（不含前缀）
+     * 获取当前类型的项目键名列表（向后兼容，包含所有租户）
+     * 返回格式: {tenantId}:{key}
      */
     keys(): string[];
+    /**
+     * 获取当前类型的项目键名列表（仅指定租户，不含租户前缀）
+     * @param tenantId 租户ID
+     */
+    keysByTenant(tenantId: string): string[];
 }
 
 /**
@@ -319,54 +391,72 @@ declare class PostgresDatabase implements ISqlDatabase {
 }
 /**
  * SQL Database Manager
- * Manages database connections and provides a unified interface
+ * Manages database connections with tenant isolation
+ *
+ * Structure: Map<tenantId, Map<key, ISqlDatabase>>
+ * Each tenant has its own isolated set of database connections
  */
 declare class SqlDatabaseManager {
     private static instance;
     private databases;
-    private defaultDatabaseKey;
+    private defaultDatabaseKeys;
     private constructor();
     /**
      * Get the singleton instance
      */
     static getInstance(): SqlDatabaseManager;
     /**
-     * Register a database connection
-     * @param key - Unique identifier for the database
+     * Get or create tenant database map
+     */
+    private getTenantDatabases;
+    /**
+     * 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: string, config: DatabaseConfig): void;
+    registerDatabase(tenantId: string, key: string, config: DatabaseConfig): void;
     /**
-     * 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: string): void;
+    setDefaultDatabase(tenantId: string, key: string): void;
     /**
-     * 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?: string): ISqlDatabase;
+    getDatabase(tenantId: string, key?: string): ISqlDatabase;
     /**
-     * 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: string): boolean;
+    hasDatabase(tenantId: string, key: string): boolean;
     /**
-     * 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(): string[];
+    getDatabaseKeys(tenantId: string): string[];
     /**
-     * Remove a database connection
+     * Remove a database connection for a tenant
+     * @param tenantId - Tenant identifier
      * @param key - Database key
      */
-    removeDatabase(key: string): Promise<void>;
+    removeDatabase(tenantId: string, key: string): Promise<void>;
     /**
-     * Disconnect all databases
+     * Disconnect all databases for a tenant
+     * @param tenantId - Tenant identifier (optional, disconnects all if not provided)
      */
-    disconnectAll(): Promise<void>;
+    disconnectAll(tenantId?: string): Promise<void>;
     /**
      * 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
@@ -379,14 +469,24 @@ declare class SqlDatabaseManager {
      * @param store - The database configuration store
      */
     loadAllConfigsFromStore(store: _axiom_lattice_protocols.DatabaseConfigStore): Promise<void>;
+    /**
+     * Clear all databases for a tenant (useful for testing)
+     * @param tenantId - Tenant identifier (optional, clears all if not provided)
+     */
+    clear(tenantId?: string): void;
 }
 declare const sqlDatabaseManager: SqlDatabaseManager;
 
 interface CreateSqlToolParams$3 {
     databaseKeys: string[];
     databaseDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
 }
-declare const createListTablesSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createListTablesSqlTool: ({ databaseKeys, databaseDescriptions, getTenantId }: CreateSqlToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{
     databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     databaseKey: string;
@@ -401,8 +501,13 @@ declare const createListTablesSqlTool: ({ databaseKeys, databaseDescriptions }:
 interface CreateSqlToolParams$2 {
     databaseKeys: string[];
     databaseDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
 }
-declare const createInfoSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createInfoSqlTool: ({ databaseKeys, databaseDescriptions, getTenantId }: CreateSqlToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
     tables: z.ZodString;
     databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -422,8 +527,13 @@ declare const createInfoSqlTool: ({ databaseKeys, databaseDescriptions }: Create
 interface CreateSqlToolParams$1 {
     databaseKeys: string[];
     databaseDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
 }
-declare const createQueryCheckerSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQueryCheckerSqlTool: ({ databaseKeys, databaseDescriptions, getTenantId }: CreateSqlToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
     databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -443,8 +553,13 @@ declare const createQueryCheckerSqlTool: ({ databaseKeys, databaseDescriptions }
 interface CreateSqlToolParams {
     databaseKeys: string[];
     databaseDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
 }
-declare const createQuerySqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQuerySqlTool: ({ databaseKeys, databaseDescriptions, getTenantId }: CreateSqlToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
     databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -744,60 +859,83 @@ declare class CustomMetricsClient implements IMetricsServerClient {
 }
 /**
  * Metrics Server Manager
- * Manages metrics server connections and provides a unified interface
+ * Manages metrics server connections with tenant isolation
+ *
+ * Structure: Map<tenantId, Map<key, IMetricsServerClient>>
+ * Each tenant has its own isolated set of metrics server connections
  */
 declare class MetricsServerManager {
     private static instance;
     private clients;
     private configs;
-    private defaultServerKey;
+    private defaultServerKeys;
     private constructor();
     /**
      * Get the singleton instance
      */
     static getInstance(): MetricsServerManager;
     /**
-     * Register a metrics server
+     * Get or create tenant clients map
+     */
+    private getTenantClients;
+    /**
+     * Get or create tenant configs map
+     */
+    private getTenantConfigs;
+    /**
+     * 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: string, config: MetricsServerConfig): void;
+    registerServer(tenantId: string, key: string, config: MetricsServerConfig): void;
     /**
-     * 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: string): void;
+    setDefaultServer(tenantId: string, key: string): void;
     /**
-     * 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?: string): IMetricsServerClient;
+    getClient(tenantId: string, key?: string): IMetricsServerClient;
     /**
-     * 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?: string): MetricsServerConfig;
+    getConfig(tenantId: string, key?: string): MetricsServerConfig;
     /**
-     * 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: string): boolean;
+    hasServer(tenantId: string, key: string): boolean;
     /**
-     * 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(): {
+    getServerKeys(tenantId: string): {
         key: string;
         type: MetricsServerType;
         name?: string;
     }[];
     /**
-     * Remove a metrics server
+     * Remove a metrics server for a tenant
+     * @param tenantId - Tenant identifier
      * @param key - Server key
      */
-    removeServer(key: string): void;
+    removeServer(tenantId: string, key: string): void;
+    /**
+     * Clear all metrics servers for a tenant
+     * @param tenantId - Tenant identifier (optional, clears all if not provided)
+     */
+    clear(tenantId?: string): void;
     /**
      * 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
@@ -808,6 +946,7 @@ declare 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
      */
     loadAllConfigsFromStore(store: _axiom_lattice_protocols.MetricsServerConfigStore): Promise<void>;
 }
@@ -816,20 +955,45 @@ declare const metricsServerManager: MetricsServerManager;
 interface CreateMetricsToolParams$5 {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
 }
-declare const createListMetricsServersTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$5) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string, "list_metrics_servers">;
+declare const createListMetricsServersTool: ({ serverKeys, serverDescriptions, getTenantId }: CreateMetricsToolParams$5) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string, "list_metrics_servers">;
 
 interface CreateMetricsToolParams$4 {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createListMetricsDataSourcesTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$4) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string, "list_datasources">;
+declare const createListMetricsDataSourcesTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateMetricsToolParams$4) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string, "list_datasources">;
 
 interface CreateMetricsToolParams$3 {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createQueryMetricsListTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQueryMetricsListTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateMetricsToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     datasourceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
@@ -849,8 +1013,18 @@ declare const createQueryMetricsListTool: ({ serverKeys, serverDescriptions }: C
 interface CreateMetricsToolParams$2 {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createQueryMetricDefinitionTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQueryMetricDefinitionTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateMetricsToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     metricName: z.ZodString;
     datasourceId: z.ZodOptional<z.ZodString>;
@@ -875,8 +1049,18 @@ declare const createQueryMetricDefinitionTool: ({ serverKeys, serverDescriptions
 interface CreateMetricsToolParams$1 {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createQuerySemanticMetricDataTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQuerySemanticMetricDataTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateMetricsToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     datasourceId: z.ZodOptional<z.ZodString>;
     metrics: z.ZodArray<z.ZodString, "many">;
@@ -944,8 +1128,18 @@ declare const createQuerySemanticMetricDataTool: ({ serverKeys, serverDescriptio
 interface CreateTablesToolParams {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createQueryTablesListTool: ({ serverKeys, serverDescriptions }: CreateTablesToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQueryTablesListTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateTablesToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     datasourceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
@@ -965,8 +1159,18 @@ declare const createQueryTablesListTool: ({ serverKeys, serverDescriptions }: Cr
 interface CreateTableToolParams {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createQueryTableDefinitionTool: ({ serverKeys, serverDescriptions }: CreateTableToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createQueryTableDefinitionTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateTableToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     tableName: z.ZodString;
     datasourceId: z.ZodOptional<z.ZodString>;
@@ -991,8 +1195,18 @@ declare const createQueryTableDefinitionTool: ({ serverKeys, serverDescriptions
 interface CreateMetricsToolParams {
     serverKeys: string[];
     serverDescriptions?: Record<string, string>;
+    /**
+     * Function to get tenant ID dynamically from runConfig
+     * This allows tenant isolation based on the execution context
+     */
+    getTenantId?: () => string;
+    /**
+     * When true, connect to all available metrics servers automatically at runtime
+     * When false or undefined, only the servers in serverKeys will be used
+     */
+    connectAll?: boolean;
 }
-declare const createExecuteSqlQueryTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+declare const createExecuteSqlQueryTool: ({ serverKeys, serverDescriptions, getTenantId, connectAll }: CreateMetricsToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
     serverKey: z.ZodOptional<z.ZodString>;
     datasourceId: z.ZodOptional<z.ZodString>;
     customSql: z.ZodString;
@@ -1141,8 +1355,11 @@ declare const validateToolInput: (key: string, input: any) => boolean;
  */
 
 type AgentClient = CompiledStateGraph<any, any, any, any, any> | ReactAgent<any, any, any, any>;
+type AgentConfigWithTenant = AgentConfig & {
+    tenantId?: string;
+};
 interface AgentLattice {
-    config: AgentConfig;
+    config: AgentConfigWithTenant;
     client?: AgentClient | undefined;
 }
 interface MiddlewareConfig {
@@ -1178,11 +1395,23 @@ interface AgentBuildParams {
 declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
     private static _instance;
     private initialized;
+    /**
+     * 从store异步加载单个AgentLattice
+     * 实现BaseLatticeManager的可选方法，支持从assistant store加载单个agent
+     * @param tenantId 租户ID
+     * @param key Agent键名
+     * @returns AgentLattice或undefined
+     */
+    protected loadItemFromStore(tenantId: string, key: string): Promise<AgentLattice | undefined>;
     /**
      * 获取AgentLatticeManager单例实例
      */
     static getInstance(): AgentLatticeManager;
     private constructor();
+    /**
+     * @deprecated This method loads assistants only for the "default" tenant.
+     * Use initializeStoredAssistantsForTenant(tenantId) for proper tenant isolation.
+     */
     private initializeStoredAssistants;
     private subscribeToAssistantEvents;
     private handleAssistantChange;
@@ -1192,7 +1421,59 @@ declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
      */
     protected getLatticeType(): string;
     /**
-     * 注册Agent Lattice
+     * 带租户注册Agent Lattice
+     * @param tenantId 租户ID
+     * @param config Agent配置
+     */
+    registerLatticeWithTenant(tenantId: string, config: AgentConfig): void;
+    /**
+     * 带租户获取AgentLattice
+     * @param tenantId 租户ID
+     * @param key Lattice键名
+     */
+    getAgentLatticeWithTenant(tenantId: string, key: string): AgentLattice | undefined;
+    /**
+     * 带租户检查Lattice是否存在
+     * @param tenantId 租户ID
+     * @param key Lattice键名
+     */
+    hasAgentLatticeWithTenant(tenantId: string, key: string): boolean;
+    /**
+     * 带租户移除Lattice
+     * @param tenantId 租户ID
+     * @param key Lattice键名
+     */
+    removeAgentLatticeWithTenant(tenantId: string, key: string): boolean;
+    /**
+     * 获取指定租户的所有Agent Lattice
+     * @param tenantId 租户ID
+     */
+    getAllAgentLatticesByTenant(tenantId: string): AgentLattice[];
+    /**
+     * 清空指定租户的所有Agent Lattice
+     * @param tenantId 租户ID
+     */
+    clearAgentLatticesByTenant(tenantId: string): void;
+    /**
+     * 带租户获取Agent配置
+     * @param tenantId 租户ID
+     * @param key Lattice键名
+     */
+    getAgentConfigWithTenant(tenantId: string, key: string): AgentConfig | undefined;
+    /**
+     * 获取指定租户的所有Agent配置
+     * 先从数据库加载该租户的 assistants，然后返回所有配置
+     * @param tenantId 租户ID
+     */
+    getAllAgentConfigsByTenant(tenantId: string): Promise<AgentConfig[]>;
+    /**
+     * 从数据库加载指定租户的存储助手
+     * @param tenantId 租户ID
+     */
+    initializeStoredAssistantsForTenant(tenantId: string): Promise<void>;
+    /**
+     * 注册Agent Lattice（向后兼容，使用 "default" 租户）
+     * @deprecated Use registerLatticeWithTenant(tenantId, config) instead
      * @param config Agent配置
      */
     registerLattice(config: AgentConfig): void;
@@ -1210,7 +1491,8 @@ declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
      */
     unregisterTeammateAgent(key: string): boolean;
     /**
-     * 获取AgentLattice
+     * 获取AgentLattice（向后兼容，使用 "default" 租户）
+     * @deprecated Use getAgentLatticeWithTenant(tenantId, key) instead
      * @param key Lattice键名
      */
     getAgentLattice(key: string): AgentLattice | undefined;
@@ -1219,17 +1501,20 @@ declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
      */
     getAllLattices(): AgentLattice[];
     /**
-     * 检查Lattice是否存在
+     * 检查Lattice是否存在（向后兼容，使用 "default" 租户）
+     * @deprecated Use hasAgentLatticeWithTenant(tenantId, key) instead
      * @param key Lattice键名
      */
     hasLattice(key: string): boolean;
     /**
-     * 移除Lattice
+     * 移除Lattice（向后兼容，使用 "default" 租户）
+     * @deprecated Use removeAgentLatticeWithTenant(tenantId, key) instead
      * @param key Lattice键名
      */
     removeLattice(key: string): boolean;
     /**
-     * 获取Agent配置
+     * 获取Agent配置（向后兼容，使用 "default" 租户）
+     * @deprecated Use getAgentConfigWithTenant(tenantId, key) instead
      * @param key Lattice键名
      */
     getAgentConfig(key: string): AgentConfig | undefined;
@@ -1271,35 +1556,49 @@ declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
      * @param options Build options
      * @returns AgentClient instance
      */
-    createAgentClientFromConfig(agentLattice: AgentLattice, options?: GraphBuildOptions): AgentClient;
+    createAgentClientFromConfig(agentLattice: AgentLattice, options?: GraphBuildOptions): Promise<AgentClient>;
     /**
      * 初始化Agent客户端
      *
      * 使用AgentGraphBuilderFactory构建Graph并设置为客户端
      *
+     * @param tenantId 租户ID
      * @param key Lattice键名
      * @param options 构建选项
      * @returns 返回CompiledGraph对象
      */
-    initializeClient(key: string, options?: GraphBuildOptions): AgentClient;
+    initializeClient(tenantId: string, key: string, options?: GraphBuildOptions): Promise<AgentClient>;
+    /**
+     * 异步初始化Agent客户端（支持从store加载）
+     *
+     * 如果内存中不存在，会尝试从store加载
+     * 使用AgentGraphBuilderFactory构建Graph并设置为客户端
+     *
+     * @param tenantId 租户ID
+     * @param key Lattice键名
+     * @param options 构建选项
+     * @returns 返回CompiledGraph对象
+     */
+    initializeClientAsync(tenantId: string, key: string, options?: GraphBuildOptions): Promise<AgentClient>;
 }
 declare const agentLatticeManager: AgentLatticeManager;
 declare const registerAgentLattice: (config: AgentConfig) => void;
-declare const registerAgentLattices: (configs: AgentConfig[]) => void;
-declare const getAgentLattice: (key: string) => AgentLattice | undefined;
+declare const registerAgentLatticeWithTenant: (tenantId: string, config: AgentConfig) => void;
+declare const registerAgentLattices: (tenantId: string, configs: AgentConfig[]) => void;
 declare const getAgentConfig: (key: string) => AgentConfig | undefined;
 declare const getAllAgentConfigs: () => Promise<AgentConfig[]>;
 declare const validateAgentInput: (key: string, input: any) => boolean;
 declare const registerTeammateAgent: (key: string, client: AgentClient) => void;
 declare const unregisterTeammateAgent: (key: string) => boolean;
 /**
- * 获取或初始化Agent客户端
+ * 获取或初始化Agent客户端（同步）
  *
+ * @param tenantId 租户ID
  * @param key Agent Lattice键名
  * @param options 构建选项
  * @returns 返回CompiledGraph对象
  */
-declare const getAgentClient: (key: string, options?: GraphBuildOptions) => AgentClient;
+declare const getAgentClient: (tenantId: string, key: string, options?: GraphBuildOptions) => Promise<AgentClient>;
 
 /**
  * MemoryLatticeManager
@@ -1389,6 +1688,7 @@ interface ThreadBufferConfig {
 interface ThreadBuffer {
     threadId: string;
     chunks$: ReplaySubject<MessageChunk>;
+    chunks: MessageChunk[];
     status: ThreadStatus;
     createdAt: number;
     updatedAt: number;
@@ -1402,6 +1702,7 @@ interface BufferStats {
     activeThreads: number;
     completedThreads: number;
     abortedThreads: number;
+    totalChunks: number;
     config: Required<ThreadBufferConfig>;
 }
 
@@ -1500,12 +1801,16 @@ declare class InMemoryChunkBuffer extends ChunkBuffer {
      * Create or get thread buffer
      */
     private getOrCreateBuffer;
+    addChunk(threadId: string, messageId: string, content: string): Promise<void>;
     addChunk(threadId: string, content: MessageChunk): Promise<void>;
     completeThread(threadId: string): Promise<void>;
     abortThread(threadId: string): Promise<void>;
     isThreadActive(threadId: string): Promise<boolean>;
     getThreadStatus(threadId: string): Promise<ThreadStatus | undefined>;
     getThreadBuffer(threadId: string): Promise<ThreadBuffer | undefined>;
+    getChunks(threadId: string): Promise<MessageChunk[]>;
+    getAccumulatedContent(threadId: string): Promise<string>;
+    getChunksByMessageId(threadId: string, messageId: string): Promise<MessageChunk[]>;
     clearThread(threadId: string): Promise<void>;
     getActiveThreads(): Promise<string[]>;
     getAllThreads(): Promise<string[]>;
@@ -1829,6 +2134,7 @@ declare class MemoryScheduleStorage implements ScheduleStorage {
      * Get all tasks with optional filters
      */
     getAllTasks(filters?: {
+        tenantId?: string;
         status?: ScheduledTaskStatus;
         executionType?: ScheduleExecutionType;
         taskType?: string;
@@ -1841,6 +2147,7 @@ declare class MemoryScheduleStorage implements ScheduleStorage {
      * Count tasks with optional filters
      */
     countTasks(filters?: {
+        tenantId?: string;
         status?: ScheduledTaskStatus;
         executionType?: ScheduleExecutionType;
         taskType?: string;
@@ -2024,7 +2331,7 @@ declare const getStoreLattice: <TStoreType extends StoreType>(key: string, type:
  *
  * In-memory implementation of ThreadStore
  * Provides CRUD operations for thread data stored in memory
- * Threads are organized by assistant ID
+ * Threads are organized by tenant ID and assistant ID
  */
 
 /**
@@ -2033,33 +2340,33 @@ declare const getStoreLattice: <TStoreType extends StoreType>(key: string, type:
 declare class InMemoryThreadStore implements ThreadStore {
     private threads;
     /**
-     * Get all threads for a specific assistant
+     * Get all threads for a specific tenant and assistant
      */
-    getThreadsByAssistantId(assistantId: string): Promise<Thread[]>;
+    getThreadsByAssistantId(tenantId: string, assistantId: string): Promise<Thread[]>;
     /**
-     * Get a thread by ID for a specific assistant
+     * Get a thread by ID for a specific tenant
      */
-    getThreadById(assistantId: string, threadId: string): Promise<Thread | undefined>;
+    getThreadById(tenantId: string, threadId: string): Promise<Thread | undefined>;
     /**
-     * Create a new thread for an assistant
+     * Create a new thread for a tenant and assistant
      */
-    createThread(assistantId: string, threadId: string, data: CreateThreadRequest): Promise<Thread>;
+    createThread(tenantId: string, assistantId: string, threadId: string, data: CreateThreadRequest): Promise<Thread>;
     /**
      * Update an existing thread
      */
-    updateThread(assistantId: string, threadId: string, updates: Partial<CreateThreadRequest>): Promise<Thread | null>;
+    updateThread(tenantId: string, threadId: string, updates: Partial<CreateThreadRequest>): Promise<Thread | null>;
     /**
      * Delete a thread by ID
      */
-    deleteThread(assistantId: string, threadId: string): Promise<boolean>;
+    deleteThread(tenantId: string, threadId: string): Promise<boolean>;
     /**
      * Check if thread exists
      */
-    hasThread(assistantId: string, threadId: string): Promise<boolean>;
+    hasThread(tenantId: string, threadId: string): Promise<boolean>;
     /**
-     * Clear all threads (useful for testing)
+     * Clear all threads for a tenant (useful for testing)
      */
-    clear(): void;
+    clear(tenantId?: string): void;
     /**
      * Get all threads for all assistants (useful for debugging)
      */
@@ -2079,33 +2386,33 @@ declare class InMemoryThreadStore implements ThreadStore {
 declare class InMemoryAssistantStore implements AssistantStore {
     private assistants;
     /**
-     * Get all assistants
+     * Get all assistants for a tenant
      */
-    getAllAssistants(): Promise<Assistant[]>;
+    getAllAssistants(tenantId: string): Promise<Assistant[]>;
     /**
      * Get assistant by ID
      */
-    getAssistantById(id: string): Promise<Assistant | null>;
+    getAssistantById(tenantId: string, id: string): Promise<Assistant | null>;
     /**
      * Create a new assistant
      */
-    createAssistant(id: string, data: CreateAssistantRequest): Promise<Assistant>;
+    createAssistant(tenantId: string, id: string, data: CreateAssistantRequest): Promise<Assistant>;
     /**
      * Update an existing assistant
      */
-    updateAssistant(id: string, updates: Partial<CreateAssistantRequest>): Promise<Assistant | null>;
+    updateAssistant(tenantId: string, id: string, updates: Partial<CreateAssistantRequest>): Promise<Assistant | null>;
     /**
      * Delete an assistant by ID
      */
-    deleteAssistant(id: string): Promise<boolean>;
+    deleteAssistant(tenantId: string, id: string): Promise<boolean>;
     /**
      * Check if assistant exists
      */
-    hasAssistant(id: string): Promise<boolean>;
+    hasAssistant(tenantId: string, id: string): Promise<boolean>;
     /**
-     * Clear all assistants (useful for testing)
+     * Clear all assistants for a tenant (useful for testing)
      */
-    clear(): void;
+    clear(tenantId?: string): void;
 }
 
 /**
@@ -2164,61 +2471,163 @@ declare class FileSystemSkillStore implements SkillStore {
      */
     private writeSkillFile;
     /**
-     * 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.
      */
-    getAllSkills(): Promise<Skill[]>;
+    getAllSkills(_tenantId: string): Promise<Skill[]>;
     /**
-     * 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
      */
-    getSkillById(id: string): Promise<Skill | null>;
+    getSkillById(_tenantId: string, id: string): Promise<Skill | null>;
     /**
-     * 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
      */
-    createSkill(id: string, data: CreateSkillRequest): Promise<Skill>;
+    createSkill(_tenantId: string, id: string, data: CreateSkillRequest): Promise<Skill>;
     /**
-     * Update an existing skill
+     * Update an existing skill for a tenant
+     * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
      */
-    updateSkill(id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+    updateSkill(_tenantId: string, id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
     /**
-     * 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
      */
-    deleteSkill(id: string): Promise<boolean>;
+    deleteSkill(_tenantId: string, id: string): Promise<boolean>;
     /**
-     * Check if skill exists
+     * Check if skill exists for a tenant
+     * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
      */
-    hasSkill(id: string): Promise<boolean>;
+    hasSkill(_tenantId: string, id: string): Promise<boolean>;
     /**
-     * Search skills by metadata
+     * Search skills by metadata within a tenant
+     * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
      */
-    searchByMetadata(metadataKey: string, metadataValue: string): Promise<Skill[]>;
+    searchByMetadata(_tenantId: string, metadataKey: string, metadataValue: string): Promise<Skill[]>;
     /**
-     * Filter skills by compatibility
+     * Filter skills by compatibility within a tenant
+     * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
      */
-    filterByCompatibility(compatibility: string): Promise<Skill[]>;
+    filterByCompatibility(_tenantId: string, compatibility: string): Promise<Skill[]>;
     /**
-     * Filter skills by license
+     * Filter skills by license within a tenant
+     * Note: tenantId is accepted for protocol compliance but FileSystemSkillStore uses flat structure
      */
-    filterByLicense(license: string): Promise<Skill[]>;
+    filterByLicense(_tenantId: string, license: string): Promise<Skill[]>;
     /**
-     * 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
      */
-    getSubSkills(parentSkillName: string): Promise<Skill[]>;
+    getSubSkills(_tenantId: string, parentSkillName: string): Promise<Skill[]>;
     /**
      * 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
      */
-    listSkillResources(skillName: string): Promise<string[]>;
+    listSkillResources(_tenantId: string, skillName: string): Promise<string[]>;
     /**
      * 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
      */
-    loadSkillResource(skillName: string, resourcePath: string): Promise<string | null>;
+    loadSkillResource(_tenantId: string, skillName: string, resourcePath: string): Promise<string | null>;
+}
+
+/**
+ * SandboxSkillStore
+ *
+ * Sandbox-based implementation of SkillStore
+ * Stores skills in a remote sandbox environment
+ * Path format: /home/gem/tenants/{tenantId}/skills/{skillName}/SKILL.md
+ */
+
+interface SandboxSkillStoreOptions {
+    /**
+     * Sandbox manager instance
+     * If not provided, will use getSandBoxManager() dynamically
+     */
+    sandboxManager?: SandboxManagerProtocol;
+    /**
+     * Base path for skill storage
+     * @default "/home/gem/tenants"
+     */
+    basePath?: string;
+}
+/**
+ * Sandbox-based implementation of SkillStore with tenant isolation
+ */
+declare class SandboxSkillStore implements SkillStore {
+    private sandboxManager?;
+    private basePath;
+    constructor(options?: SandboxSkillStoreOptions);
+    /**
+     * Get sandbox manager for a tenant
+     */
+    private getSandboxManager;
+    /**
+     * Get skill directory path in sandbox
+     */
+    private getSkillDirectoryPath;
+    /**
+     * Get skill file path in sandbox
+     */
+    private getSkillFilePath;
+    /**
+     * Read skill from sandbox
+     */
+    private readSkillFile;
+    /**
+     * Write skill to sandbox
+     */
+    private writeSkillFile;
+    /**
+     * Get all skills for a tenant
+     */
+    getAllSkills(tenantId: string): Promise<Skill[]>;
+    /**
+     * Get skill by ID
+     */
+    getSkillById(tenantId: string, id: string): Promise<Skill | null>;
+    /**
+     * Create a new skill
+     */
+    createSkill(tenantId: string, id: string, data: CreateSkillRequest): Promise<Skill>;
+    /**
+     * Update an existing skill
+     */
+    updateSkill(tenantId: string, id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+    /**
+     * Delete a skill by ID
+     */
+    deleteSkill(tenantId: string, id: string): Promise<boolean>;
+    /**
+     * Check if skill exists
+     */
+    hasSkill(tenantId: string, id: string): Promise<boolean>;
+    /**
+     * Search skills by metadata within a tenant
+     */
+    searchByMetadata(tenantId: string, metadataKey: string, metadataValue: string): Promise<Skill[]>;
+    /**
+     * Filter skills by compatibility within a tenant
+     */
+    filterByCompatibility(tenantId: string, compatibility: string): Promise<Skill[]>;
+    /**
+     * Filter skills by license within a tenant
+     */
+    filterByLicense(tenantId: string, license: string): Promise<Skill[]>;
+    /**
+     * Get sub-skills of a parent skill within a tenant
+     */
+    getSubSkills(tenantId: string, parentSkillName: string): Promise<Skill[]>;
 }
 
 /**
@@ -2624,6 +3033,12 @@ declare class SkillLatticeManager extends BaseLatticeManager<SkillLattice> {
      * Get Lattice type prefix
      */
     protected getLatticeType(): string;
+    /**
+     * Default tenant ID for store operations
+     * Note: SkillLatticeManager operates without explicit tenant context.
+     * Store methods require tenantId for protocol compliance.
+     */
+    private getDefaultTenantId;
     /**
      * Configure store for persistence
      * @param storeKey Store key name registered in StoreLatticeManager
@@ -2641,29 +3056,64 @@ declare class SkillLatticeManager extends BaseLatticeManager<SkillLattice> {
      */
     private injectStoreIntoClient;
     /**
-     * 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
+     */
+    registerLatticeWithTenant(tenantId: string, key: string, config: SkillConfig, client?: SkillClient): Promise<void>;
+    /**
+     * 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
      */
     registerLattice(key: string, config: SkillConfig, client?: SkillClient): Promise<void>;
     /**
-     * Get skill Lattice by key
+     * Get skill Lattice by key with tenant
+     * @param tenantId Tenant ID
+     * @param key Lattice key name
+     */
+    getSkillLatticeWithTenant(tenantId: string, key: string): SkillLattice | undefined;
+    /**
+     * Get skill Lattice by key (backward compatible, uses "default" tenant)
+     * @deprecated Use getSkillLatticeWithTenant(tenantId, key) instead
      * @param key Lattice key name
      */
     getSkillLattice(key: string): SkillLattice | undefined;
     /**
-     * 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
+     */
+    getAllLatticesWithTenant(tenantId: string): Promise<SkillLattice[]>;
+    /**
+     * Get all skill Lattices from store (backward compatible, uses "default" tenant)
+     * @deprecated Use getAllLatticesWithTenant(tenantId) instead
      */
     getAllLattices(): Promise<SkillLattice[]>;
     /**
-     * Check if Lattice exists
+     * Check if Lattice exists with tenant
+     * @param tenantId Tenant ID
+     * @param key Lattice key name
+     */
+    hasLatticeWithTenant(tenantId: string, key: string): boolean;
+    /**
+     * Check if Lattice exists (backward compatible, uses "default" tenant)
+     * @deprecated Use hasLatticeWithTenant(tenantId, key) instead
      * @param key Lattice key name
      */
     hasLattice(key: string): boolean;
     /**
-     * Remove Lattice
+     * Remove Lattice with tenant
+     * @param tenantId Tenant ID
+     * @param key Lattice key name
+     */
+    removeLatticeWithTenant(tenantId: string, key: string): Promise<boolean>;
+    /**
+     * Remove Lattice (backward compatible, uses "default" tenant)
+     * @deprecated Use removeLatticeWithTenant(tenantId, key) instead
      * @param key Lattice key name
      */
     removeLattice(key: string): Promise<boolean>;
@@ -3389,7 +3839,7 @@ interface AgentGraphBuilder {
      * @param params Agent构建参数
      * @returns 返回CompiledGraph对象
      */
-    build(agentLattice: AgentLattice, params: AgentBuildParams): AgentClient;
+    build(agentLattice: AgentLattice, params: AgentBuildParams): Promise<AgentClient>;
 }
 
 /**
@@ -3408,7 +3858,7 @@ declare class TeamAgentGraphBuilder implements AgentGraphBuilder {
      * @param params - Build params with resolved tools and model
      * @returns AgentClient (the TeamLead ReactAgent)
      */
-    build(agentLattice: AgentLattice, params: AgentBuildParams): AgentClient;
+    build(agentLattice: AgentLattice, params: AgentBuildParams): Promise<AgentClient>;
 }
 
 /**
@@ -3631,6 +4081,7 @@ interface StateAndStore {
     /** Optional assistant ID for per-assistant isolation in store */
     assistantId?: string;
     threadId?: string;
+    tenantId?: string;
     workspaceId?: string;
     projectId?: string;
 }
@@ -3741,8 +4192,9 @@ declare class StoreBackend implements BackendProtocol {
     /**
      * 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"].
      */
     protected getNamespace(): string[];
@@ -4370,4 +4822,4 @@ declare function validateEncryptionKey(): void;
  */
 declare function clearEncryptionKeyCache(): void;
 
-export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BackendFactory, type BackendProtocol, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, CompositeBackend, ConsoleLoggerClient, type CronFields, CustomMetricsClient, type DatabaseConfig, type DatabaseType, DefaultScheduleClient, EMPTY_CONTENT_WARNING, type EditResult, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type FileData, type FileInfo, FileSystemSkillStore, type FileSystemSkillStoreOptions, FilesystemBackend, type GrepMatch, type IMetricsServerClient, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryTaskListStore, InMemoryTenantStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, type IsolatedLevel, LINE_NUMBER_WIDTH, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, MessageType, MetricsServerManager, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, PinoLoggerClient, PostgresDatabase, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, type RunSandboxConfig, SandboxFilesystem, SandboxLatticeManager, type SandboxManagerProtocol, type ScheduleLattice, ScheduleLatticeManager, SemanticMetricsClient, type SkillLattice, SkillLatticeManager, type SkillResource, SqlDatabaseManager, type StateAndStore, StateBackend, StoreBackend, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, TOOL_RESULT_TOKEN_LIMIT, TRUNCATION_GUIDANCE, type TableInfo, type TableSchema, type TaskEvent, type TaskListStore, type TaskSpec, TaskStatus, type TaskUpdatable, TeamAgentGraphBuilder, type TeamConfig, type TeamMiddlewareOptions, type TeamTask, type TeammateSpec, type TeammateToolsOptions, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type WriteResult, agentLatticeManager, buildGrepResultsDict, checkEmptyContent, clearEncryptionKeyCache, createAgentTeam, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createTeamMiddleware, createTeammateTools, decrypt, describeCronExpression, embeddingsLatticeManager, encrypt, eventBus, eventBus as eventBusDefault, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, getAgentClient, getAgentConfig, getAgentLattice, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, loggerLatticeManager, mcpManager, metricsServerManager, modelLatticeManager, normalizeSandboxName, parseCronExpression, performStringReplacement, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, updateFileData, validateAgentInput, validateEncryptionKey, validatePath, validateSkillName, validateToolInput, vectorStoreLatticeManager };
+export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BackendFactory, type BackendProtocol, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, CompositeBackend, ConsoleLoggerClient, type CronFields, CustomMetricsClient, type DatabaseConfig, type DatabaseType, DefaultScheduleClient, EMPTY_CONTENT_WARNING, type EditResult, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type FileData, type FileInfo, FileSystemSkillStore, type FileSystemSkillStoreOptions, FilesystemBackend, type GrepMatch, type IMetricsServerClient, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryTaskListStore, InMemoryTenantStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, type IsolatedLevel, LINE_NUMBER_WIDTH, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, MessageType, MetricsServerManager, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, PinoLoggerClient, PostgresDatabase, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, type RunSandboxConfig, SandboxFilesystem, SandboxLatticeManager, type SandboxManagerProtocol, SandboxSkillStore, type SandboxSkillStoreOptions, type ScheduleLattice, ScheduleLatticeManager, SemanticMetricsClient, type SkillLattice, SkillLatticeManager, type SkillResource, SqlDatabaseManager, type StateAndStore, StateBackend, StoreBackend, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, TOOL_RESULT_TOKEN_LIMIT, TRUNCATION_GUIDANCE, type TableInfo, type TableSchema, type TaskEvent, type TaskListStore, type TaskSpec, TaskStatus, type TaskUpdatable, TeamAgentGraphBuilder, type TeamConfig, type TeamMiddlewareOptions, type TeamTask, type TeammateSpec, type TeammateToolsOptions, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type WriteResult, agentLatticeManager, buildGrepResultsDict, checkEmptyContent, clearEncryptionKeyCache, createAgentTeam, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createTeamMiddleware, createTeammateTools, decrypt, describeCronExpression, embeddingsLatticeManager, encrypt, eventBus, eventBus as eventBusDefault, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, getAgentClient, getAgentConfig, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, loggerLatticeManager, mcpManager, metricsServerManager, modelLatticeManager, normalizeSandboxName, parseCronExpression, performStringReplacement, queueLatticeManager, registerAgentLattice, registerAgentLatticeWithTenant, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, updateFileData, validateAgentInput, validateEncryptionKey, validatePath, validateSkillName, validateToolInput, vectorStoreLatticeManager };