@axiom-lattice/core 2.1.23 → 2.1.25

package/dist/index.d.mts

@@ -2,21 +2,21 @@ import { BaseMessage } from '@langchain/core/messages';
 import { ZodType } from 'zod/v3';
 import { $ZodType } from 'zod/v4/core';
 import { BaseChatModel, BaseChatModelCallOptions } from '@langchain/core/language_models/chat_models';
-import { BaseLanguageModelInput } from '@langchain/core/language_models/base';
+import { BaseLanguageModelInput, LanguageModelLike } from '@langchain/core/language_models/base';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { ChatResult } from '@langchain/core/outputs';
-import { LLMConfig, ToolConfig, ToolExecutor, AgentConfig, GraphBuildOptions, MessageChunk, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, SkillStore, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest, Skill, CreateSkillRequest, LoggerLatticeProtocol, LoggerConfig, LoggerClient, LoggerContext, SkillConfig, SkillClient } from '@axiom-lattice/protocols';
-import * as protocols from '@axiom-lattice/protocols';
-export { protocols as Protocols };
+import * as _axiom_lattice_protocols from '@axiom-lattice/protocols';
+import { LLMConfig, SemanticMetricsServerConfig, MetricMeta, MetricQueryResult, DataSource, SemanticMetricsQueryRequest, SemanticMetricsQueryResponse, MetricsServerType, MetricsServerConfig, ToolConfig, ToolExecutor, AgentConfig, MiddlewareType, GraphBuildOptions, MessageChunk, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, SkillStore, WorkspaceStore, ProjectStore, DatabaseConfigStore, MetricsServerConfigStore, UserStore, TenantStore, UserTenantLinkStore, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest, Skill, CreateSkillRequest, DatabaseConfigEntry, CreateDatabaseConfigRequest, UpdateDatabaseConfigRequest, User, CreateUserRequest, UpdateUserRequest, Tenant, CreateTenantRequest, UpdateTenantRequest, UserTenantLink, CreateUserTenantLinkRequest, UpdateUserTenantLinkRequest, LoggerLatticeProtocol, LoggerConfig, LoggerClient, LoggerContext, SkillConfig, SkillClient } from '@axiom-lattice/protocols';
+export { _axiom_lattice_protocols as Protocols };
 export { AgentConfig, AgentType, GraphBuildOptions, MemoryType } from '@axiom-lattice/protocols';
 import * as langchain from 'langchain';
-import { ReactAgent } from 'langchain';
-import z from 'zod';
+import { ReactAgent, AgentMiddleware } from 'langchain';
+import z, { z as z$1 } from 'zod';
 import { SandboxClient } from '@agent-infra/sandbox';
 import * as _langchain_core_tools from '@langchain/core/tools';
 import { StructuredTool } from '@langchain/core/tools';
 import { CompiledStateGraph } from '@langchain/langgraph';
-import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
+import { BaseCheckpointSaver, BaseStore } from '@langchain/langgraph-checkpoint';
 import { ReplaySubject } from 'rxjs';
 import { Embeddings } from '@langchain/core/embeddings';
 import { VectorStore } from '@langchain/core/vectorstores';
@@ -300,11 +300,6 @@ interface ISqlDatabase {
     getDatabaseType(): DatabaseType;
 }
 
-/**
- * SQL Database Manager
- * Singleton manager for SQL database connections
- */
-
 /**
  * PostgreSQL Database Implementation
  * Uses pg library for PostgreSQL connections
@@ -369,58 +364,623 @@ declare class SqlDatabaseManager {
      * Disconnect all databases
      */
     disconnectAll(): Promise<void>;
+    /**
+     * Load database configurations from a DatabaseConfigStore
+     * and register them with this manager
+     *
+     * @param store - The database configuration store
+     * @param tenantId - Tenant identifier
+     */
+    loadConfigsFromStore(store: _axiom_lattice_protocols.DatabaseConfigStore, tenantId: string): Promise<void>;
+    /**
+     * Load all database configurations from a DatabaseConfigStore
+     * across all tenants and register them with this manager
+     *
+     * @param store - The database configuration store
+     */
+    loadAllConfigsFromStore(store: _axiom_lattice_protocols.DatabaseConfigStore): Promise<void>;
 }
 declare const sqlDatabaseManager: SqlDatabaseManager;
 
-interface CreateSqlToolParams {
-    databaseKey?: string;
-    connectionString?: string;
+interface CreateSqlToolParams$3 {
+    databaseKeys: string[];
+    databaseDescriptions?: Record<string, string>;
 }
-declare const createListTablesSqlTool: ({ databaseKey, connectionString }: CreateSqlToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, Record<string, never>, {}, string>;
+declare const createListTablesSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{
+    databaseKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    databaseKey: string;
+}, {
+    databaseKey: string;
+}>, {
+    databaseKey: string;
+}, {
+    databaseKey: string;
+}, string>;
 
-declare const createInfoSqlTool: ({ databaseKey, connectionString }: {
-    databaseKey?: string;
-    connectionString?: string;
-}) => langchain.DynamicStructuredTool<z.ZodObject<{
+interface CreateSqlToolParams$2 {
+    databaseKeys: string[];
+    databaseDescriptions?: Record<string, string>;
+}
+declare const createInfoSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
     tables: z.ZodString;
+    databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    databaseKey: string;
     tables: string;
 }, {
+    databaseKey: string;
     tables: string;
 }>, {
     tables: string;
+    databaseKey: string;
 }, {
+    databaseKey: string;
     tables: string;
 }, string>;
 
-declare const createQueryCheckerSqlTool: ({ databaseKey, connectionString }: {
-    databaseKey?: string;
-    connectionString?: string;
-}) => langchain.DynamicStructuredTool<z.ZodObject<{
+interface CreateSqlToolParams$1 {
+    databaseKeys: string[];
+    databaseDescriptions?: Record<string, string>;
+}
+declare const createQueryCheckerSqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
+    databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     query: string;
+    databaseKey: string;
 }, {
     query: string;
+    databaseKey: string;
 }>, {
     query: string;
+    databaseKey: string;
 }, {
     query: string;
+    databaseKey: string;
 }, string>;
 
-declare const createQuerySqlTool: ({ databaseKey, connectionString }: {
-    databaseKey?: string;
-    connectionString?: string;
-}) => langchain.DynamicStructuredTool<z.ZodObject<{
+interface CreateSqlToolParams {
+    databaseKeys: string[];
+    databaseDescriptions?: Record<string, string>;
+}
+declare const createQuerySqlTool: ({ databaseKeys, databaseDescriptions }: CreateSqlToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
     query: z.ZodString;
+    databaseKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     query: string;
+    databaseKey: string;
 }, {
     query: string;
+    databaseKey: string;
 }>, {
     query: string;
+    databaseKey: string;
 }, {
     query: string;
+    databaseKey: string;
+}, string>;
+
+/**
+ * SemanticMetricsClient
+ * Client implementation for Semantic Metrics Server
+ * Provides datasource-aware metrics querying capabilities
+ */
+
+/**
+ * Metric meta item from datasource meta endpoint
+ */
+interface MetricMetaItem {
+    metricName: string;
+    displayName: string;
+    domain: string;
+    shortDesc: string;
+    searchKeywords: string[];
+    registered: boolean;
+}
+/**
+ * Table meta item from datasource meta endpoint
+ */
+interface TableMetaItem {
+    tableName: string;
+    displayName: string;
+    docType: string;
+    docTypeEn: string;
+    mainTable?: string;
+    lineTable?: string;
+    columnCount: number;
+    shortDesc: string;
+}
+/**
+ * Index data from datasource meta endpoint
+ */
+interface MetricMetaIndex {
+    datasourceId: number;
+    datasourceName: string;
+    catalogVersion: string;
+    domainCategories: string[];
+    metrics: MetricMetaItem[];
+    tables: TableMetaItem[];
+}
+/**
+ * Table column definition
+ */
+interface TableColumnDetail {
+    name: string;
+    label: string;
+    description?: string;
+    type?: string;
+    example?: string;
+}
+/**
+ * Table detail from datasource meta endpoint
+ */
+interface TableMetaDetail {
+    tableName: string;
+    docType: string;
+    docTypeEn: string;
+    objTypeCode?: number;
+    mainTable?: string;
+    lineTable?: string;
+    selectSql: string;
+    columns: (TableColumnDetail | null)[];
+}
+/**
+ * Datasource meta response data structure
+ */
+interface DatasourceMetaData {
+    index: MetricMetaIndex;
+    metricsDetails: MetricMetaDetail[];
+    tablesDetails?: TableMetaDetail[];
+}
+/**
+ * Metric meta detail item from datasource meta endpoint
+ */
+interface MetricMetaDetail {
+    datasourceId: number;
+    metricName: string;
+    displayName: string;
+    domain: string;
+    description: string;
+    dataType: string;
+    format: string;
+    defaultTimeContext: {
+        timeDimension: string;
+        label: string;
+        granularity: string;
+        window: string;
+        supportedGrains: string[];
+    };
+    supportedDimensions: Array<{
+        dim_id: string;
+        field_name: string;
+        type: string;
+        filter_operators?: string[];
+        filter_example?: object;
+        group_by_example?: string;
+    }>;
+    aiAgentContext: {
+        polarity: string;
+        synonyms: string[];
+        thresholds: Array<{
+            metric: string;
+            operator: string;
+            value: number;
+            level: string;
+        }>;
+        diagnosticWorkflow: {
+            trigger: {
+                any_of: Array<{
+                    metric: string;
+                    operator: string;
+                    value: number;
+                }>;
+            };
+            actions: Array<{
+                type: string;
+                metric?: string;
+                dimensions?: string[];
+                intent: string;
+            }>;
+            analysis_logic: string;
+        };
+        humanReadableExplanation: string;
+    };
+}
+/**
+ * Semantic Metrics Client Implementation
+ * Uses Semantic Metrics HTTP API for queries
+ */
+declare class SemanticMetricsClient implements IMetricsServerClient {
+    private config;
+    private baseUrl;
+    constructor(config: SemanticMetricsServerConfig);
+    /**
+     * Test connection to the semantic metrics server
+     * Attempts to fetch data sources as a connectivity test
+     */
+    testConnection(): Promise<{
+        connected: boolean;
+        latency?: number;
+        error?: string;
+    }>;
+    /**
+     * Get list of available metrics from all selected data sources
+     * Aggregates metrics across selected datasources
+     */
+    listMetrics(): Promise<MetricMeta[]>;
+    /**
+     * Get metadata for a specific metric
+     * Searches across selected datasources for the metric
+     */
+    getMetricMeta(metricName: string): Promise<MetricMeta | null>;
+    /**
+     * Query metric data - delegates to semanticQuery
+     * Note: For semantic server, use semanticQuery() directly for full functionality
+     */
+    queryMetricData(metricName: string, options: {
+        startTime?: number;
+        endTime?: number;
+        step?: number;
+        labels?: Record<string, string>;
+    }): Promise<MetricQueryResult>;
+    /**
+     * Get the server type
+     */
+    getServerType(): "semantic";
+    /**
+     * Get all available data sources from the semantic server
+     * GET /datasources
+     */
+    getDataSources(): Promise<DataSource[]>;
+    /**
+     * Get metrics meta for a specific data source
+     * GET /datasources/{id}/meta
+     */
+    getDatasourceMetrics(datasourceId: string): Promise<DatasourceMetaData>;
+    /**
+     * Execute a semantic metrics query
+     * POST /metrics/query
+     */
+    semanticQuery(request: SemanticMetricsQueryRequest): Promise<SemanticMetricsQueryResponse>;
+    /**
+     * Get selected data sources for this configuration
+     */
+    getSelectedDataSources(): string[];
+    /**
+     * Build request headers with authentication
+     */
+    private getHeaders;
+}
+
+/**
+ * Metrics Server Client Interface
+ * Defines the contract for metrics server implementations
+ */
+interface IMetricsServerClient {
+    /**
+     * Test connection to the metrics server
+     */
+    testConnection(): Promise<{
+        connected: boolean;
+        latency?: number;
+        error?: string;
+    }>;
+    /**
+     * Get list of available metrics
+     */
+    listMetrics(): Promise<MetricMeta[]>;
+    /**
+     * Get metadata for a specific metric
+     * @param metricName - Name of the metric
+     */
+    getMetricMeta(metricName: string): Promise<MetricMeta | null>;
+    /**
+     * Query metric data
+     * @param metricName - Name of the metric
+     * @param options - Query options
+     */
+    queryMetricData(metricName: string, options: {
+        startTime?: number;
+        endTime?: number;
+        step?: number;
+        labels?: Record<string, string>;
+    }): Promise<MetricQueryResult>;
+    /**
+     * Get the server type
+     */
+    getServerType(): MetricsServerType;
+}
+/**
+ * Prometheus Client Implementation
+ * Uses Prometheus HTTP API for queries
+ */
+declare class PrometheusClient implements IMetricsServerClient {
+    private config;
+    constructor(config: MetricsServerConfig);
+    testConnection(): Promise<{
+        connected: boolean;
+        latency?: number;
+        error?: string;
+    }>;
+    listMetrics(): Promise<MetricMeta[]>;
+    getMetricMeta(metricName: string): Promise<MetricMeta | null>;
+    queryMetricData(metricName: string, options: {
+        startTime?: number;
+        endTime?: number;
+        step?: number;
+        labels?: Record<string, string>;
+    }): Promise<MetricQueryResult>;
+    getServerType(): MetricsServerType;
+    private getHeaders;
+}
+/**
+ * Custom/Generic Metrics Client Implementation
+ * Uses a generic REST API approach
+ */
+declare class CustomMetricsClient implements IMetricsServerClient {
+    private config;
+    constructor(config: MetricsServerConfig);
+    testConnection(): Promise<{
+        connected: boolean;
+        latency?: number;
+        error?: string;
+    }>;
+    listMetrics(): Promise<MetricMeta[]>;
+    getMetricMeta(metricName: string): Promise<MetricMeta | null>;
+    queryMetricData(metricName: string, options: {
+        startTime?: number;
+        endTime?: number;
+        step?: number;
+        labels?: Record<string, string>;
+    }): Promise<MetricQueryResult>;
+    getServerType(): MetricsServerType;
+    private getHeaders;
+}
+/**
+ * Metrics Server Manager
+ * Manages metrics server connections and provides a unified interface
+ */
+declare class MetricsServerManager {
+    private static instance;
+    private clients;
+    private configs;
+    private defaultServerKey;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): MetricsServerManager;
+    /**
+     * Register a metrics server
+     * @param key - Unique identifier for the server
+     * @param config - Metrics server configuration
+     */
+    registerServer(key: string, config: MetricsServerConfig): void;
+    /**
+     * Set the default metrics server
+     * @param key - Server key to set as default
+     */
+    setDefaultServer(key: string): void;
+    /**
+     * Get a metrics server client by key
+     * @param key - Server key (optional, uses default if not provided)
+     */
+    getClient(key?: string): IMetricsServerClient;
+    /**
+     * Get metrics server configuration by key
+     * @param key - Server key (optional, uses default if not provided)
+     */
+    getConfig(key?: string): MetricsServerConfig;
+    /**
+     * Check if a metrics server is registered
+     * @param key - Server key
+     */
+    hasServer(key: string): boolean;
+    /**
+     * Get all registered metrics server keys with their types
+     */
+    getServerKeys(): {
+        key: string;
+        type: MetricsServerType;
+        name?: string;
+    }[];
+    /**
+     * Remove a metrics server
+     * @param key - Server key
+     */
+    removeServer(key: string): void;
+    /**
+     * Load metrics server configurations from a store
+     * and register them with this manager
+     *
+     * @param store - The metrics server configuration store
+     * @param tenantId - Tenant identifier
+     */
+    loadConfigsFromStore(store: _axiom_lattice_protocols.MetricsServerConfigStore, tenantId: string): Promise<void>;
+    /**
+     * Load all metrics server configurations from a store
+     * across all tenants and register them with this manager
+     *
+     * @param store - The metrics server configuration store
+     */
+    loadAllConfigsFromStore(store: _axiom_lattice_protocols.MetricsServerConfigStore): Promise<void>;
+}
+declare const metricsServerManager: MetricsServerManager;
+
+interface CreateMetricsToolParams$4 {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createListMetricsServersTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$4) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string>;
+
+interface CreateMetricsToolParams$3 {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createListMetricsDataSourcesTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$3) => langchain.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string>;
+
+interface CreateMetricsToolParams$2 {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createQueryMetricsListTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$2) => langchain.DynamicStructuredTool<z.ZodObject<{
+    serverKey: z.ZodString;
+    datasourceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}>, {
+    serverKey: string;
+    datasourceIds?: string[];
+}, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}, string>;
+
+interface CreateMetricsToolParams$1 {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createQueryMetricDefinitionTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams$1) => langchain.DynamicStructuredTool<z.ZodObject<{
+    serverKey: z.ZodString;
+    metricName: z.ZodString;
+    datasourceId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    metricName: string;
+    serverKey: string;
+    datasourceId?: string | undefined;
+}, {
+    metricName: string;
+    serverKey: string;
+    datasourceId?: string | undefined;
+}>, {
+    serverKey: string;
+    metricName: string;
+    datasourceId?: string;
+}, {
+    metricName: string;
+    serverKey: string;
+    datasourceId?: string | undefined;
+}, string>;
+
+interface CreateMetricsToolParams {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createQuerySemanticMetricDataTool: ({ serverKeys, serverDescriptions }: CreateMetricsToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+    serverKey: z.ZodString;
+    datasourceId: z.ZodString;
+    metrics: z.ZodArray<z.ZodString, "many">;
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        dimension: z.ZodString;
+        operator: z.ZodString;
+        values: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: (string | number | boolean)[];
+        dimension: string;
+        operator: string;
+    }, {
+        values: (string | number | boolean)[];
+        dimension: string;
+        operator: string;
+    }>, "many">>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    serverKey: string;
+    datasourceId: string;
+    metrics: string[];
+    groupBy?: string[] | undefined;
+    filters?: {
+        values: (string | number | boolean)[];
+        dimension: string;
+        operator: string;
+    }[] | undefined;
+    limit?: number | undefined;
+}, {
+    serverKey: string;
+    datasourceId: string;
+    metrics: string[];
+    groupBy?: string[] | undefined;
+    filters?: {
+        values: (string | number | boolean)[];
+        dimension: string;
+        operator: string;
+    }[] | undefined;
+    limit?: number | undefined;
+}>, {
+    serverKey: string;
+    datasourceId: string;
+    metrics: string[];
+    groupBy?: string[];
+    filters?: Array<{
+        dimension: string;
+        operator: string;
+        values: (string | number | boolean)[];
+    }>;
+    limit?: number;
+}, {
+    serverKey: string;
+    datasourceId: string;
+    metrics: string[];
+    groupBy?: string[] | undefined;
+    filters?: {
+        values: (string | number | boolean)[];
+        dimension: string;
+        operator: string;
+    }[] | undefined;
+    limit?: number | undefined;
+}, string>;
+
+interface CreateTablesToolParams {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createQueryTablesListTool: ({ serverKeys, serverDescriptions }: CreateTablesToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+    serverKey: z.ZodString;
+    datasourceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}>, {
+    serverKey: string;
+    datasourceIds?: string[];
+}, {
+    serverKey: string;
+    datasourceIds?: string[] | undefined;
+}, string>;
+
+interface CreateTableToolParams {
+    serverKeys: string[];
+    serverDescriptions?: Record<string, string>;
+}
+declare const createQueryTableDefinitionTool: ({ serverKeys, serverDescriptions }: CreateTableToolParams) => langchain.DynamicStructuredTool<z.ZodObject<{
+    serverKey: z.ZodString;
+    tableName: z.ZodString;
+    datasourceId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    serverKey: string;
+    tableName: string;
+    datasourceId?: string | undefined;
+}, {
+    serverKey: string;
+    tableName: string;
+    datasourceId?: string | undefined;
+}>, {
+    serverKey: string;
+    tableName: string;
+    datasourceId?: string;
+}, {
+    serverKey: string;
+    tableName: string;
+    datasourceId?: string | undefined;
 }, string>;
 
 interface SandboxManagerProtocol {
@@ -544,6 +1104,31 @@ interface AgentLattice {
     config: AgentConfig;
     client?: AgentClient | undefined;
 }
+interface MiddlewareConfig {
+    id: string;
+    type: MiddlewareType;
+    name: string;
+    description: string;
+    enabled: boolean;
+    config: Record<string, any>;
+}
+interface AgentBuildParams {
+    middleware?: MiddlewareConfig[];
+    skillCategories?: string[];
+    tools: Array<{
+        key: string;
+        definition: any;
+        executor: any;
+    }>;
+    model: ModelLattice;
+    subAgents: Array<{
+        key: string;
+        config: AgentConfig;
+        client: AgentClient | undefined;
+    }>;
+    prompt: string;
+    stateSchema?: z$1.ZodObject<any, any, any, any, any>;
+}
 
 /**
  * AgentLatticeManager - 单例Agent Lattice管理器
@@ -570,6 +1155,19 @@ declare class AgentLatticeManager extends BaseLatticeManager<AgentLattice> {
      * @param config Agent配置
      */
     registerLattice(config: AgentConfig): void;
+    /**
+     * Register a pre-built teammate agent client for dynamic team spawning.
+     * Used when spawning teammates via agentWorkerGraph - the agent must exist
+     * in the lattice before the worker invokes it.
+     *
+     * @param key Unique key (e.g. `team:${teamId}:${agentName}`)
+     * @param client Pre-built AgentClient (ReactAgent or CompiledGraph)
+     */
+    registerTeammateAgent(key: string, client: AgentClient): void;
+    /**
+     * Unregister a teammate agent. Call when a team is done to clean up.
+     */
+    unregisterTeammateAgent(key: string): boolean;
     /**
      * 获取AgentLattice
      * @param key Lattice键名
@@ -651,6 +1249,8 @@ declare const getAgentLattice: (key: string) => AgentLattice | undefined;
 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客户端
  *
@@ -1277,6 +1877,13 @@ type StoreTypeMap = {
     thread: ThreadStore;
     assistant: AssistantStore;
     skill: SkillStore;
+    workspace: WorkspaceStore;
+    project: ProjectStore;
+    database: DatabaseConfigStore;
+    metrics: MetricsServerConfigStore;
+    user: UserStore;
+    tenant: TenantStore;
+    userTenantLink: UserTenantLinkStore;
 };
 /**
  * Store type keys
@@ -1477,6 +2084,13 @@ interface FileSystemSkillStoreOptions {
      */
     rootDir?: string;
 }
+/**
+ * Skill resource metadata
+ */
+interface SkillResource {
+    path: string;
+    isDirectory: boolean;
+}
 /**
  * Filesystem-based implementation of SkillStore
  */
@@ -1550,6 +2164,125 @@ declare class FileSystemSkillStore implements SkillStore {
      * Get sub-skills of a parent skill
      */
     getSubSkills(parentSkillName: string): Promise<Skill[]>;
+    /**
+     * List all resources in a skill's resources directory
+     * @param skillName The skill name
+     * @returns Array of resource paths relative to resources/ directory
+     */
+    listSkillResources(skillName: string): Promise<string[]>;
+    /**
+     * Load a specific resource from a skill's resources directory
+     * @param skillName The skill name
+     * @param resourcePath Path to the resource relative to resources/ directory
+     * @returns The resource content as string
+     */
+    loadSkillResource(skillName: string, resourcePath: string): Promise<string | null>;
+}
+
+/**
+ * InMemoryDatabaseConfigStore
+ *
+ * In-memory implementation of DatabaseConfigStore
+ * Provides CRUD operations for database configuration data stored in memory
+ *
+ * Note: This implementation does NOT encrypt passwords - use with caution
+ * For production use, prefer PostgreSQLDatabaseConfigStore
+ */
+
+/**
+ * In-memory implementation of DatabaseConfigStore
+ */
+declare class InMemoryDatabaseConfigStore implements DatabaseConfigStore {
+    private configs;
+    /**
+     * Get composite key for storage
+     */
+    private getKey;
+    /**
+     * Get all database configurations for a tenant
+     */
+    getAllConfigs(tenantId: string): Promise<DatabaseConfigEntry[]>;
+    /**
+     * Get all database configurations across all tenants
+     */
+    getAllConfigsWithoutTenant(): Promise<DatabaseConfigEntry[]>;
+    /**
+     * Get database configuration by ID
+     */
+    getConfigById(tenantId: string, id: string): Promise<DatabaseConfigEntry | null>;
+    /**
+     * Get database configuration by business key
+     */
+    getConfigByKey(tenantId: string, key: string): Promise<DatabaseConfigEntry | null>;
+    /**
+     * Create a new database configuration
+     */
+    createConfig(tenantId: string, id: string, data: CreateDatabaseConfigRequest): Promise<DatabaseConfigEntry>;
+    /**
+     * Update an existing database configuration
+     */
+    updateConfig(tenantId: string, id: string, updates: Partial<UpdateDatabaseConfigRequest>): Promise<DatabaseConfigEntry | null>;
+    /**
+     * Delete a database configuration by ID
+     */
+    deleteConfig(tenantId: string, id: string): Promise<boolean>;
+    /**
+     * Check if configuration exists
+     */
+    hasConfig(tenantId: string, id: string): Promise<boolean>;
+    /**
+     * Clear all configurations (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Clear configurations for a specific tenant
+     */
+    clearByTenant(tenantId: string): void;
+}
+
+declare class InMemoryUserStore implements UserStore {
+    private users;
+    constructor();
+    getAllUsers(): Promise<User[]>;
+    getUserById(id: string): Promise<User | null>;
+    getUserByEmail(email: string): Promise<User | null>;
+    createUser(id: string, data: CreateUserRequest): Promise<User>;
+    updateUser(id: string, updates: UpdateUserRequest): Promise<User | null>;
+    deleteUser(id: string): Promise<boolean>;
+    clear(): void;
+}
+
+/**
+ * InMemoryTenantStore
+ *
+ * In-memory implementation of TenantStore
+ * Provides CRUD operations for tenant data stored in memory
+ * Tenant is a top-level entity with single key storage
+ */
+
+declare class InMemoryTenantStore implements TenantStore {
+    private tenants;
+    constructor();
+    private initDefaultData;
+    getAllTenants(): Promise<Tenant[]>;
+    getTenantById(id: string): Promise<Tenant | null>;
+    createTenant(id: string, data: CreateTenantRequest): Promise<Tenant>;
+    updateTenant(id: string, updates: UpdateTenantRequest): Promise<Tenant | null>;
+    deleteTenant(id: string): Promise<boolean>;
+    clear(): void;
+}
+
+declare class InMemoryUserTenantLinkStore implements UserTenantLinkStore {
+    private links;
+    private getKey;
+    getTenantsByUser(userId: string): Promise<UserTenantLink[]>;
+    getUsersByTenant(tenantId: string): Promise<UserTenantLink[]>;
+    getLink(userId: string, tenantId: string): Promise<UserTenantLink | null>;
+    createLink(data: CreateUserTenantLinkRequest): Promise<UserTenantLink>;
+    updateLink(userId: string, tenantId: string, updates: UpdateUserTenantLinkRequest): Promise<UserTenantLink | null>;
+    deleteLink(userId: string, tenantId: string): Promise<boolean>;
+    hasLink(userId: string, tenantId: string): Promise<boolean>;
+    clear(): void;
 }
 
 /**
@@ -2107,20 +2840,1408 @@ declare function normalizeSandboxName(name: string): string;
 declare function isValidSandboxName(name: string): boolean;
 
 /**
- * Event bus service
- * Used for event publishing and subscription between internal system components
+ * Agent Team - Store Protocols
+ *
+ * Defines the TaskListStore and MailboxStore interfaces.
+ * These are external shared stores (not agent internal state), following the
+ * same Protocol -> Implementation pattern as ThreadStore / InMemoryThreadStore.
+ *
+ * All methods are scoped by `teamId` so a single store instance can serve
+ * multiple concurrent teams (like ThreadStore is scoped by assistantId).
  */
-declare class EventBus {
-    private emitter;
-    private defaultQueueKey;
-    constructor();
+
+/**
+ * External shared storage for team tasks.
+ *
+ * Leader and teammates access the same store instance to add, claim,
+ * complete, and query tasks. Implementations can be in-memory, filesystem,
+ * database, etc.
+ */
+interface TaskListStore {
     /**
-     * Set the default queue key for queue operations
-     * @param queueKey Queue key name
+     * Add a single task to the team's task list.
+     * @returns The created task with generated id and timestamps.
      */
-    setDefaultQueueKey(queueKey: string): void;
+    addTask(teamId: string, spec: TaskSpec): Promise<TeamTask>;
     /**
-     * Publish event
+     * Add multiple tasks at once. Dependency references (by title) are
+     * resolved to task IDs within this batch + existing tasks.
+     */
+    addTasks(teamId: string, specs: TaskSpec[]): Promise<TeamTask[]>;
+    /**
+     * Update mutable fields of an existing task.
+     * @returns The updated task, or null if not found.
+     */
+    updateTask(teamId: string, taskId: string, updates: Partial<TaskUpdatable>): Promise<TeamTask | null>;
+    /**
+     * Remove a task from the list.
+     * @returns true if removed, false if not found.
+     */
+    removeTask(teamId: string, taskId: string): Promise<boolean>;
+    /**
+     * Claim a specific task by ID: set assignee to agentId and status to CLAIMED.
+     * Only succeeds if the task is PENDING and all its dependencies are COMPLETED.
+     * @returns The claimed task, or null if not found / not claimable.
+     */
+    claimTaskById(teamId: string, taskId: string, agentId: string): Promise<TeamTask | null>;
+    /**
+     * Mark a task as completed with a result summary.
+     * @returns The updated task, or null if not found.
+     */
+    completeTask(teamId: string, taskId: string, result: string): Promise<TeamTask | null>;
+    /**
+     * Mark a task as failed with an error message.
+     * @returns The updated task, or null if not found.
+     */
+    failTask(teamId: string, taskId: string, error: string): Promise<TeamTask | null>;
+    /**
+     * Get a single task by ID.
+     */
+    getTask(teamId: string, taskId: string): Promise<TeamTask | null>;
+    /**
+     * Get all tasks with a given status.
+     */
+    getTasksByStatus(teamId: string, status: TaskStatus): Promise<TeamTask[]>;
+    /**
+     * Get all tasks for the team.
+     */
+    getAllTasks(teamId: string): Promise<TeamTask[]>;
+    /**
+     * Check whether all tasks are in a terminal state (COMPLETED or FAILED)
+     * and no tasks are PENDING, CLAIMED, or IN_PROGRESS.
+     */
+    isAllDone(teamId: string): Promise<boolean>;
+    /**
+     * Check whether there is at least one PENDING task whose dependencies
+     * are all COMPLETED (i.e. a task that can be claimed right now).
+     */
+    hasClaimable(teamId: string): Promise<boolean>;
+    /**
+     * Subscribe to task events. Used by persistent teammates to sleep
+     * until new claimable tasks appear (via "task:added" / "task:completed").
+     */
+    onTaskEvent(teamId: string, event: TaskEvent, callback: (task: TeamTask) => void): void;
+    /**
+     * Remove all tasks for a team (used when disbanding a team).
+     */
+    clearTeam(teamId: string): void;
+}
+/**
+ * External shared storage for inter-agent messages.
+ *
+ * Leader and teammates use the same store instance to send and receive
+ * messages. Implementations can be in-memory, database, etc.
+ */
+interface MailboxStore {
+    /**
+     * Send a direct message from one agent to another.
+     * @returns The created message.
+     */
+    sendMessage(teamId: string, from: string, to: string, content: string, type?: MessageType): Promise<MailboxMessage>;
+    /**
+     * Send a message to all registered agents in the team.
+     * @returns Array of created messages (one per recipient).
+     */
+    broadcastMessage(teamId: string, from: string, content: string, type?: MessageType): Promise<MailboxMessage[]>;
+    /**
+     * Get all messages addressed to a specific agent (including broadcasts).
+     */
+    getMessages(teamId: string, agentId: string): Promise<MailboxMessage[]>;
+    /**
+     * Get only unread messages for an agent.
+     */
+    getUnreadMessages(teamId: string, agentId: string): Promise<MailboxMessage[]>;
+    /**
+     * Mark a specific message as read.
+     */
+    markAsRead(teamId: string, agentId: string, messageId: string): Promise<void>;
+    /**
+     * Register an agent so it can receive broadcast messages.
+     */
+    registerAgent(teamId: string, agentId: string): Promise<void>;
+    /**
+     * Unregister an agent.
+     */
+    unregisterAgent(teamId: string, agentId: string): Promise<void>;
+    /**
+     * Get all registered agent IDs for a team.
+     */
+    getRegisteredAgents(teamId: string): Promise<string[]>;
+    /**
+     * Subscribe to new messages for a specific agent.
+     * Used for real-time notification so teammates can react promptly.
+     */
+    onMessage(teamId: string, agentId: string, callback: (msg: MailboxMessage) => void): void;
+    /**
+     * Unsubscribe from message events.
+     */
+    offMessage(teamId: string, agentId: string, callback: (msg: MailboxMessage) => void): void;
+    /**
+     * Subscribe to all new messages in a team.
+     * Used for real-time notification of any message in the team.
+     */
+    onTeamMessage(teamId: string, callback: (msg: MailboxMessage) => void): void;
+    /**
+     * Unsubscribe from team message events.
+     */
+    offTeamMessage(teamId: string, callback: (msg: MailboxMessage) => void): void;
+    /**
+     * Get all messages for all agents in a team.
+     */
+    getAllTeamMessages(teamId: string): Promise<MailboxMessage[]>;
+    /**
+     * Remove all messages for a team (used when disbanding a team).
+     */
+    clearTeam(teamId: string): void;
+}
+
+/**
+ * Agent Team - Core Type Definitions
+ *
+ * Shared types used by TaskListStore, MailboxStore, middleware, and the AgentTeam facade.
+ */
+
+/**
+ * Status of a task in the shared task list.
+ */
+declare enum TaskStatus {
+    PENDING = "pending",
+    CLAIMED = "claimed",
+    IN_PROGRESS = "in_progress",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+/**
+ * Events emitted by a TaskListStore when task state changes.
+ */
+type TaskEvent = "task:added" | "task:claimed" | "task:completed" | "task:failed" | "task:removed";
+/**
+ * A task stored in the shared task list.
+ */
+interface TeamTask {
+    /** Unique task identifier */
+    id: string;
+    /** Short title for the task */
+    title: string;
+    /** Detailed description of what needs to be done */
+    description: string;
+    /** Current status */
+    status: TaskStatus;
+    /** Name of the teammate that claimed this task */
+    assignee?: string;
+    /** Result summary when completed */
+    result?: string;
+    /** Error message when failed */
+    error?: string;
+    /** IDs of tasks that must be completed before this one can be claimed */
+    dependencies: string[];
+    /** When the task was created */
+    createdAt: Date;
+    /** When the task was last updated */
+    updatedAt: Date;
+}
+/**
+ * Input for creating a new task.
+ */
+interface TaskSpec {
+    id: string;
+    title: string;
+    description: string;
+    assignee?: string;
+    dependencies?: string[];
+}
+/**
+ * Fields that can be updated on an existing task.
+ */
+interface TaskUpdatable {
+    title?: string;
+    description?: string;
+    assignee?: string;
+    status?: TaskStatus;
+    dependencies?: string[];
+}
+/**
+ * Type of an inter-agent message in the mailbox.
+ * Different tools and flows use different types when storing messages.
+ */
+declare enum MessageType {
+    /** One-to-one message (send_message tool) */
+    DIRECT_MESSAGE = "direct_message",
+    /** Message to all teammates (broadcast_message tool) */
+    BROADCAST = "broadcast",
+    /** Teammate submits execution plan to team_lead for approval */
+    PLAN_REQUEST = "plan_request",
+    /** Team_lead approves or rejects plan (feedback to teammate) */
+    PLAN_FEEDBACK = "plan_feedback",
+    /** Team_lead instructs team to shut down (e.g. disband_team) */
+    SHUTDOWN_REQUEST = "shutdown_request",
+    /** Teammate acknowledges shutdown */
+    SHUTDOWN_RESPONSE = "shutdown_response",
+    /** From TaskCompleted/TeammateIdle hook or system: quality issue or continue-work reminder */
+    TASK_FEEDBACK = "task_feedback",
+    /** Idle notification, task status change, or other status update */
+    STATUS_UPDATE = "status_update"
+}
+/**
+ * A message stored in the mailbox.
+ */
+interface MailboxMessage {
+    /** Unique message identifier */
+    id: string;
+    /** Sender agent name */
+    from: string;
+    /** Recipient agent name (or "__broadcast__" for broadcasts) */
+    to: string;
+    /** Message content */
+    content: string;
+    /** When the message was sent */
+    timestamp: Date;
+    /** Message type */
+    type: MessageType;
+    /** Whether the recipient has read this message */
+    read: boolean;
+}
+/**
+ * Specification for a teammate agent.
+ * Configured at team creation time; the `create_team` tool matches teammate
+ * names from the LLM's plan against these specs to get tools/model/prompt.
+ */
+interface TeammateSpec {
+    /** Unique name for this teammate (used as agent ID) */
+    name: string;
+    /** Role category (e.g. "research", "writing", "review") */
+    role: string;
+    /** Human-readable description of what this teammate does */
+    description: string;
+    /** Model override (defaults to team-level model) */
+    model?: LanguageModelLike | string;
+    /** Tools this teammate has access to (in addition to team tools) */
+    tools?: StructuredTool[];
+    /** Custom system prompt for this teammate */
+    systemPrompt?: string;
+    /** Additional middleware for this teammate */
+    middleware?: AgentMiddleware[];
+}
+/**
+ * Configuration for creating an agent team.
+ */
+interface TeamConfig {
+    /** Available teammate specifications (the LLM picks from these by name) */
+    teammates: TeammateSpec[];
+    /** Maximum number of teammates running concurrently (default: teammates.length) */
+    maxConcurrency?: number;
+    /** Model for the team lead agent */
+    model?: LanguageModelLike | string;
+    /** Custom system prompt for the team lead */
+    systemPrompt?: string;
+    /** Tools available to the team lead */
+    tools?: StructuredTool[];
+    /** Checkpointer for persisting agent state between runs */
+    checkpointer?: BaseCheckpointSaver | boolean;
+    /** Pluggable task list store (default: InMemoryTaskListStore) */
+    taskListStore?: TaskListStore;
+    /** Pluggable mailbox store (default: InMemoryMailboxStore) */
+    mailboxStore?: MailboxStore;
+    /** Additional middleware for the team lead agent */
+    middleware?: AgentMiddleware[];
+    /**
+     * Schedule lattice key for polling task list / mailbox.
+     * When set, teammates use scheduled polling instead of event-driven wait.
+     * Requires the app to register the schedule lattice first.
+     */
+    scheduleLatticeKey?: string;
+    /** Poll interval in ms when using schedule lattice (default: 5000) */
+    pollIntervalMs?: number;
+    /** Filesystem backend for sandboxed file operations */
+    backend?: (config: {
+        state: unknown;
+        store?: any;
+    }) => Promise<any>;
+}
+
+/**
+ * InMemoryTaskListStore
+ *
+ * In-memory implementation of TaskListStore.
+ * Tasks are organised by teamId, following the same pattern as
+ * InMemoryThreadStore (Map<teamId, Map<taskId, TeamTask>>).
+ *
+ * Uses an internal EventEmitter so persistent teammates can sleep
+ * until claimable tasks appear instead of busy-polling.
+ */
+
+declare class InMemoryTaskListStore implements TaskListStore {
+    /** Map<teamId, Map<taskId, TeamTask>> */
+    private tasks;
+    /** EventEmitter for task lifecycle events */
+    private emitter;
+    /** Auto-incrementing ID counter */
+    private idCounter;
+    constructor();
+    /** Get or create the task map for a team. */
+    private getTeamTasks;
+    /** Generate a unique task ID. */
+    private nextId;
+    /** Emit a scoped event: `${teamId}:${event}`. */
+    private emit;
+    /**
+     * Resolve dependency references by task IDs.
+     */
+    private resolveDependencies;
+    /**
+     * Check whether all dependencies of a task are in COMPLETED status.
+     */
+    private areDependenciesSatisfied;
+    addTask(teamId: string, spec: TaskSpec): Promise<TeamTask>;
+    addTasks(teamId: string, specs: TaskSpec[]): Promise<TeamTask[]>;
+    updateTask(teamId: string, taskId: string, updates: Partial<TaskUpdatable>): Promise<TeamTask | null>;
+    removeTask(teamId: string, taskId: string): Promise<boolean>;
+    /**
+     * Claim a specific task by ID: set assignee to agentId and status to CLAIMED.
+     * Only succeeds if the task is PENDING and all dependencies are COMPLETED.
+     */
+    claimTaskById(teamId: string, taskId: string, agentId: string): Promise<TeamTask | null>;
+    completeTask(teamId: string, taskId: string, result: string): Promise<TeamTask | null>;
+    failTask(teamId: string, taskId: string, error: string): Promise<TeamTask | null>;
+    getTask(teamId: string, taskId: string): Promise<TeamTask | null>;
+    getTasksByStatus(teamId: string, status: TaskStatus): Promise<TeamTask[]>;
+    getAllTasks(teamId: string): Promise<TeamTask[]>;
+    isAllDone(teamId: string): Promise<boolean>;
+    hasClaimable(teamId: string): Promise<boolean>;
+    onTaskEvent(teamId: string, event: TaskEvent, callback: (task: TeamTask) => void): void;
+    offTaskEvent(teamId: string, event: TaskEvent, callback: (task: TeamTask) => void): void;
+    /** Remove all tasks for a team (useful for cleanup / testing). */
+    clearTeam(teamId: string): void;
+    /** Remove all tasks across all teams (useful for testing). */
+    clear(): void;
+}
+
+/**
+ * InMemoryMailboxStore
+ *
+ * In-memory implementation of MailboxStore.
+ * Messages are organised by teamId -> agentId, following the same
+ * Map nesting pattern as InMemoryThreadStore.
+ *
+ * Uses an internal EventEmitter so agents can be notified of new
+ * messages in real time without polling.
+ */
+
+declare class InMemoryMailboxStore implements MailboxStore {
+    /** Map<teamId, Map<agentId, MailboxMessage[]>> */
+    private messages;
+    /** Map<teamId, Set<agentId>> -- registered agents for broadcast */
+    private agents;
+    /** EventEmitter for real-time message notifications */
+    private emitter;
+    /** Auto-incrementing message ID counter */
+    private idCounter;
+    constructor();
+    /** Get or create the agent message list for a team. */
+    private getAgentMessages;
+    /** Generate a unique message ID. */
+    private nextId;
+    /** Store a message and emit a real-time event for the recipient. */
+    private storeAndNotify;
+    sendMessage(teamId: string, from: string, to: string, content: string, type?: MessageType): Promise<MailboxMessage>;
+    broadcastMessage(teamId: string, from: string, content: string, type?: MessageType): Promise<MailboxMessage[]>;
+    getMessages(teamId: string, agentId: string): Promise<MailboxMessage[]>;
+    getUnreadMessages(teamId: string, agentId: string): Promise<MailboxMessage[]>;
+    markAsRead(teamId: string, agentId: string, messageId: string): Promise<void>;
+    registerAgent(teamId: string, agentId: string): Promise<void>;
+    unregisterAgent(teamId: string, agentId: string): Promise<void>;
+    getRegisteredAgents(teamId: string): Promise<string[]>;
+    onMessage(teamId: string, agentId: string, callback: (msg: MailboxMessage) => void): void;
+    offMessage(teamId: string, agentId: string, callback: (msg: MailboxMessage) => void): void;
+    onTeamMessage(teamId: string, callback: (msg: MailboxMessage) => void): void;
+    offTeamMessage(teamId: string, callback: (msg: MailboxMessage) => void): void;
+    getAllTeamMessages(teamId: string): Promise<MailboxMessage[]>;
+    /** Remove all data for a team (messages + registrations). */
+    clearTeam(teamId: string): void;
+    /** Remove all data across all teams. */
+    clear(): void;
+}
+
+/**
+ * Agent Team - Team Middleware
+ *
+ * createTeamMiddleware() provides the TeamLead agent with tools to
+ * manage a dynamic team:
+ *
+ *   create_team   -- non-blocking: spawn teammates + populate task list
+ *   add_tasks     -- add new tasks at any time (evolutionary)
+ *   assign_task   -- set a task's assignee (reassign to a teammate)
+ *   set_task_status -- set a task's status (pending, claimed, in_progress, completed, failed)
+ *   set_task_dependencies -- set a task's dependency list
+ *   check_tasks   -- get current task list status
+ *   send_message  -- send message to a teammate
+ *   read_messages -- read unread messages from teammates
+ *
+ * Patterns referenced from deep_agent_new/middleware/subagents.ts:
+ *   - createMiddleware() + wrapModelCall for system prompt injection
+ *   - Agent creation via createAgent() from langchain
+ *   - State filtering (filterStateForSubagent logic)
+ *   - ToolMessage returns
+ */
+
+/**
+ * Options for creating the team middleware.
+ */
+interface TeamMiddlewareOptions {
+    /** Team configuration with teammate specs */
+    teamConfig: TeamConfig;
+    /** Task list store instance (shared across all agents) */
+    taskListStore: TaskListStore;
+    /** Mailbox store instance (shared across all agents) */
+    mailboxStore: MailboxStore;
+}
+/**
+ * Create the team middleware that gives the TeamLead agent tools to
+ * manage a dynamic team with shared task list and mailbox.
+ */
+declare function createTeamMiddleware(options: TeamMiddlewareOptions): AgentMiddleware;
+
+/**
+ * Agent Team - Teammate Tools
+ *
+ * Factory that creates LangChain StructuredTools injected into each
+ * teammate agent. These tools let teammates interact with the shared
+ * TaskListStore and MailboxStore.
+ *
+ * Tools: claim_task, complete_task, fail_task, send_message, read_messages
+ */
+
+/**
+ * Options for creating teammate tools.
+ */
+interface TeammateToolsOptions {
+    /** Team identifier (scopes store operations) */
+    teamId: string;
+    /** This teammate's agent name / ID */
+    agentId: string;
+    /** Shared task list store */
+    taskListStore: TaskListStore;
+    /** Shared mailbox store */
+    mailboxStore: MailboxStore;
+}
+/**
+ * Create the set of tools injected into each teammate agent.
+ *
+ * These tools give the teammate access to:
+ * - Task lifecycle: claim_task, complete_task, fail_task
+ * - Communication: send_message, read_messages
+ */
+declare function createTeammateTools(options: TeammateToolsOptions): StructuredTool[];
+
+/**
+ * Agent Graph Builder 接口
+ *
+ * 策略模式的核心接口，定义了构建Agent Graph的方法
+ */
+
+interface AgentGraphBuilder {
+    /**
+     * 构建Agent Graph
+     *
+     * @param agentLattice Agent Lattice对象
+     * @param params Agent构建参数
+     * @returns 返回CompiledGraph对象
+     */
+    build(agentLattice: AgentLattice, params: AgentBuildParams): AgentClient;
+}
+
+/**
+ * Team Agent Graph Builder
+ *
+ * Implements AgentGraphBuilder for AgentType.TEAM.
+ * Bridges the AgentConfig registration system with createAgentTeam(),
+ * resolving tool keys and model keys into concrete instances.
+ */
+
+declare class TeamAgentGraphBuilder implements AgentGraphBuilder {
+    /**
+     * Build a Team agent from the registered AgentLattice config.
+     *
+     * @param agentLattice - The AgentLattice containing the TeamAgentConfig
+     * @param params - Build params with resolved tools and model
+     * @returns AgentClient (the TeamLead ReactAgent)
+     */
+    build(agentLattice: AgentLattice, params: AgentBuildParams): AgentClient;
+}
+
+/**
+ * Agent Team - High-level Facade
+ *
+ * createAgentTeam() wires together the TaskListStore, MailboxStore,
+ * and team middleware to produce a ready-to-use TeamLead ReactAgent.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * import { createAgentTeam } from "@axiom-lattice/core";
+ *
+ * const team = createAgentTeam({
+ *   teammates: [
+ *     { name: "researcher", role: "research", description: "Web research", tools: [searchTool] },
+ *     { name: "writer", role: "writing", description: "Report writing", tools: [writeTool] },
+ *   ],
+ *   maxConcurrency: 3,
+ * });
+ *
+ * await team.invoke({
+ *   messages: [{ role: "human", content: "Research and write a report on X" }],
+ * });
+ * ```
+ */
+
+/**
+ * Create an agent team: a TeamLead ReactAgent backed by shared
+ * TaskListStore and MailboxStore with pre-configured teammates.
+ *
+ * @param config - Team configuration (teammates, model, stores, etc.)
+ * @returns A ReactAgent that acts as the TeamLead
+ */
+declare function createAgentTeam(config: TeamConfig): ReactAgent<any, any, any, any>;
+
+/**
+ * Protocol definition for pluggable memory backends.
+ *
+ * This module defines the BackendProtocol that all backend implementations
+ * must follow. Backends can store files in different locations (state, filesystem,
+ * database, etc.) and provide a uniform interface for file operations.
+ */
+
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Structured file listing info.
+ *
+ * Minimal contract used across backends. Only "path" is required.
+ * Other fields are best-effort and may be absent depending on backend.
+ */
+interface FileInfo {
+    /** File path */
+    path: string;
+    /** Whether this is a directory */
+    is_dir?: boolean;
+    /** File size in bytes (approximate) */
+    size?: number;
+    /** ISO 8601 timestamp of last modification */
+    modified_at?: string;
+}
+/**
+ * Structured grep match entry.
+ */
+interface GrepMatch {
+    /** File path where match was found */
+    path: string;
+    /** Line number (1-indexed) */
+    line: number;
+    /** The matching line text */
+    text: string;
+}
+/**
+ * File data structure used by backends.
+ *
+ * All file data is represented as objects with this structure:
+ */
+interface FileData {
+    /** Lines of text content */
+    content: string[];
+    /** ISO format timestamp of creation */
+    created_at: string;
+    /** ISO format timestamp of last modification */
+    modified_at: string;
+}
+/**
+ * Result from backend write operations.
+ *
+ * Checkpoint backends populate filesUpdate with {file_path: file_data} for LangGraph state.
+ * External backends set filesUpdate to null (already persisted to disk/S3/database/etc).
+ */
+interface WriteResult {
+    /** Error message on failure, undefined on success */
+    error?: string;
+    /** File path of written file, undefined on failure */
+    path?: string;
+    /**
+     * State update dict for checkpoint backends, null for external storage.
+     * Checkpoint backends populate this with {file_path: file_data} for LangGraph state.
+     * External backends set null (already persisted to disk/S3/database/etc).
+     */
+    filesUpdate?: Record<string, FileData> | null;
+    /** Metadata for the write operation, attached to the ToolMessage */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result from backend edit operations.
+ *
+ * Checkpoint backends populate filesUpdate with {file_path: file_data} for LangGraph state.
+ * External backends set filesUpdate to null (already persisted to disk/S3/database/etc).
+ */
+interface EditResult {
+    /** Error message on failure, undefined on success */
+    error?: string;
+    /** File path of edited file, undefined on failure */
+    path?: string;
+    /**
+     * State update dict for checkpoint backends, null for external storage.
+     * Checkpoint backends populate this with {file_path: file_data} for LangGraph state.
+     * External backends set null (already persisted to disk/S3/database/etc).
+     */
+    filesUpdate?: Record<string, FileData> | null;
+    /** Number of replacements made, undefined on failure */
+    occurrences?: number;
+    /** Metadata for the edit operation, attached to the ToolMessage */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Protocol for pluggable memory backends (single, unified).
+ *
+ * Backends can store files in different locations (state, filesystem, database, etc.)
+ * and provide a uniform interface for file operations.
+ *
+ * All file data is represented as objects with the FileData structure.
+ *
+ * Methods can return either direct values or Promises, allowing both
+ * synchronous and asynchronous implementations.
+ */
+interface BackendProtocol {
+    /**
+     * Structured listing with file metadata.
+     *
+     * Lists files and directories in the specified directory (non-recursive).
+     * Directories have a trailing / in their path and is_dir=true.
+     *
+     * @param path - Absolute path to directory
+     * @returns List of FileInfo objects for files and directories directly in the directory
+     */
+    lsInfo(path: string): MaybePromise<FileInfo[]>;
+    /**
+     * Read file content with line numbers or an error string.
+     *
+     * @param filePath - Absolute file path
+     * @param offset - Line offset to start reading from (0-indexed), default 0
+     * @param limit - Maximum number of lines to read, default 2000
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): MaybePromise<string>;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Absolute file path
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): MaybePromise<FileData>;
+    /**
+     * Structured search results or error string for invalid input.
+     *
+     * Searches file contents for a regex pattern.
+     *
+     * @param pattern - Regex pattern to search for
+     * @param path - Base path to search from (default: null)
+     * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+     * @returns List of GrepMatch objects or error string for invalid regex
+     */
+    grepRaw(pattern: string, path?: string | null, glob?: string | null): MaybePromise<GrepMatch[] | string>;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     *
+     * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+     * @param path - Base path to search from (default: "/")
+     * @returns List of FileInfo objects matching the pattern
+     */
+    globInfo(pattern: string, path?: string): MaybePromise<FileInfo[]>;
+    /**
+     * Create a new file.
+     *
+     * @param filePath - Absolute file path
+     * @param content - File content as string
+     * @returns WriteResult with error populated on failure
+     */
+    write(filePath: string, content: string): MaybePromise<WriteResult>;
+    /**
+     * Edit a file by replacing string occurrences.
+     *
+     * @param filePath - Absolute file path
+     * @param oldString - String to find and replace
+     * @param newString - Replacement string
+     * @param replaceAll - If true, replace all occurrences (default: false)
+     * @returns EditResult with error, path, filesUpdate, and occurrences
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): MaybePromise<EditResult>;
+}
+/**
+ * State and store container for backend initialization.
+ *
+ * This provides a clean interface for what backends need to access:
+ * - state: Current agent state (with files, messages, etc.)
+ * - store: Optional persistent store for cross-conversation data
+ *
+ * Different contexts build this differently:
+ * - Tools: Extract state via getCurrentTaskInput(config)
+ * - Middleware: Use request.state directly
+ */
+interface StateAndStore {
+    /** Current agent state with files, messages, etc. */
+    state: unknown;
+    /** Optional BaseStore for persistent cross-conversation storage */
+    store?: BaseStore;
+    /** Optional assistant ID for per-assistant isolation in store */
+    assistantId?: string;
+    threadId?: string;
+    workspaceId?: string;
+    projectId?: string;
+}
+/**
+ * Factory function type for creating backend instances.
+ *
+ * Backends receive StateAndStore which contains the current state
+ * and optional store, extracted from the execution context.
+ *
+ * @example
+ * ```typescript
+ * // Using in middleware
+ * const middleware = createFilesystemMiddleware({
+ *   backend: (stateAndStore) => new StateBackend(stateAndStore)
+ * });
+ * ```
+ */
+type BackendFactory = (stateAndStore: StateAndStore) => Promise<BackendProtocol>;
+
+/**
+ * StateBackend: Store files in LangGraph agent state (ephemeral).
+ */
+
+/**
+ * Backend that stores files in agent state (ephemeral).
+ *
+ * Uses LangGraph's state management and checkpointing. Files persist within
+ * a conversation thread but not across threads. State is automatically
+ * checkpointed after each agent step.
+ *
+ * Special handling: Since LangGraph state must be updated via Command objects
+ * (not direct mutation), operations return filesUpdate in WriteResult/EditResult
+ * for the middleware to apply via Command.
+ */
+declare class StateBackend implements BackendProtocol {
+    private stateAndStore;
+    constructor(stateAndStore: StateAndStore);
+    /**
+     * Get files from current state.
+     */
+    private getFiles;
+    /**
+     * List files and directories in the specified directory (non-recursive).
+     *
+     * @param path - Absolute path to directory
+     * @returns List of FileInfo objects for files and directories directly in the directory.
+     *          Directories have a trailing / in their path and is_dir=true.
+     */
+    lsInfo(path: string): FileInfo[];
+    /**
+     * Read file content with line numbers.
+     *
+     * @param filePath - Absolute file path
+     * @param offset - Line offset to start reading from (0-indexed)
+     * @param limit - Maximum number of lines to read
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): string;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Absolute file path
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): FileData;
+    /**
+     * Create a new file with content.
+     * Returns WriteResult with filesUpdate to update LangGraph state.
+     */
+    write(filePath: string, content: string): WriteResult;
+    /**
+     * Edit a file by replacing string occurrences.
+     * Returns EditResult with filesUpdate and occurrences.
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): EditResult;
+    /**
+     * Structured search results or error string for invalid input.
+     */
+    grepRaw(pattern: string, path?: string, glob?: string | null): GrepMatch[] | string;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     */
+    globInfo(pattern: string, path?: string): FileInfo[];
+}
+
+/**
+ * StoreBackend: Adapter for LangGraph's BaseStore (persistent, cross-thread).
+ */
+
+/**
+ * Backend that stores files in LangGraph's BaseStore (persistent).
+ *
+ * Uses LangGraph's Store for persistent, cross-conversation storage.
+ * Files are organized via namespaces and persist across all threads.
+ *
+ * The namespace can include an optional assistant_id for multi-agent isolation.
+ */
+declare class StoreBackend implements BackendProtocol {
+    private stateAndStore;
+    constructor(stateAndStore: StateAndStore);
+    /**
+     * Get the store instance.
+     *
+     * @returns BaseStore instance
+     * @throws Error if no store is available
+     */
+    private getStore;
+    /**
+     * Get the namespace for store operations.
+     *
+     * If an assistant_id is available in stateAndStore, return
+     * [assistant_id, "filesystem"] to provide per-assistant isolation.
+     * Otherwise return ["filesystem"].
+     */
+    protected getNamespace(): string[];
+    /**
+     * Convert a store Item to FileData format.
+     *
+     * @param storeItem - The store Item containing file data
+     * @returns FileData object
+     * @throws Error if required fields are missing or have incorrect types
+     */
+    private convertStoreItemToFileData;
+    /**
+     * Convert FileData to a value suitable for store.put().
+     *
+     * @param fileData - The FileData to convert
+     * @returns Object with content, created_at, and modified_at fields
+     */
+    private convertFileDataToStoreValue;
+    /**
+     * Search store with automatic pagination to retrieve all results.
+     *
+     * @param store - The store to search
+     * @param namespace - Hierarchical path prefix to search within
+     * @param options - Optional query, filter, and page_size
+     * @returns List of all items matching the search criteria
+     */
+    private searchStorePaginated;
+    /**
+     * List files and directories in the specified directory (non-recursive).
+     *
+     * @param path - Absolute path to directory
+     * @returns List of FileInfo objects for files and directories directly in the directory.
+     *          Directories have a trailing / in their path and is_dir=true.
+     */
+    lsInfo(path: string): Promise<FileInfo[]>;
+    /**
+     * Read file content with line numbers.
+     *
+     * @param filePath - Absolute file path
+     * @param offset - Line offset to start reading from (0-indexed)
+     * @param limit - Maximum number of lines to read
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): Promise<string>;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Absolute file path
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): Promise<FileData>;
+    /**
+     * Create a new file with content.
+     * Returns WriteResult. External storage sets filesUpdate=null.
+     */
+    write(filePath: string, content: string): Promise<WriteResult>;
+    /**
+     * Edit a file by replacing string occurrences.
+     * Returns EditResult. External storage sets filesUpdate=null.
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+    /**
+     * Structured search results or error string for invalid input.
+     */
+    grepRaw(pattern: string, path?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     */
+    globInfo(pattern: string, path?: string): Promise<FileInfo[]>;
+}
+
+/**
+ * FilesystemBackend: Read and write files directly from the filesystem.
+ *
+ * Security and search upgrades:
+ * - Secure path resolution with root containment when in virtual_mode (sandboxed to cwd)
+ * - Prevent symlink-following on file I/O using O_NOFOLLOW when available
+ * - Ripgrep-powered grep with JSON parsing, plus regex fallback
+ *   and optional glob include filtering, while preserving virtual path behavior
+ */
+
+/**
+ * Backend that reads and writes files directly from the filesystem.
+ *
+ * Files are accessed using their actual filesystem paths. Relative paths are
+ * resolved relative to the current working directory. Content is read/written
+ * as plain text, and metadata (timestamps) are derived from filesystem stats.
+ */
+declare class FilesystemBackend implements BackendProtocol {
+    private cwd;
+    private virtualMode;
+    private maxFileSizeBytes;
+    constructor(options?: {
+        rootDir?: string;
+        virtualMode?: boolean;
+        maxFileSizeMb?: number;
+    });
+    /**
+     * Resolve a file path with security checks.
+     *
+     * When virtualMode=true, treat incoming paths as virtual absolute paths under
+     * this.cwd, disallow traversal (.., ~) and ensure resolved path stays within root.
+     * When virtualMode=false, preserve legacy behavior: absolute paths are allowed
+     * as-is; relative paths resolve under cwd.
+     *
+     * @param key - File path (absolute, relative, or virtual when virtualMode=true)
+     * @returns Resolved absolute path string
+     * @throws Error if path traversal detected or path outside root
+     */
+    private resolvePath;
+    /**
+     * List files and directories in the specified directory (non-recursive).
+     *
+     * @param dirPath - Absolute directory path to list files from
+     * @returns List of FileInfo objects for files and directories directly in the directory.
+     *          Directories have a trailing / in their path and is_dir=true.
+     */
+    lsInfo(dirPath: string): Promise<FileInfo[]>;
+    /**
+     * Read file content with line numbers.
+     *
+     * @param filePath - Absolute or relative file path
+     * @param offset - Line offset to start reading from (0-indexed)
+     * @param limit - Maximum number of lines to read
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): Promise<string>;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Absolute file path
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): Promise<FileData>;
+    /**
+     * Create a new file with content.
+     * Returns WriteResult. External storage sets filesUpdate=null.
+     */
+    write(filePath: string, content: string): Promise<WriteResult>;
+    /**
+     * Edit a file by replacing string occurrences.
+     * Returns EditResult. External storage sets filesUpdate=null.
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+    /**
+     * Structured search results or error string for invalid input.
+     */
+    grepRaw(pattern: string, dirPath?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+    /**
+     * Try to use ripgrep for fast searching.
+     * Returns null if ripgrep is not available or fails.
+     */
+    private ripgrepSearch;
+    /**
+     * Fallback regex search implementation.
+     */
+    private pythonSearch;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     */
+    globInfo(pattern: string, searchPath?: string): Promise<FileInfo[]>;
+}
+
+/**
+ * CompositeBackend: Route operations to different backends based on path prefix.
+ */
+
+/**
+ * Backend that routes file operations to different backends based on path prefix.
+ *
+ * This enables hybrid storage strategies like:
+ * - `/memories/` → StoreBackend (persistent, cross-thread)
+ * - Everything else → StateBackend (ephemeral, per-thread)
+ *
+ * The CompositeBackend handles path prefix stripping/re-adding transparently.
+ */
+declare class CompositeBackend implements BackendProtocol {
+    private default;
+    private routes;
+    private sortedRoutes;
+    constructor(defaultBackend: BackendProtocol, routes: Record<string, BackendProtocol>);
+    /**
+     * Determine which backend handles this key and strip prefix.
+     *
+     * @param key - Original file path
+     * @returns Tuple of [backend, stripped_key] where stripped_key has the route
+     *          prefix removed (but keeps leading slash).
+     */
+    private getBackendAndKey;
+    /**
+     * List files and directories in the specified directory (non-recursive).
+     *
+     * @param path - Absolute path to directory
+     * @returns List of FileInfo objects with route prefixes added, for files and directories
+     *          directly in the directory. Directories have a trailing / in their path and is_dir=true.
+     */
+    lsInfo(path: string): Promise<FileInfo[]>;
+    /**
+     * Read file content, routing to appropriate backend.
+     *
+     * @param filePath - Absolute file path
+     * @param offset - Line offset to start reading from (0-indexed)
+     * @param limit - Maximum number of lines to read
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): Promise<string>;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Absolute file path
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): Promise<FileData>;
+    /**
+     * Structured search results or error string for invalid input.
+     */
+    grepRaw(pattern: string, path?: string, glob?: string | null): Promise<GrepMatch[] | string>;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     */
+    globInfo(pattern: string, path?: string): Promise<FileInfo[]>;
+    /**
+     * Create a new file, routing to appropriate backend.
+     *
+     * @param filePath - Absolute file path
+     * @param content - File content as string
+     * @returns WriteResult with path or error
+     */
+    write(filePath: string, content: string): Promise<WriteResult>;
+    /**
+     * Edit a file, routing to appropriate backend.
+     *
+     * @param filePath - Absolute file path
+     * @param oldString - String to find and replace
+     * @param newString - Replacement string
+     * @param replaceAll - If true, replace all occurrences
+     * @returns EditResult with path, occurrences, or error
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+}
+
+/**
+ * MemoryBackend: In-memory file storage backend.
+ *
+ * Stores files in a shared Map instance. Useful for sharing file state
+ * across multiple agents within the same process (e.g., team members).
+ *
+ * All operations are synchronous and use in-memory storage.
+ */
+
+declare class MemoryBackend implements BackendProtocol {
+    private files;
+    constructor(files?: Map<string, FileData>);
+    private getFiles;
+    lsInfo(path: string): FileInfo[];
+    read(filePath: string, offset?: number, limit?: number): string;
+    readRaw(filePath: string): FileData;
+    write(filePath: string, content: string): WriteResult;
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): EditResult;
+    grepRaw(pattern: string, path?: string, glob?: string | null): GrepMatch[] | string;
+    globInfo(pattern: string, path?: string): FileInfo[];
+}
+
+/**
+ * SandboxFilesystem: A sandboxed filesystem backend that connects to a remote sandbox via SDK.
+ *
+ * This backend provides a secure, isolated filesystem environment by connecting to a remote
+ * sandbox service through the @agent-infra/sandbox SDK. It implements the BackendProtocol
+ * interface and delegates all file operations to the remote sandbox.
+ *
+ * Features:
+ * - Remote sandbox connection via HTTP API
+ * - Virtual path support (all paths start with /)
+ * - Path traversal prevention
+ * - Full BackendProtocol implementation
+ */
+
+/**
+ * Sandboxed filesystem backend that connects to a remote sandbox service.
+ *
+ * All file operations are delegated to the remote sandbox via the SDK.
+ * Paths are treated as virtual absolute paths (starting with /).
+ */
+declare class SandboxFilesystem implements BackendProtocol {
+    private sandbox;
+    private maxFileSizeBytes;
+    private workingDirectory;
+    private baseURL;
+    private homeDir;
+    /**
+     * Create a new SandboxFilesystem instance.
+     *
+     * @param options - Configuration options
+     * @param options.baseURL - Base URL of the sandbox service (default: 'http://localhost:8080')
+     * @param options.maxFileSizeMb - Maximum file size in MB (default: 10)
+     * @param options.sandboxInstance - Optional Sandbox instance (if provided, baseURL is ignored)
+     */
+    constructor(options?: {
+        baseURL?: string;
+        workingDirectory?: string;
+        maxFileSizeMb?: number;
+        sandboxInstance?: SandboxClient;
+    });
+    private resolvePath;
+    /**
+     * Convert a real filesystem path to a virtual path.
+     *
+     * @param realPath - Real filesystem path
+     * @returns Virtual path starting with /
+     */
+    private toVirtualPath;
+    /**
+     * List files and directories in the specified directory (non-recursive).
+     *
+     * @param dirPath - Virtual directory path (must start with /)
+     * @returns List of FileInfo objects for files and directories directly in the directory.
+     *          Directories have a trailing / in their path and is_dir=true.
+     */
+    lsInfo(dirPath: string): Promise<FileInfo[]>;
+    /**
+     * Read file content with line numbers.
+     *
+     * @param filePath - Virtual file path (must start with /)
+     * @param offset - Line offset to start reading from (0-indexed)
+     * @param limit - Maximum number of lines to read
+     * @returns Formatted file content with line numbers, or error message
+     */
+    read(filePath: string, offset?: number, limit?: number): Promise<string>;
+    /**
+     * Read file content as raw FileData.
+     *
+     * @param filePath - Virtual file path (must start with /)
+     * @returns Raw file content as FileData
+     */
+    readRaw(filePath: string): Promise<FileData>;
+    /**
+     * Create a new file with content.
+     * Returns WriteResult. External storage sets filesUpdate=null.
+     *
+     * @param filePath - Virtual file path (must start with /)
+     * @param content - File content as string
+     * @returns WriteResult with error populated on failure
+     */
+    write(filePath: string, content: string): Promise<WriteResult>;
+    /**
+     * Edit a file by replacing string occurrences.
+     * Returns EditResult. External storage sets filesUpdate=null.
+     *
+     * @param filePath - Virtual file path (must start with /)
+     * @param oldString - String to find and replace
+     * @param newString - Replacement string
+     * @param replaceAll - If true, replace all occurrences (default: false)
+     * @returns EditResult with error, path, filesUpdate, and occurrences
+     */
+    edit(filePath: string, oldString: string, newString: string, replaceAll?: boolean): Promise<EditResult>;
+    /**
+     * Structured search results or error string for invalid input.
+     *
+     * Searches file contents for a regex pattern within the sandbox.
+     *
+     * @param pattern - Regex pattern to search for
+     * @param searchPath - Base path to search from (default: "/")
+     * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+     * @returns List of GrepMatch objects or error string for invalid regex
+     */
+    grepRaw(pattern: string, searchPath?: string | null, glob?: string | null): Promise<GrepMatch[] | string>;
+    /**
+     * Structured glob matching returning FileInfo objects.
+     *
+     * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+     * @param searchPath - Base path to search from (default: "/")
+     * @returns List of FileInfo objects matching the pattern
+     */
+    globInfo(pattern: string, searchPath?: string): Promise<FileInfo[]>;
+}
+
+/**
+ * Shared utility functions for memory backend implementations.
+ *
+ * This module contains both user-facing string formatters and structured
+ * helpers used by backends and the composite router. Structured helpers
+ * enable composition without fragile string parsing.
+ */
+
+declare const EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents";
+declare const MAX_LINE_LENGTH = 10000;
+declare const LINE_NUMBER_WIDTH = 6;
+declare const TOOL_RESULT_TOKEN_LIMIT = 20000;
+declare const TRUNCATION_GUIDANCE = "... [results truncated, try being more specific with your parameters]";
+/**
+ * Sanitize tool_call_id to prevent path traversal and separator issues.
+ *
+ * Replaces dangerous characters (., /, \) with underscores.
+ */
+declare function sanitizeToolCallId(toolCallId: string): string;
+/**
+ * Format file content with line numbers (cat -n style).
+ *
+ * Chunks lines longer than MAX_LINE_LENGTH with continuation markers (e.g., 5.1, 5.2).
+ *
+ * @param content - File content as string or list of lines
+ * @param startLine - Starting line number (default: 1)
+ * @returns Formatted content with line numbers and continuation markers
+ */
+declare function formatContentWithLineNumbers(content: string | string[], startLine?: number): string;
+/**
+ * Check if content is empty and return warning message.
+ *
+ * @param content - Content to check
+ * @returns Warning message if empty, null otherwise
+ */
+declare function checkEmptyContent(content: string): string | null;
+/**
+ * Convert FileData to plain string content.
+ *
+ * @param fileData - FileData object with 'content' key
+ * @returns Content as string with lines joined by newlines
+ */
+declare function fileDataToString(fileData: FileData): string;
+/**
+ * Create a FileData object with timestamps.
+ *
+ * @param content - File content as string
+ * @param createdAt - Optional creation timestamp (ISO format)
+ * @returns FileData object with content and timestamps
+ */
+declare function createFileData(content: string, createdAt?: string): FileData;
+/**
+ * Update FileData with new content, preserving creation timestamp.
+ *
+ * @param fileData - Existing FileData object
+ * @param content - New content as string
+ * @returns Updated FileData object
+ */
+declare function updateFileData(fileData: FileData, content: string): FileData;
+/**
+ * Format file data for read response with line numbers.
+ *
+ * @param fileData - FileData object
+ * @param offset - Line offset (0-indexed)
+ * @param limit - Maximum number of lines
+ * @returns Formatted content or error message
+ */
+declare function formatReadResponse(fileData: FileData, offset: number, limit: number): string;
+/**
+ * Perform string replacement with occurrence validation.
+ *
+ * @param content - Original content
+ * @param oldString - String to replace
+ * @param newString - Replacement string
+ * @param replaceAll - Whether to replace all occurrences
+ * @returns Tuple of [new_content, occurrences] on success, or error message string
+ */
+declare function performStringReplacement(content: string, oldString: string, newString: string, replaceAll: boolean): [string, number] | string;
+/**
+ * Truncate list or string result if it exceeds token limit (rough estimate: 4 chars/token).
+ */
+declare function truncateIfTooLong(result: string[] | string): string[] | string;
+/**
+ * Validate and normalize a path.
+ *
+ * @param path - Path to validate
+ * @returns Normalized path starting with / and ending with /
+ * @throws Error if path is invalid
+ */
+declare function validatePath(path: string | null | undefined): string;
+/**
+ * Search files dict for paths matching glob pattern.
+ *
+ * @param files - Dictionary of file paths to FileData
+ * @param pattern - Glob pattern (e.g., `*.py`, `**\/*.ts`)
+ * @param path - Base path to search from
+ * @returns Newline-separated file paths, sorted by modification time (most recent first).
+ *          Returns "No files found" if no matches.
+ *
+ * @example
+ * ```typescript
+ * const files = {"/src/main.py": FileData(...), "/test.py": FileData(...)};
+ * globSearchFiles(files, "*.py", "/");
+ * // Returns: "/test.py\n/src/main.py" (sorted by modified_at)
+ * ```
+ */
+declare function globSearchFiles(files: Record<string, FileData>, pattern: string, path?: string): string;
+/**
+ * Format grep search results based on output mode.
+ *
+ * @param results - Dictionary mapping file paths to list of [line_num, line_content] tuples
+ * @param outputMode - Output format - "files_with_matches", "content", or "count"
+ * @returns Formatted string output
+ */
+declare function formatGrepResults(results: Record<string, Array<[number, string]>>, outputMode: "files_with_matches" | "content" | "count"): string;
+/**
+ * Search file contents for regex pattern.
+ *
+ * @param files - Dictionary of file paths to FileData
+ * @param pattern - Regex pattern to search for
+ * @param path - Base path to search from
+ * @param glob - Optional glob pattern to filter files (e.g., "*.py")
+ * @param outputMode - Output format - "files_with_matches", "content", or "count"
+ * @returns Formatted search results. Returns "No matches found" if no results.
+ *
+ * @example
+ * ```typescript
+ * const files = {"/file.py": FileData({content: ["import os", "print('hi')"], ...})};
+ * grepSearchFiles(files, "import", "/");
+ * // Returns: "/file.py" (with output_mode="files_with_matches")
+ * ```
+ */
+declare function grepSearchFiles(files: Record<string, FileData>, pattern: string, path?: string | null, glob?: string | null, outputMode?: "files_with_matches" | "content" | "count"): string;
+/**
+ * Return structured grep matches from an in-memory files mapping.
+ *
+ * Returns a list of GrepMatch on success, or a string for invalid inputs
+ * (e.g., invalid regex). We deliberately do not raise here to keep backends
+ * non-throwing in tool contexts and preserve user-facing error messages.
+ */
+declare function grepMatchesFromFiles(files: Record<string, FileData>, pattern: string, path?: string | null, glob?: string | null): GrepMatch[] | string;
+/**
+ * Group structured matches into the legacy dict form used by formatters.
+ */
+declare function buildGrepResultsDict(matches: GrepMatch[]): Record<string, Array<[number, string]>>;
+/**
+ * Format structured grep matches using existing formatting logic.
+ */
+declare function formatGrepMatches(matches: GrepMatch[], outputMode: "files_with_matches" | "content" | "count"): string;
+
+/**
+ * Event bus service
+ * Used for event publishing and subscription between internal system components
+ */
+declare class EventBus {
+    private emitter;
+    private defaultQueueKey;
+    constructor();
+    /**
+     * Set the default queue key for queue operations
+     * @param queueKey Queue key name
+     */
+    setDefaultQueueKey(queueKey: string): void;
+    /**
+     * Publish event
      * @param eventName Event name
      * @param data Event data
      * @param useQueue Whether to use queue for publishing
@@ -2163,4 +4284,47 @@ declare class AgentManager {
 
 declare const AGENT_TASK_EVENT = "agent:execute";
 
-export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, ConsoleLoggerClient, type CronFields, type DatabaseConfig, type DatabaseType, DefaultScheduleClient, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, FileSystemSkillStore, type FileSystemSkillStoreOptions, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryThreadStore, type IsolatedLevel, type LoggerLattice, LoggerLatticeManager, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, PinoLoggerClient, PostgresDatabase, type QueryResult, type QueueLattice, QueueLatticeManager, type RunSandboxConfig, SandboxLatticeManager, type SandboxManagerProtocol, type ScheduleLattice, ScheduleLatticeManager, type SkillLattice, SkillLatticeManager, SqlDatabaseManager, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, type TableInfo, type TableSchema, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, type VectorStoreLatticeInterface, VectorStoreLatticeManager, agentLatticeManager, createInfoSqlTool, createListTablesSqlTool, createQueryCheckerSqlTool, createQuerySqlTool, describeCronExpression, embeddingsLatticeManager, eventBus, eventBus as eventBusDefault, getAgentClient, getAgentConfig, getAgentLattice, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, hasChunkBuffer, isValidCronExpression, isValidSandboxName, isValidSkillName, loggerLatticeManager, mcpManager, modelLatticeManager, normalizeSandboxName, parseCronExpression, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerToolLattice, registerVectorStoreLattice, sandboxLatticeManager, scheduleLatticeManager, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, validateAgentInput, validateSkillName, validateToolInput, vectorStoreLatticeManager };
+/**
+ * 全局加密工具
+ * 用于敏感数据加密存储（如数据库密码、API 密钥等）
+ *
+ * @module @axiom-lattice/core/util/encryption
+ */
+/**
+ * 获取加密密钥
+ * 优先从环境变量读取，否则使用默认值
+ * @returns 32 字节的 Buffer 密钥
+ */
+declare function getEncryptionKey(): Buffer;
+/**
+ * 加密字符串
+ * @param plaintext 明文字符串
+ * @param key 可选的加密密钥，默认使用全局密钥
+ * @returns 加密后的字符串 (salt:iv:ciphertext:authTag 的 base64 编码)
+ */
+declare function encrypt(plaintext: string, key?: Buffer): string;
+/**
+ * 解密字符串
+ * @param encrypted 加密的字符串 (base64 编码)
+ * @param key 可选的解密密钥，默认使用全局密钥
+ * @returns 解密后的明文
+ * @throws 如果解密失败（密钥错误或数据损坏）
+ */
+declare function decrypt(encrypted: string, key?: Buffer): string;
+/**
+ * 检查是否使用默认密钥
+ * @returns 如果使用默认密钥返回 true
+ */
+declare function isUsingDefaultKey(): boolean;
+/**
+ * 验证加密密钥
+ * 生产环境未设置 LATTICE_ENCRYPTION_KEY 时会抛出错误
+ * 开发环境仅输出警告
+ */
+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, 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 };