@axiom-lattice/core 2.1.47 → 2.1.49

package/dist/index.d.ts

@@ -8,13 +8,12 @@ import { BaseLanguageModelInput, LanguageModelLike } from '@langchain/core/langu
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { ChatResult } from '@langchain/core/outputs';
 import * as _axiom_lattice_protocols from '@axiom-lattice/protocols';
-import { LLMConfig, SemanticMetricsServerConfig, MetricMeta, MetricQueryResult, DataSource, SemanticMetricsQueryRequest, SemanticMetricsQueryResponse, TableQueryRequest, TableQueryResponse, ExecuteSqlQueryRequest, ExecuteSqlQueryResponse, MetricsServerType, MetricsServerConfig, ToolConfig, ToolExecutor, AgentConfig, MiddlewareType, GraphBuildOptions, MessageChunk, MessageChunkType, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, SkillStore, WorkspaceStore, ProjectStore, DatabaseConfigStore, MetricsServerConfigStore, McpServerConfigStore, 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';
+import { LLMConfig, SemanticMetricsServerConfig, MetricMeta, MetricQueryResult, DataSource, SemanticMetricsQueryRequest, SemanticMetricsQueryResponse, TableQueryRequest, TableQueryResponse, ExecuteSqlQueryRequest, ExecuteSqlQueryResponse, MetricsServerType, MetricsServerConfig, ToolConfig, ToolExecutor, AgentConfig, MiddlewareType, GraphBuildOptions, MessageChunk, MessageChunkType, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, SkillStore, WorkspaceStore, ProjectStore, DatabaseConfigStore, MetricsServerConfigStore, McpServerConfigStore, UserStore, TenantStore, UserTenantLinkStore, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest, Skill, CreateSkillRequest, SkillStoreContext, 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, 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 * as _langchain_langgraph from '@langchain/langgraph';
@@ -24,6 +23,10 @@ import { ReplaySubject } from 'rxjs';
 import { Embeddings } from '@langchain/core/embeddings';
 import { VectorStore } from '@langchain/core/vectorstores';
 import { Connection, MultiServerMCPClient } from '@langchain/mcp-adapters';
+import { Sandbox } from 'microsandbox';
+import { SandboxClient } from '@agent-infra/sandbox';
+import { Sandbox as Sandbox$1 } from 'e2b';
+import { Sandbox as Sandbox$2 } from '@daytonaio/sdk';
 
 /**
  * BaseLatticeManager - 抽象基类，为各种Lattice管理器提供通用功能
@@ -1262,20 +1265,97 @@ declare const createExecuteSqlQueryTool: ({ serverKeys, serverDescriptions, getT
     datasourceId?: string | undefined;
 }, string, "execute_sql_query">;
 
-interface SandboxManagerProtocol {
-    getBaseURL(): string;
-    createSandbox(sandboxName: string): Promise<SandboxClient>;
-    deleteSandbox(sandboxName: string): Promise<void>;
-    getSandbox(sandboxName: string): Promise<SandboxClient>;
-    listSandboxes(): Promise<SandboxClient[]>;
-    getSandboxStatus(sandboxName: string): Promise<string>;
-    getSandboxFromConfig(config: RunSandboxConfig): Promise<SandboxClient>;
-}
-type IsolatedLevel = "agent" | "thread" | "global";
+interface SandboxFileInfo {
+    path: string;
+    is_dir: boolean;
+    size?: number;
+    modified_at?: string;
+}
+interface SandboxFileService {
+    readFile(file: string): Promise<{
+        content: string;
+    }>;
+    writeFile(file: string, content: string): Promise<void>;
+    listPath(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<{
+        files: SandboxFileInfo[];
+    }>;
+    findFiles(path: string, glob: string): Promise<{
+        files: string[];
+    }>;
+    searchInFile(file: string, regex: string): Promise<{
+        matches: string[];
+        line_numbers: number[];
+    }>;
+    strReplaceEditor(params: {
+        command: "str_replace";
+        path: string;
+        old_str: string;
+        new_str: string;
+        replace_mode: "FIRST" | "ALL";
+    }): Promise<void>;
+    uploadFile(params: {
+        file: string;
+        data: Buffer;
+        encoding?: string;
+    }): Promise<void>;
+    downloadFile(params: {
+        file: string;
+    }): Promise<Buffer>;
+}
+interface SandboxShellService {
+    execCommand(params: {
+        command: string;
+        exec_dir?: string;
+        timeout?: number;
+    }): Promise<{
+        output: string;
+        exit_code: number;
+    }>;
+}
+interface SandboxInstance {
+    readonly name: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+type SandboxIsolationLevel = "global" | "agent" | "project";
+type SandboxVolumeDefinition = {
+    type: "bind";
+    source: string;
+    readonly?: boolean;
+} | {
+    type: "named";
+    name: string;
+    readonly?: boolean;
+} | {
+    type: "tmpfs";
+    sizeMib?: number;
+};
 interface RunSandboxConfig {
     assistant_id: string;
-    isolatedLevel: IsolatedLevel;
     thread_id: string;
+    tenantId?: string;
+    workspaceId?: string;
+    projectId?: string;
+    vmIsolation?: SandboxIsolationLevel;
+    volumes?: Record<string, SandboxVolumeDefinition>;
+}
+interface SandboxManagerProtocol {
+    resolvePolicy(config: RunSandboxConfig): {
+        vmIsolation: SandboxIsolationLevel;
+    };
+    getSandboxFromConfig(config: RunSandboxConfig): Promise<SandboxInstance>;
+    createSandbox(name: string): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
 }
 
 type ToolDefinition = ToolConfig;
@@ -2267,9 +2347,9 @@ interface PendingMessage {
     custom_run_config?: unknown;
 }
 interface PendingQueueMessageInput {
-    message: string;
+    message?: string;
     id?: string;
-    messages?: unknown[];
+    messages?: MessageLike[];
     [key: string]: unknown;
 }
 interface PendingQueueMessage {
@@ -2338,6 +2418,16 @@ type LangGraphStateChecker = (tenantId: string, assistantId: string, threadId: s
  * Returns an async iterable for streaming responses
  */
 type AgentStreamExecutor = (tenantId: string, assistantId: string, threadId: string, input: any) => AsyncIterable<any>;
+/**
+ * Message-like structure for normalized message input
+ * Supports both simple string content and structured message objects
+ */
+interface MessageLike {
+    role: "human" | "system" | "assistant" | "tool";
+    content: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+}
 
 /**
  * StoreLatticeManager
@@ -2674,8 +2764,8 @@ declare class FileSystemSkillStore implements SkillStore {
  * SandboxSkillStore
  *
  * Sandbox-based implementation of SkillStore
- * Stores skills in a remote sandbox environment
- * Path format: /home/gem/tenants/{tenantId}/skills/{skillName}/SKILL.md
+ * Stores skills in the shared project sandbox under ~/.agents/skills/
+ * Path format: ~/.agents/skills/{skillName}/SKILL.md
  */
 
 interface SandboxSkillStoreOptions {
@@ -2684,29 +2774,35 @@ interface SandboxSkillStoreOptions {
      * If not provided, will use getSandBoxManager() dynamically
      */
     sandboxManager?: SandboxManagerProtocol;
-    /**
-     * Base path for skill storage
-     * @default "/home/gem/tenants"
-     */
-    basePath?: string;
+    /** Default assistant ID for sandbox context */
+    assistantId?: string;
+    /** Default workspace ID for sandbox context */
+    workspaceId?: string;
+    /** Default project ID for sandbox context */
+    projectId?: string;
 }
 /**
  * Sandbox-based implementation of SkillStore with tenant isolation
  */
 declare class SandboxSkillStore implements SkillStore {
     private sandboxManager?;
-    private basePath;
+    private defaultContext;
     constructor(options?: SandboxSkillStoreOptions);
     /**
-     * Get sandbox manager for a tenant
+     * Get sandbox manager
      */
     private getSandboxManager;
     /**
-     * Get skill directory path in sandbox
+     * Get the project-level sandbox for skill operations.
+     * Uses the same sandbox as the project workspace to ensure volume mounts are consistent.
+     */
+    private getSandbox;
+    /**
+     * Get skill directory path in sandbox (absolute path with ~/ prefix)
      */
     private getSkillDirectoryPath;
     /**
-     * Get skill file path in sandbox
+     * Get skill file path in sandbox (absolute path with ~/ prefix)
      */
     private getSkillFilePath;
     /**
@@ -2720,43 +2816,43 @@ declare class SandboxSkillStore implements SkillStore {
     /**
      * Get all skills for a tenant
      */
-    getAllSkills(tenantId: string): Promise<Skill[]>;
+    getAllSkills(tenantId: string, context?: SkillStoreContext): Promise<Skill[]>;
     /**
-     * Get skill by ID
-     */
-    getSkillById(tenantId: string, id: string): Promise<Skill | null>;
+      * Get skill by ID
+      */
+    getSkillById(tenantId: string, id: string, context?: SkillStoreContext): Promise<Skill | null>;
     /**
-     * Create a new skill
-     */
-    createSkill(tenantId: string, id: string, data: CreateSkillRequest): Promise<Skill>;
+      * Create a new skill
+      */
+    createSkill(tenantId: string, id: string, data: CreateSkillRequest, context?: SkillStoreContext): Promise<Skill>;
     /**
-     * Update an existing skill
-     */
-    updateSkill(tenantId: string, id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+      * Update an existing skill
+      */
+    updateSkill(tenantId: string, id: string, updates: Partial<CreateSkillRequest>, context?: SkillStoreContext): Promise<Skill | null>;
     /**
-     * Delete a skill by ID
-     */
-    deleteSkill(tenantId: string, id: string): Promise<boolean>;
+      * Delete a skill by ID
+      */
+    deleteSkill(tenantId: string, id: string, context?: SkillStoreContext): Promise<boolean>;
     /**
-     * Check if skill exists
-     */
-    hasSkill(tenantId: string, id: string): Promise<boolean>;
+      * Check if skill exists
+      */
+    hasSkill(tenantId: string, id: string, context?: SkillStoreContext): Promise<boolean>;
     /**
-     * Search skills by metadata within a tenant
-     */
-    searchByMetadata(tenantId: string, metadataKey: string, metadataValue: string): Promise<Skill[]>;
+      * Search skills by metadata within a tenant
+      */
+    searchByMetadata(tenantId: string, metadataKey: string, metadataValue: string, context?: SkillStoreContext): Promise<Skill[]>;
     /**
-     * Filter skills by compatibility within a tenant
-     */
-    filterByCompatibility(tenantId: string, compatibility: string): Promise<Skill[]>;
+      * Filter skills by compatibility within a tenant
+      */
+    filterByCompatibility(tenantId: string, compatibility: string, context?: SkillStoreContext): Promise<Skill[]>;
     /**
-     * Filter skills by license within a tenant
-     */
-    filterByLicense(tenantId: string, license: string): Promise<Skill[]>;
+      * Filter skills by license within a tenant
+      */
+    filterByLicense(tenantId: string, license: string, context?: SkillStoreContext): Promise<Skill[]>;
     /**
-     * Get sub-skills of a parent skill within a tenant
-     */
-    getSubSkills(tenantId: string, parentSkillName: string): Promise<Skill[]>;
+      * Get sub-skills of a parent skill within a tenant
+      */
+    getSubSkills(tenantId: string, parentSkillName: string, context?: SkillStoreContext): Promise<Skill[]>;
 }
 
 /**
@@ -3353,6 +3449,33 @@ declare function isValidSkillName(name: string): boolean;
  */
 declare function validateSkillName(name: string): void;
 
+/**
+ * Skill Parser Utilities
+ *
+ * Pure functions for parsing and building SKILL.md files.
+ * No storage abstraction — callers operate on raw file content.
+ */
+interface SkillMeta {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    subSkills?: string[];
+}
+/**
+ * Parse YAML frontmatter from a SKILL.md file.
+ * Returns the parsed metadata and the markdown body.
+ */
+declare function parseSkillFrontmatter(content: string): {
+    meta: SkillMeta;
+    body: string;
+};
+/**
+ * Build a SKILL.md file from metadata and body content.
+ */
+declare function buildSkillFile(meta: SkillMeta, body: string): string;
+
 /**
  * McpLatticeManager
  *
@@ -3391,68 +3514,366 @@ declare class McpLatticeManager extends BaseLatticeManager<McpLatticeInterface>
 }
 declare const mcpManager: McpLatticeManager;
 
-/**
- * SandboxLatticeManager
- *
- * Sandbox Lattice manager for registering and managing sandbox services
- * Supports creating, deleting, and managing sandbox instances
- */
+interface SandboxProvider {
+    createSandbox(name: string, config?: RunSandboxConfig): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+}
 
-/**
- * SandboxLatticeManager - Singleton sandbox Lattice manager
- * Responsible for registering and managing various sandbox service Lattices
- */
-declare class SandboxLatticeManager extends BaseLatticeManager<SandboxManagerProtocol> {
-    private static _instance;
+interface MicrosandboxProviderConfig {
+    image?: string;
+    cpus?: number;
+    memoryMib?: number;
+    env?: Record<string, string>;
+}
+declare const defaultMicrosandboxConfig: MicrosandboxProviderConfig;
+declare class MicrosandboxProvider implements SandboxProvider {
+    private config;
+    private instances;
+    private creating;
+    constructor(config?: MicrosandboxProviderConfig);
+    createSandbox(name: string): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+}
+
+type SandboxLifecycleResponse = {
+    name: string;
+    status: string;
+};
+type ReadFileResponse = {
+    path: string;
+    content: string;
+};
+type WriteFileResponse = {
+    path: string;
+};
+type ListPathResponse = {
+    entries: Array<{
+        path: string;
+        type: string;
+    }>;
+};
+type FindFilesResponse = {
+    files: string[];
+};
+type SearchInFileResponse = {
+    matches: Array<{
+        line: number;
+        content: string;
+    }>;
+};
+type ReplaceInFileResponse = {
+    replaced: number;
+};
+type DownloadFileResponse = {
+    path: string;
+    content?: string;
+    contentBase64?: string;
+};
+type ExecCommandResponse = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+interface EnsureMicrosandboxInput {
+    image?: string;
+    cpus?: number;
+    memoryMib?: number;
+    env?: Record<string, string>;
+    volumes?: Record<string, SandboxVolumeDefinition>;
+}
+interface MicrosandboxShellExecInput {
+    sandboxName: string;
+    command: string;
+    exec_dir?: string;
+    timeout?: number;
+}
+interface MicrosandboxServiceClientConfig {
+    baseURL: string;
+}
+declare class MicrosandboxServiceClient {
+    private readonly baseURL;
+    constructor(config: MicrosandboxServiceClientConfig);
+    ensureSandbox(name: string, input: EnsureMicrosandboxInput): Promise<SandboxLifecycleResponse>;
+    startSandbox(name: string): Promise<SandboxLifecycleResponse>;
+    stopSandbox(name: string): Promise<SandboxLifecycleResponse>;
+    killSandbox(name: string): Promise<SandboxLifecycleResponse>;
+    deleteSandbox(name: string): Promise<SandboxLifecycleResponse>;
+    getStatus(name: string): Promise<SandboxLifecycleResponse>;
+    readFile(sandboxName: string, path: string): Promise<ReadFileResponse>;
+    writeFile(sandboxName: string, path: string, content: string): Promise<WriteFileResponse>;
+    listPath(sandboxName: string, path: string, recursive?: boolean): Promise<ListPathResponse>;
+    findFiles(sandboxName: string, path: string, pattern: string): Promise<FindFilesResponse>;
+    searchInFile(sandboxName: string, path: string, query: string): Promise<SearchInFileResponse>;
+    replaceInFile(sandboxName: string, input: {
+        path: string;
+        search: string;
+        replace: string;
+    }): Promise<ReplaceInFileResponse>;
+    uploadFile(sandboxName: string, path: string, content: Buffer): Promise<WriteFileResponse>;
+    downloadFile(sandboxName: string, path: string): Promise<DownloadFileResponse>;
+    execCommand(input: MicrosandboxShellExecInput): Promise<ExecCommandResponse>;
+    private request;
+}
+
+interface MicrosandboxRemoteProviderConfig extends MicrosandboxServiceClientConfig {
+    client?: Pick<MicrosandboxServiceClient, "ensureSandbox"> & Partial<MicrosandboxServiceClient>;
+    image?: string;
+    cpus?: number;
+    memoryMib?: number;
+    env?: Record<string, string>;
+}
+declare class MicrosandboxRemoteProvider implements SandboxProvider {
+    private readonly config;
+    private readonly client;
+    private readonly instances;
+    private readonly creating;
+    constructor(config: MicrosandboxRemoteProviderConfig);
+    createSandbox(name: string, config?: RunSandboxConfig): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+    private buildEnsureInput;
+    private buildDefaultVolumes;
+}
+
+interface RemoteSandboxProviderConfig {
+    baseURL: string;
+}
+declare class RemoteSandboxProvider implements SandboxProvider {
+    private config;
+    private client;
+    private instances;
+    constructor(config: RemoteSandboxProviderConfig);
+    createSandbox(name: string): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+}
+
+interface E2BProviderConfig {
+    apiKey: string;
+    template?: string;
+    timeoutMs?: number;
+}
+declare class E2BProvider implements SandboxProvider {
+    private config;
+    private instances;
+    private creating;
+    constructor(config: E2BProviderConfig);
+    createSandbox(name: string): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+}
+
+interface DaytonaProviderConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    target?: string;
+    timeout?: number;
+    volumeName?: string;
+}
+declare class DaytonaProvider implements SandboxProvider {
+    private config;
+    private daytona;
+    private instances;
+    private creating;
+    private volumeId;
+    constructor(config: DaytonaProviderConfig);
+    createSandbox(name: string, config?: RunSandboxConfig): Promise<SandboxInstance>;
     /**
-     * Get SandboxLatticeManager singleton instance
+     * Build volume mounts for a sandbox based on RunSandboxConfig.
+     * Mounts:
+     *   ~/.agents/skills → tenants/{tenantId}/skills
+     *   ~/agent          → tenants/{tenantId}/agents/{assistantId}
+     *   ~/project        → tenants/{tenantId}/projects/{projectId}
      */
-    static getInstance(): SandboxLatticeManager;
+    private buildVolumeMounts;
+    private getOrCreateVolume;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+}
+
+interface CreateSandboxProviderConfig {
     /**
-     * Get Lattice type prefix
+     * Provider type
+     * - "microsandbox": local microVM via microsandbox SDK (requires KVM/Hypervisor)
+     * - "microsandbox-remote": remote microsandbox-service via dedicated HTTP client
+     * - "remote": remote sandbox service via @agent-infra/sandbox HTTP client
+     * - "e2b": E2B cloud sandbox (https://e2b.dev)
+     * - "daytona": Daytona cloud sandbox (https://daytona.io)
      */
-    protected getLatticeType(): string;
+    type: "microsandbox" | "microsandbox-remote" | "remote" | "e2b" | "daytona";
     /**
-     * Register sandbox Lattice
-     * @param key Lattice key name
-     * @param manager Optional sandbox manager. If not provided, will create a default one.
-     * @param baseURL Base URL for sandbox service (used when creating default manager)
+     * Required when type = "remote"
      */
-    registerLattice(key: string, config: {
-        manager?: SandboxManagerProtocol;
-        baseURL?: string;
-    }): void;
+    remoteBaseURL?: string;
     /**
-     * Get SandboxLattice
-     * @param key Lattice key name
+     * Required when type = "microsandbox-remote"
      */
-    getSandboxLattice(key: string): SandboxManagerProtocol;
+    microsandboxServiceBaseURL?: string;
     /**
-     * Get all Lattices
+     * Optional override for microsandbox image
      */
-    getAllLattices(): SandboxManagerProtocol[];
+    microsandboxImage?: string;
     /**
-     * Check if Lattice exists
-     * @param key Lattice key name
+     * Optional override for microsandbox CPUs
      */
-    hasLattice(key: string): boolean;
+    microsandboxCpus?: number;
     /**
-     * Remove Lattice
-     * @param key Lattice key name
+     * Optional override for microsandbox memory (MiB)
      */
-    removeLattice(key: string): boolean;
+    microsandboxMemoryMib?: number;
     /**
-     * Clear all Lattices
+     * Required when type = "e2b"
      */
-    clearLattices(): void;
+    e2bApiKey?: string;
     /**
-     * Get Lattice count
+     * Optional E2B template (default: "base")
      */
-    getLatticeCount(): number;
+    e2bTemplate?: string;
     /**
-     * Get Lattice key list
+     * Optional E2B sandbox timeout in milliseconds (default: 300000)
+     */
+    e2bTimeoutMs?: number;
+    /**
+     * Required when type = "daytona"
+     */
+    daytonaApiKey?: string;
+    /**
+     * Optional Daytona API URL
+     */
+    daytonaApiUrl?: string;
+    /**
+     * Optional Daytona target region
+     */
+    daytonaTarget?: string;
+    /**
+     * Optional Daytona create timeout in seconds (0 = no timeout, default: 0)
+     */
+    daytonaTimeout?: number;
+    /**
+     * Optional Daytona volume name for shared persistent storage across sandboxes
+     */
+    daytonaVolumeName?: string;
+}
+/**
+ * Factory function for creating different sandbox provider implementations.
+ *
+ * This allows runtime selection of the sandbox backend without changing
+ * consumer code. New provider types can be added here as they are implemented.
+ */
+declare function createSandboxProvider(config: CreateSandboxProviderConfig): SandboxProvider;
+
+declare class MicrosandboxInstance implements SandboxInstance {
+    private native;
+    readonly name: string;
+    constructor(name: string, native: Sandbox);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+declare class MicrosandboxRemoteInstance implements SandboxInstance {
+    private readonly client;
+    readonly name: string;
+    constructor(name: string, client: MicrosandboxServiceClient);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+declare class RemoteSandboxInstance implements SandboxInstance {
+    private client;
+    readonly name: string;
+    constructor(name: string, client: SandboxClient);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+declare class E2BInstance implements SandboxInstance {
+    private native;
+    readonly name: string;
+    constructor(name: string, native: Sandbox$1);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+declare class DaytonaInstance implements SandboxInstance {
+    private native;
+    readonly name: string;
+    constructor(name: string, native: Sandbox$2);
+    /**
+     * All sandbox file operations live under the user's home directory (~).
+     * The AI uses virtual paths like "~/agent/file.txt". Daytona SDK expects
+     * relative paths for file operations (they are resolved against ~ automatically),
+     * so we strip the leading "~/" or "/" here.
+     *
+     * Handles edge cases like "~/~/agent/file.txt" by repeatedly stripping prefixes.
      */
+    private toSandboxHomePath;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    getStatus(): Promise<"running" | "stopped" | "unknown">;
+    readonly file: SandboxFileService;
+    readonly shell: SandboxShellService;
+}
+
+declare function computeSandboxName(config: {
+    vmIsolation: SandboxIsolationLevel;
+    tenantId?: string;
+    workspaceId?: string;
+    projectId?: string;
+    assistant_id: string;
+}): string;
+declare class SandboxLatticeManager extends BaseLatticeManager<SandboxProvider> implements SandboxManagerProtocol {
+    private static _instance;
+    static getInstance(): SandboxLatticeManager;
+    protected getLatticeType(): string;
+    registerLattice(key: string, provider: SandboxProvider): void;
+    getSandboxLattice(key: string): SandboxProvider;
+    getAllLattices(): SandboxProvider[];
+    hasLattice(key: string): boolean;
+    removeLattice(key: string): boolean;
+    clearLattices(): void;
+    getLatticeCount(): number;
     getLatticeKeys(): string[];
+    resolvePolicy(config: RunSandboxConfig): {
+        vmIsolation: SandboxIsolationLevel;
+    };
+    getSandboxFromConfig(config: RunSandboxConfig): Promise<SandboxInstance>;
+    createSandbox(name: string, config?: RunSandboxConfig): Promise<SandboxInstance>;
+    getSandbox(name: string): Promise<SandboxInstance>;
+    stopSandbox(name: string): Promise<void>;
+    deleteSandbox(name: string): Promise<void>;
+    listSandboxes(): Promise<SandboxInstance[]>;
+    private _requireProvider;
 }
 declare const sandboxLatticeManager: SandboxLatticeManager;
 declare const getSandBoxManager: (key?: string) => SandboxManagerProtocol;
@@ -4621,113 +5042,23 @@ declare class MemoryBackend implements BackendProtocol {
 /**
  * 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
+ * Paths are absolute paths starting with ~/ (e.g. "~/agent/file.txt").
+ * These are passed directly to DaytonaInstance which handles the ~/ prefix.
  */
 
-/**
- * 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;
+        sandboxInstance?: SandboxInstance;
     });
-    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[]>;
 }
 
@@ -4958,8 +5289,9 @@ interface ThreadState {
 }
 interface QueueMessage {
     input: {
-        message: string;
+        message?: string;
         id?: string;
+        messages?: MessageLike[];
     };
     command?: CommandParams<any>;
     custom_run_config?: any;
@@ -5075,6 +5407,11 @@ declare class Agent {
      * Add message to queue
      * All messages go to queue, processor auto-starts if not running
      * STEER/Command messages are inserted at head of queue for immediate processing
+     *
+     * Supports both legacy single message format and new messages[] format:
+     * - Legacy: input.message (single human message)
+     * - New: input.messages[] (array of mixed human/system messages)
+     * - When input.messages is provided, it takes precedence over input.message
      */
     addMessage(queueMessage: QueueMessage, mode?: QueueMode): Promise<{
         queued: boolean;
@@ -5319,4 +5656,9 @@ interface UnknownToolHandlerConfig {
  */
 declare function createUnknownToolHandlerMiddleware(config?: UnknownToolHandlerConfig): AgentMiddleware;
 
-export { AGENT_TASK_EVENT, type AddMessageParams, Agent, type AgentClient, type AgentExecutor, AgentInstanceManager, type AgentLattice, AgentLatticeManager, type AgentLifecycleEventName, AgentManager, type AgentStreamExecutor, type AgentThreadInterface, 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 IMessageQueueStore, type IMetricsServerClient, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryTaskListStore, InMemoryTenantStore, InMemoryThreadMessageQueueStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, type IsolatedLevel, LINE_NUMBER_WIDTH, type LangGraphStateChecker, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type MessageCompletedEvent, type MessageFailedEvent, type MessageStartedEvent, MessageType, MetricsServerManager, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, type PendingMessage, PinoLoggerClient, PostgresDatabase, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, QueueMode, type QueuePendingEvent, type RunSandboxConfig, type RuntimeModelConfig, SandboxFilesystem, SandboxLatticeManager, type SandboxManagerProtocol, SandboxSkillStore, type SandboxSkillStoreOptions, type ScheduleLattice, ScheduleLatticeManager, SemanticMetricsClient, type SkillLattice, SkillLatticeManager, type SkillResource, SqlDatabaseManager, type StateAndStore, StateBackend, StoreBackend, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, TOOL_RESULT_TOKEN_LIMIT, TRUNCATION_GUIDANCE, type TableInfo, type TableSchema, type TaskEvent, type TaskListStore, type TaskSpec, TaskStatus, type TaskUpdatable, TeamAgentGraphBuilder, type TeamConfig, type TeamMiddlewareOptions, type TeamTask, type TeammateSpec, type TeammateToolsOptions, type ThreadBuffer, type ThreadBufferConfig, type ThreadBusyEvent, type ThreadIdleEvent, type ThreadInfo, type ThreadQueueConfig, type ThreadState, ThreadStatus, type ThreadStatusChangedEvent, type ToolDefinition, type ToolLattice, ToolLatticeManager, type UnknownToolHandlerConfig, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type WriteResult, agentInstanceManager, agentLatticeManager, buildGrepResultsDict, checkEmptyContent, clearEncryptionKeyCache, createAgentTeam, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createModelSelectorMiddleware, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createTeamMiddleware, createTeammateTools, createUnknownToolHandlerMiddleware, createWidgetMiddleware, decrypt, describeCronExpression, embeddingsLatticeManager, encrypt, eventBus, eventBus as eventBusDefault, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, getAgentClient, getAgentConfig, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, loggerLatticeManager, mcpManager, metricsServerManager, modelLatticeManager, normalizeSandboxName, parseCronExpression, performStringReplacement, queueLatticeManager, registerAgentLattice, registerAgentLatticeWithTenant, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, updateFileData, validateAgentInput, validateEncryptionKey, validatePath, validateSkillName, validateToolInput, vectorStoreLatticeManager };
+interface SchedulerMiddlewareOptions {
+    defaultMaxRetries?: number;
+}
+declare function createSchedulerMiddleware(options?: SchedulerMiddlewareOptions): AgentMiddleware;
+
+export { AGENT_TASK_EVENT, type AddMessageParams, Agent, type AgentClient, type AgentExecutor, AgentInstanceManager, type AgentLattice, AgentLatticeManager, type AgentLifecycleEventName, AgentManager, type AgentStreamExecutor, type AgentThreadInterface, type BackendFactory, type BackendProtocol, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, CompositeBackend, ConsoleLoggerClient, type CreateSandboxProviderConfig, type CronFields, CustomMetricsClient, type DatabaseConfig, type DatabaseType, DaytonaInstance, DaytonaProvider, type DaytonaProviderConfig, DefaultScheduleClient, E2BInstance, E2BProvider, type E2BProviderConfig, EMPTY_CONTENT_WARNING, type EditResult, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type EnsureMicrosandboxInput, type FileData, type FileInfo, FileSystemSkillStore, type FileSystemSkillStoreOptions, FilesystemBackend, type GrepMatch, type IMessageQueueStore, type IMetricsServerClient, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryDatabaseConfigStore, InMemoryMailboxStore, InMemoryTaskListStore, InMemoryTenantStore, InMemoryThreadMessageQueueStore, InMemoryThreadStore, InMemoryUserStore, InMemoryUserTenantLinkStore, LINE_NUMBER_WIDTH, type LangGraphStateChecker, type LoggerLattice, LoggerLatticeManager, MAX_LINE_LENGTH, type MailboxMessage, type MailboxStore, type McpLatticeInterface, McpLatticeManager, type McpServerInfo, MemoryBackend, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type MessageCompletedEvent, type MessageFailedEvent, type MessageStartedEvent, MessageType, MetricsServerManager, MicrosandboxInstance, MicrosandboxProvider, type MicrosandboxProviderConfig, MicrosandboxRemoteInstance, MicrosandboxRemoteProvider, type MicrosandboxRemoteProviderConfig, MicrosandboxServiceClient, type MicrosandboxServiceClientConfig, type MicrosandboxShellExecInput, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, type PendingMessage, PinoLoggerClient, PostgresDatabase, PrometheusClient, type QueryResult, type QueueLattice, QueueLatticeManager, QueueMode, type QueuePendingEvent, RemoteSandboxInstance, RemoteSandboxProvider, type RemoteSandboxProviderConfig, type RunSandboxConfig, type RuntimeModelConfig, type SandboxFileInfo, type SandboxFileService, SandboxFilesystem, type SandboxInstance, type SandboxIsolationLevel, SandboxLatticeManager, type SandboxManagerProtocol, type SandboxProvider, type SandboxShellService, SandboxSkillStore, type SandboxSkillStoreOptions, type SandboxVolumeDefinition, type ScheduleLattice, ScheduleLatticeManager, type SchedulerMiddlewareOptions, SemanticMetricsClient, type SkillLattice, SkillLatticeManager, type SkillMeta, 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, type ThreadBusyEvent, type ThreadIdleEvent, type ThreadInfo, type ThreadQueueConfig, type ThreadState, ThreadStatus, type ThreadStatusChangedEvent, type ToolDefinition, type ToolLattice, ToolLatticeManager, type UnknownToolHandlerConfig, type VectorStoreLatticeInterface, VectorStoreLatticeManager, type WriteResult, agentInstanceManager, agentLatticeManager, buildGrepResultsDict, buildSkillFile, checkEmptyContent, clearEncryptionKeyCache, computeSandboxName, createAgentTeam, createExecuteSqlQueryTool, createFileData, createInfoSqlTool, createListMetricsDataSourcesTool, createListMetricsServersTool, createListTablesSqlTool, createModelSelectorMiddleware, createQueryCheckerSqlTool, createQueryMetricDefinitionTool, createQueryMetricsListTool, createQuerySemanticMetricDataTool, createQuerySqlTool, createQueryTableDefinitionTool, createQueryTablesListTool, createSandboxProvider, createSchedulerMiddleware, createTeamMiddleware, createTeammateTools, createUnknownToolHandlerMiddleware, createWidgetMiddleware, decrypt, defaultMicrosandboxConfig, describeCronExpression, embeddingsLatticeManager, encrypt, eventBus, eventBus as eventBusDefault, fileDataToString, formatContentWithLineNumbers, formatGrepMatches, formatGrepResults, formatReadResponse, getAgentClient, getAgentConfig, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getEncryptionKey, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getSandBoxManager, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, globSearchFiles, grepMatchesFromFiles, grepSearchFiles, hasChunkBuffer, isUsingDefaultKey, isValidCronExpression, isValidSandboxName, isValidSkillName, loggerLatticeManager, mcpManager, metricsServerManager, modelLatticeManager, normalizeSandboxName, parseCronExpression, parseSkillFrontmatter, performStringReplacement, queueLatticeManager, registerAgentLattice, registerAgentLatticeWithTenant, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerExistingTool, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerTeammateAgent, registerToolLattice, registerVectorStoreLattice, sandboxLatticeManager, sanitizeToolCallId, scheduleLatticeManager, skillLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, truncateIfTooLong, unregisterTeammateAgent, updateFileData, validateAgentInput, validateEncryptionKey, validatePath, validateSkillName, validateToolInput, vectorStoreLatticeManager };