noumen 0.4.0 → 0.5.0

package/dist/{agent-1nFVUP9E.d.ts → agent-C3eDRsxs.d.ts}

@@ -1,8 +1,10 @@
 import { A as AIProvider, S as StreamEvent, b as ChatMessage, E as Entry, U as UUID, d as FileCheckpointSnapshot, f as ContentReplacementRecord$1, g as SessionInfo, M as ModelPricing, h as UsageRecord, i as CostSummary, j as ModelUsageSummary, k as ChatCompletionUsage, l as ThinkingConfig, m as MemoryConfig, O as OutputFormat, e as ContentPart, R as RunOptions, c as CheckpointConfig, n as ToolResult } from './types-LrU4LRmX.js';
-import { j as VirtualComputer, E as ExecOptions, C as CommandResult, V as VirtualFs, T as Tool, H as HookDefinition, S as SubagentConfig, k as SubagentRun, l as TaskStore, e as LspServerManager, m as FileCheckpointManager, n as FileStateCacheConfig, L as LspServerConfig } from './types-RPKUTu1k.js';
+import { S as Sandbox } from './sandbox-9qeMTNrD.js';
+import { T as Tool, H as HookDefinition, S as SubagentConfig, i as SubagentRun, j as TaskStore, e as LspServerManager, F as FileCheckpointManager, k as FileStateCacheConfig, L as LspServerConfig } from './types-BA87bHPV.js';
 import { C as CacheControlConfig } from './cache-DsRqxx6v.js';
 import { M as McpServerConfig, T as TokenStorage } from './types-2kTLUCnD.js';
 import { c as PermissionHandler, d as PermissionConfig } from './types-CD0rUKKT.js';
+import { a as VirtualFs, V as VirtualComputer } from './computer-BPdxSo6X.js';
 
 type ProviderName = "openai" | "anthropic" | "gemini" | "openrouter" | "bedrock" | "vertex" | "ollama";
 declare const DEFAULT_MODELS: Record<string, string>;
@@ -25,508 +27,6 @@ declare function resolveProvider(input: AIProvider | ProviderName, opts?: Resolv
  */
 declare function detectProvider(): Promise<ProviderName | undefined>;
 
-/**
- * Filesystem and network restriction config passed to `@anthropic-ai/sandbox-runtime`.
- */
-interface SandboxConfig {
-    filesystem?: {
-        /** Paths the agent may write to (default: `[cwd]`). Write is denied everywhere else. */
-        allowWrite?: string[];
-        /** Paths to explicitly deny writes within allowed regions. */
-        denyWrite?: string[];
-        /** Paths to deny reading. By default everything is readable. */
-        denyRead?: string[];
-        /** Paths to re-allow reading within denyRead regions. Takes precedence over denyRead. */
-        allowRead?: string[];
-    };
-    network?: {
-        /** Domains the agent may reach via HTTP/HTTPS/SOCKS. */
-        allowedDomains?: string[];
-        /** Domains to explicitly block. */
-        deniedDomains?: string[];
-    };
-}
-interface SandboxedLocalComputerOptions {
-    defaultCwd?: string;
-    defaultTimeout?: number;
-    sandbox?: SandboxConfig;
-}
-/**
- * `VirtualComputer` that wraps every command with OS-level sandboxing via
- * `@anthropic-ai/sandbox-runtime`. Uses macOS Seatbelt (`sandbox-exec`) or
- * Linux bubblewrap (`bwrap`) under the hood.
- */
-declare class SandboxedLocalComputer implements VirtualComputer {
-    private defaultCwd;
-    private defaultTimeout;
-    private sandboxConfig;
-    private initPromise;
-    private initialized;
-    constructor(opts?: SandboxedLocalComputerOptions);
-    private buildRuntimeConfig;
-    private ensureInitialized;
-    executeCommand(command: string, opts?: ExecOptions): Promise<CommandResult>;
-    /**
-     * Tear down the sandbox runtime. Call when the agent is done.
-     */
-    dispose(): Promise<void>;
-}
-
-/**
- * Minimal subset of the dockerode Container interface used by DockerComputer.
- * Avoids a hard import of dockerode at the module level.
- */
-interface DockerContainer {
-    exec(options: Record<string, unknown>): Promise<{
-        start(opts?: Record<string, unknown>): Promise<NodeJS.ReadableStream>;
-        inspect(): Promise<{
-            ExitCode: number;
-        }>;
-    }>;
-}
-interface DockerComputerOptions {
-    /** A dockerode Container instance for the target container. */
-    container: DockerContainer;
-    /** Default working directory for commands (default: /). */
-    defaultCwd?: string;
-    /** Default timeout in ms for commands (default: 30000). */
-    defaultTimeout?: number;
-}
-/**
- * VirtualComputer backed by command execution inside a Docker container.
- *
- * Requires `dockerode` as an optional peer dependency.
- * The user is responsible for container lifecycle (create, start, stop).
- */
-declare class DockerComputer implements VirtualComputer {
-    private container;
-    private defaultCwd;
-    private defaultTimeout;
-    constructor(opts: DockerComputerOptions);
-    executeCommand(command: string, opts?: ExecOptions): Promise<CommandResult>;
-}
-
-/**
- * Minimal subset of the E2B Sandbox interface used by E2BComputer and E2BFs.
- * Avoids a hard import of `e2b` at the module level.
- */
-interface E2BSandboxInstance {
-    commands: {
-        run(cmd: string, opts?: {
-            cwd?: string;
-            timeout?: number;
-            envs?: Record<string, string>;
-        }): Promise<{
-            exitCode: number;
-            stdout: string;
-            stderr: string;
-        }>;
-    };
-    files: {
-        read(path: string, opts?: {
-            format?: string;
-        }): Promise<string>;
-        write(path: string, data: string): Promise<unknown>;
-        remove(path: string): Promise<void>;
-        makeDir(path: string): Promise<unknown>;
-        list(path: string): Promise<Array<{
-            name: string;
-            path: string;
-            type?: string;
-            size?: number;
-            modifiedTime?: Date;
-        }>>;
-        exists(path: string): Promise<boolean>;
-        getInfo(path: string): Promise<{
-            name: string;
-            path: string;
-            type?: string;
-            size?: number;
-            modifiedTime?: Date;
-        }>;
-    };
-}
-interface E2BComputerOptions {
-    /** An E2B Sandbox instance created via `Sandbox.create()`. */
-    sandbox: E2BSandboxInstance;
-    /** Default working directory for commands. */
-    defaultCwd?: string;
-    /** Default timeout in ms for commands (default: 30000). */
-    defaultTimeout?: number;
-}
-/**
- * VirtualComputer backed by command execution in an E2B cloud sandbox.
- *
- * Requires `e2b` as an optional peer dependency.
- * The user is responsible for sandbox lifecycle (create, close).
- */
-declare class E2BComputer implements VirtualComputer {
-    private sandbox;
-    private defaultCwd;
-    private defaultTimeout;
-    constructor(opts: E2BComputerOptions);
-    executeCommand(command: string, opts?: ExecOptions): Promise<CommandResult>;
-}
-
-/**
- * Minimal subset of the Freestyle VM interface used by FreestyleComputer and
- * FreestyleFs. Avoids a hard import of `freestyle-sandboxes` at the module
- * level — the real SDK is only loaded dynamically during `FreestyleSandbox`
- * auto-creation.
- */
-interface FreestyleVmInstance {
-    exec(command: string, opts?: {
-        cwd?: string;
-        timeout?: number;
-    }): Promise<{
-        stdout: string | null;
-        stderr: string | null;
-        statusCode: number | null;
-    }>;
-    fs: {
-        readTextFile(path: string): Promise<string>;
-        writeTextFile(path: string, content: string): Promise<void>;
-        readDir(path: string): Promise<Array<{
-            name: string;
-            kind: string;
-        }>>;
-    };
-    suspend(): Promise<unknown>;
-    start(): Promise<unknown>;
-}
-interface FreestyleComputerOptions {
-    /** A Freestyle VM instance. */
-    vm: FreestyleVmInstance;
-    /** Default working directory for commands. */
-    defaultCwd?: string;
-    /** Default timeout in ms for commands (default: 30000). */
-    defaultTimeout?: number;
-}
-/**
- * VirtualComputer backed by command execution in a Freestyle VM.
- *
- * Requires `freestyle-sandboxes` as an optional peer dependency.
- * The user is responsible for VM lifecycle when using explicit mode.
- */
-declare class FreestyleComputer implements VirtualComputer {
-    private vm;
-    private defaultCwd;
-    private defaultTimeout;
-    constructor(opts: FreestyleComputerOptions);
-    executeCommand(command: string, opts?: ExecOptions): Promise<CommandResult>;
-}
-
-/**
- * Bundled sandbox: a `VirtualFs` and `VirtualComputer` paired together.
- *
- * Use one of the built-in factories (`LocalSandbox`, `UnsandboxedLocal`,
- * `SpritesSandbox`) or supply any object that satisfies this shape for
- * custom sandboxes (Docker, E2B, Daytona, in-memory, etc.).
- */
-interface Sandbox {
-    fs: VirtualFs;
-    computer: VirtualComputer;
-    /** Optional cleanup — called by Agent.close() to tear down OS-level sandbox state. */
-    dispose?(): Promise<void>;
-    /**
-     * Lazily provision the underlying sandbox resource. Idempotent — repeated
-     * calls return the same single-flight promise.
-     *
-     * When `sandboxId` is provided the sandbox reconnects to an existing
-     * resource instead of creating a new one. This is used during session
-     * resume: the stored sandbox identifier is read from session metadata
-     * and passed here so the agent reattaches to its previous container.
-     *
-     * When omitted a fresh resource is provisioned (for factories that
-     * support auto-creation) or the call is a no-op (for factories that
-     * were given a pre-created resource up front).
-     */
-    init?(sandboxId?: string): Promise<void>;
-    /**
-     * Return the opaque identifier for this sandbox instance so it can be
-     * persisted in session metadata and used to reconnect later via `init()`.
-     * Returns `undefined` before `init()` has resolved or for sandboxes
-     * that don't support reconnection.
-     */
-    sandboxId?(): string | undefined;
-}
-interface UnsandboxedLocalOptions {
-    /** Working directory for both file resolution and command execution. */
-    cwd?: string;
-    /** Default timeout (ms) for shell commands. */
-    defaultTimeout?: number;
-}
-/**
- * Create a `Sandbox` backed by the host filesystem and shell with **no
- * OS-level isolation**. The agent can access anything the host process can.
- *
- * Use this for development or fully-trusted environments where sandboxing
- * overhead is unwanted. For production use, prefer `LocalSandbox()` (which
- * wraps commands with `@anthropic-ai/sandbox-runtime`).
- */
-declare function UnsandboxedLocal(opts?: UnsandboxedLocalOptions): Sandbox;
-interface LocalSandboxOptions {
-    /** Working directory for both file resolution and command execution. */
-    cwd?: string;
-    /** Default timeout (ms) for shell commands. */
-    defaultTimeout?: number;
-    /**
-     * Sandbox restrictions. Defaults: writes allowed only in `cwd`,
-     * reads allowed everywhere, network unrestricted.
-     */
-    sandbox?: SandboxConfig;
-}
-/**
- * Create a `Sandbox` with OS-level isolation via `@anthropic-ai/sandbox-runtime`.
- *
- * - **macOS**: Seatbelt (`sandbox-exec`) profiles restrict filesystem and network.
- * - **Linux**: bubblewrap (`bwrap`) + socat for namespace-based isolation.
- *
- * Filesystem operations (`VirtualFs`) use the host `node:fs` — the sandbox
- * boundary is enforced on shell commands (`VirtualComputer`), which is where
- * the agent executes arbitrary code.
- *
- * Requires `@anthropic-ai/sandbox-runtime` as a peer dependency.
- */
-declare function LocalSandbox(opts?: LocalSandboxOptions): Sandbox;
-interface SpritesSandboxOptions {
-    /** sprites.dev API token. */
-    token: string;
-    /**
-     * Name of an existing sprite container. When provided the sandbox
-     * attaches to this sprite directly — no auto-creation occurs and
-     * `dispose()` will **not** delete it (lifecycle is yours to manage).
-     *
-     * When omitted a new sprite is provisioned on the first `init()` call
-     * (via `POST /v1/sprites`). The auto-created sprite is deleted when
-     * `dispose()` is called, and its name is available via `sandboxId()`
-     * for session persistence.
-     */
-    spriteName?: string;
-    /** Base URL for sprites API (default: https://api.sprites.dev). */
-    baseURL?: string;
-    /** Working directory inside the sprite (default: /home/sprite). */
-    workingDir?: string;
-    /**
-     * Optional prefix for auto-generated sprite names (default: "noumen-").
-     * Only used when `spriteName` is omitted.
-     */
-    namePrefix?: string;
-}
-/**
- * Create a `Sandbox` backed by a remote sprites.dev container.
- * Full isolation — the agent has no access to the host machine.
- *
- * **Auto-creation:** When `spriteName` is omitted the sandbox is created
- * lazily on the first `init()` call via the Sprites REST API. The sprite
- * name is available through `sandboxId()` so callers can persist it in
- * session metadata for reconnection on resume. Pass the stored name back
- * through `init(storedId)` to reattach instead of creating a new sprite.
- *
- * **Explicit ID:** When `spriteName` is provided the sandbox attaches to
- * that sprite immediately on `init()`. `dispose()` is a no-op in this
- * case — the caller owns the sprite's lifecycle.
- *
- * @example
- * ```ts
- * // Auto-create — sprite provisioned on first init()
- * const sandbox = SpritesSandbox({ token: process.env.SPRITES_TOKEN! });
- *
- * // Explicit — attach to pre-existing sprite, no auto-lifecycle
- * const sandbox = SpritesSandbox({
- *   token: process.env.SPRITES_TOKEN!,
- *   spriteName: "my-sprite",
- * });
- * ```
- */
-declare function SpritesSandbox(opts: SpritesSandboxOptions): Sandbox;
-interface DockerSandboxOptions {
-    /**
-     * A pre-existing dockerode Container instance. When provided the sandbox
-     * attaches to this container directly — no auto-creation occurs and
-     * `dispose()` will **not** stop or remove it.
-     *
-     * When omitted, a new container is created from `image` on the first
-     * `init()` call via a dynamic import of `dockerode`. The auto-created
-     * container is stopped and removed when `dispose()` is called.
-     */
-    container?: DockerContainer;
-    /**
-     * Docker image to use for auto-creation (e.g. `"ubuntu:22.04"`).
-     * Required when `container` is omitted; ignored when `container` is provided.
-     */
-    image?: string;
-    /** Command to run in the auto-created container (default: `["sleep", "infinity"]`). */
-    cmd?: string[];
-    /** Environment variables for the auto-created container. */
-    env?: string[];
-    /** Extra options passed to dockerode `createContainer`. */
-    dockerOptions?: Record<string, unknown>;
-    /** Working directory inside the container. */
-    cwd?: string;
-    /** Default timeout (ms) for shell commands. */
-    defaultTimeout?: number;
-}
-/**
- * Create a `Sandbox` backed by a Docker container.
- * Requires `dockerode` as an optional peer dependency.
- *
- * **Auto-creation:** When `container` is omitted and `image` is provided,
- * the container is created and started lazily on the first `init()` call.
- * The container ID is available through `sandboxId()` for session
- * persistence. Pass the stored ID back through `init(storedId)` to
- * reattach to an existing container on resume.
- *
- * **Explicit container:** When `container` is provided, `init()` binds
- * it immediately. `dispose()` is a no-op — the caller owns the
- * container's lifecycle.
- *
- * @example
- * ```ts
- * // Auto-create from image
- * const sandbox = DockerSandbox({ image: "ubuntu:22.04", cwd: "/workspace" });
- *
- * // Explicit container (lifecycle managed externally)
- * const sandbox = DockerSandbox({ container: myDockerodeContainer });
- * ```
- */
-declare function DockerSandbox(opts: DockerSandboxOptions): Sandbox;
-interface E2BSandboxOptions {
-    /**
-     * A pre-existing E2B Sandbox instance (e.g. from `Sandbox.create()`).
-     * When provided the sandbox attaches to this instance — no auto-creation
-     * occurs and `dispose()` will **not** kill it.
-     *
-     * When omitted, a new E2B sandbox is created on the first `init()` call
-     * via a dynamic import of the `e2b` package. The auto-created sandbox
-     * is killed when `dispose()` is called.
-     */
-    sandbox?: E2BSandboxInstance;
-    /**
-     * E2B template to use for auto-creation (default: `"base"`).
-     * Only used when `sandbox` is omitted.
-     */
-    template?: string;
-    /**
-     * E2B API key. Falls back to the `E2B_API_KEY` environment variable
-     * when omitted. Only used during auto-creation.
-     */
-    apiKey?: string;
-    /** Timeout (ms) for the auto-created E2B sandbox (default: E2B SDK default). */
-    timeoutMs?: number;
-    /** Working directory inside the sandbox. */
-    cwd?: string;
-    /** Default timeout (ms) for shell commands. */
-    defaultTimeout?: number;
-}
-/**
- * Create a `Sandbox` backed by an E2B cloud sandbox.
- * Requires `e2b` as an optional peer dependency.
- *
- * **Auto-creation:** When `sandbox` is omitted the E2B sandbox is
- * provisioned lazily on the first `init()` call via the E2B SDK.
- * The sandbox ID is available through `sandboxId()` for session
- * persistence. Pass the stored ID back through `init(storedId)` to
- * reconnect to the same sandbox on resume (via `Sandbox.connect()`).
- *
- * **Explicit instance:** When `sandbox` is provided, `init()` binds
- * it immediately. `dispose()` is a no-op — the caller owns the
- * sandbox's lifecycle.
- *
- * @example
- * ```ts
- * // Auto-create — sandbox provisioned on first init()
- * const sandbox = E2BSandbox({ template: "base" });
- *
- * // Explicit — attach to pre-existing instance
- * const sandbox = E2BSandbox({ sandbox: await E2BSdk.Sandbox.create() });
- * ```
- */
-declare function E2BSandbox(opts: E2BSandboxOptions): Sandbox;
-interface FreestyleSandboxOptions {
-    /**
-     * A pre-existing Freestyle VM instance. When provided the sandbox
-     * attaches to this VM directly — no auto-creation occurs and
-     * `dispose()` will **not** suspend or delete it.
-     *
-     * When omitted, a new VM is created on the first `init()` call via
-     * a dynamic import of the `freestyle-sandboxes` package.
-     */
-    vm?: FreestyleVmInstance;
-    /**
-     * Freestyle API key. Falls back to the `FREESTYLE_API_KEY` environment
-     * variable when omitted. Only used during auto-creation.
-     */
-    apiKey?: string;
-    /** Snapshot ID to create the VM from. Only used during auto-creation. */
-    snapshotId?: string;
-    /**
-     * A `VmSpec` instance or configuration object passed through to
-     * `freestyle.vms.create()`. Only used during auto-creation.
-     */
-    spec?: unknown;
-    /**
-     * Idle timeout in seconds for the auto-created VM (default: 600).
-     * The VM auto-suspends after this many seconds of network inactivity.
-     */
-    idleTimeoutSeconds?: number;
-    /** Working directory inside the VM. */
-    cwd?: string;
-    /** Default timeout (ms) for shell commands. */
-    defaultTimeout?: number;
-    /** Files to provision at creation time. */
-    additionalFiles?: Record<string, {
-        content: string;
-        encoding?: string;
-    }>;
-    /** Git repos to clone at creation time. */
-    gitRepos?: Array<{
-        repo: string;
-        path: string;
-        rev?: string;
-    }>;
-    /**
-     * What to do with auto-created VMs on `dispose()`:
-     * - `"suspend"` (default) — suspends the VM, preserving full memory
-     *   state for near-instant resume on reconnect.
-     * - `"delete"` — permanently deletes the VM and frees all resources.
-     */
-    disposeStrategy?: "suspend" | "delete";
-}
-/**
- * Create a `Sandbox` backed by a Freestyle VM.
- * Requires `freestyle-sandboxes` as an optional peer dependency.
- *
- * **Auto-creation:** When `vm` is omitted a new Freestyle VM is
- * provisioned lazily on the first `init()` call. The VM ID is available
- * through `sandboxId()` for session persistence. Pass the stored ID back
- * through `init(storedId)` to reconnect (this also wakes suspended VMs).
- *
- * By default, auto-created VMs are **suspended** on `dispose()` rather
- * than deleted. This preserves full memory state and allows near-instant
- * resume. Set `disposeStrategy: "delete"` for full cleanup.
- *
- * **Explicit instance:** When `vm` is provided, `init()` binds it
- * immediately. `dispose()` is a no-op — the caller owns the VM's
- * lifecycle.
- *
- * @example
- * ```ts
- * // Auto-create — VM provisioned on first init()
- * const sandbox = FreestyleSandbox({ cwd: "/workspace" });
- *
- * // Auto-create from a snapshot
- * const sandbox = FreestyleSandbox({
- *   snapshotId: "abc123",
- *   cwd: "/workspace",
- * });
- *
- * // Explicit — attach to pre-existing VM
- * const sandbox = FreestyleSandbox({ vm: existingVm });
- * ```
- */
-declare function FreestyleSandbox(opts: FreestyleSandboxOptions): Sandbox;
-
 interface SkillDefinition {
     name: string;
     /** Skill body content (after frontmatter is stripped) */
@@ -1127,10 +627,21 @@ interface AgentOptions {
     cwd?: string;
     /**
      * Bundled sandbox providing both filesystem and shell execution.
-     * Use `LocalSandbox()` for OS-level sandboxing (requires
-     * `@anthropic-ai/sandbox-runtime`), `UnsandboxedLocal()` for raw host
-     * access, `SpritesSandbox()` for isolated remote containers, or pass
-     * any `{ fs: VirtualFs; computer: VirtualComputer }` for custom sandboxes.
+     *
+     * Local backends live on the root barrel:
+     * - `LocalSandbox()` — OS-level sandboxing (requires `@anthropic-ai/sandbox-runtime`).
+     * - `UnsandboxedLocal()` — raw host access.
+     *
+     * Remote backends are subpath imports so their optional peer deps do
+     * not enter the module graph unless opted into:
+     * - `import { DockerSandbox }    from "noumen/docker"`
+     * - `import { E2BSandbox }       from "noumen/e2b"`
+     * - `import { FreestyleSandbox } from "noumen/freestyle"`
+     * - `import { SshSandbox }       from "noumen/ssh"`
+     * - `import { SpritesSandbox }   from "noumen/sprites"`
+     *
+     * You can also pass any `{ fs: VirtualFs; computer: VirtualComputer }`
+     * for custom sandboxes.
      *
      * Defaults to `UnsandboxedLocal({ cwd })` when omitted — the library
      * default is non-sandboxed for backward compatibility. The CLI defaults
@@ -1329,4 +840,4 @@ declare class Agent {
     close(): Promise<void>;
 }
 
-export { type RunCallbacks as $, Agent as A, type BudgetState as B, type ContextFile as C, type DockerContainer as D, type E2BSandboxInstance as E, type FreestyleVmInstance as F, E2BComputer as G, type E2BComputerOptions as H, E2BSandbox as I, type E2BSandboxOptions as J, FreestyleComputer as K, type FreestyleComputerOptions as L, FreestyleSandbox as M, type FreestyleSandboxOptions as N, LocalSandbox as O, type ProjectContextConfig as P, type LocalSandboxOptions as Q, type RetryConfig as R, type Sandbox as S, type ThreadConfig as T, type MicrocompactConfig as U, type MicrocompactResult as V, type ProviderName as W, type ReactiveCompactConfig as X, type ReactiveCompactResult as Y, type ResolveProviderOptions as Z, type RetryEvent as _, type SkillDefinition as a, type RunResult as a0, SUPPORTED_PROVIDERS as a1, type SandboxConfig as a2, SandboxedLocalComputer as a3, type SandboxedLocalComputerOptions as a4, type SnipConfig as a5, type SnipResult as a6, SpritesSandbox as a7, type SpritesSandboxOptions as a8, Thread as a9, recordAutoCompactFailure as aA, recordAutoCompactSuccess as aB, resolveProvider as aC, shouldAutoCompact as aD, snipMessagesByUuids as aE, tryReactiveCompact as aF, webSearchToolPlaceholder as aG, type ThreadOptions as aa, type ToolResultBudgetConfig as ab, type ToolResultBudgetResult as ac, type ContentReplacementRecord as ad, type ToolResultSpillResult as ae, type ToolResultStorageConfig as af, type TracingConfig as ag, UnsandboxedLocal as ah, type UnsandboxedLocalOptions as ai, type WebSearchConfig as aj, type WebSearchResult as ak, applyPersistedReplacements as al, applySnipRemovals as am, canAutoCompact as an, createAutoCompactConfig as ao, createAutoCompactTracking as ap, createBudgetState as aq, createContentReplacementState as ar, createWebSearchTool as as, detectProvider as at, enforceToolResultBudget as au, enforceToolResultStorageBudget as av, microcompactMessages as aw, persistToolResult as ax, projectSnippedView as ay, reconstructContentReplacementState as az, SessionStorage as b, type ContextScope as c, type RetryContext as d, type RetryEngineOptions as e, type Span as f, type SpanAttributeValue as g, SpanStatusCode as h, type Tracer as i, type SpanOptions as j, type StoredCostState as k, type AgentOptions as l, type AutoCompactConfig as m, type AutoCompactTrackingState as n, CLEARED_PLACEHOLDER as o, COMPACTABLE_TOOLS as p, type ContentReplacementState as q, CostTracker as r, DEFAULT_MODELS as s, DEFAULT_RETRY_CONFIG as t, type DiagnoseCheckResult as u, type DiagnoseResult as v, DockerComputer as w, type DockerComputerOptions as x, DockerSandbox as y, type DockerSandboxOptions as z };
+export { createAutoCompactConfig as $, Agent as A, type BudgetState as B, type ContextFile as C, DEFAULT_MODELS as D, type RunCallbacks as E, type RunResult as F, SUPPORTED_PROVIDERS as G, type SnipConfig as H, type SnipResult as I, Thread as J, type ThreadOptions as K, type ToolResultBudgetConfig as L, type MicrocompactConfig as M, type ToolResultBudgetResult as N, type ContentReplacementRecord as O, type ProjectContextConfig as P, type ToolResultSpillResult as Q, type RetryConfig as R, type SkillDefinition as S, type ThreadConfig as T, type ToolResultStorageConfig as U, type TracingConfig as V, type WebSearchConfig as W, type WebSearchResult as X, applyPersistedReplacements as Y, applySnipRemovals as Z, canAutoCompact as _, SessionStorage as a, createAutoCompactTracking as a0, createBudgetState as a1, createContentReplacementState as a2, createWebSearchTool as a3, detectProvider as a4, enforceToolResultBudget as a5, enforceToolResultStorageBudget as a6, microcompactMessages as a7, persistToolResult as a8, projectSnippedView as a9, reconstructContentReplacementState as aa, recordAutoCompactFailure as ab, recordAutoCompactSuccess as ac, resolveProvider as ad, shouldAutoCompact as ae, snipMessagesByUuids as af, tryReactiveCompact as ag, webSearchToolPlaceholder as ah, type ContextScope as b, type RetryContext as c, type RetryEngineOptions as d, type Span as e, type SpanAttributeValue as f, SpanStatusCode as g, type Tracer as h, type SpanOptions as i, type StoredCostState as j, type AgentOptions as k, type AutoCompactConfig as l, type AutoCompactTrackingState as m, CLEARED_PLACEHOLDER as n, COMPACTABLE_TOOLS as o, type ContentReplacementState as p, CostTracker as q, DEFAULT_RETRY_CONFIG as r, type DiagnoseCheckResult as s, type DiagnoseResult as t, type MicrocompactResult as u, type ProviderName as v, type ReactiveCompactConfig as w, type ReactiveCompactResult as x, type ResolveProviderOptions as y, type RetryEvent as z };

package/dist/chunk-I5SBSOS6.js

@@ -0,0 +1,40 @@
+// src/virtual/proxy.ts
+function uninitError() {
+  throw new Error(
+    "Sandbox not initialized \u2014 call init() or pass a pre-created resource"
+  );
+}
+function createFsProxy() {
+  let inner = null;
+  const get = () => inner ?? uninitError();
+  return {
+    setTarget(target) {
+      inner = target;
+    },
+    readFile: (...args) => get().readFile(...args),
+    readFileBytes: (...args) => get().readFileBytes?.(...args),
+    writeFile: (...args) => get().writeFile(...args),
+    appendFile: (...args) => get().appendFile(...args),
+    deleteFile: (...args) => get().deleteFile(...args),
+    mkdir: (...args) => get().mkdir(...args),
+    readdir: (...args) => get().readdir(...args),
+    exists: (...args) => get().exists(...args),
+    stat: (...args) => get().stat(...args)
+  };
+}
+function createComputerProxy() {
+  let inner = null;
+  const get = () => inner ?? uninitError();
+  return {
+    setTarget(target) {
+      inner = target;
+    },
+    executeCommand: (...args) => get().executeCommand(...args)
+  };
+}
+
+export {
+  createFsProxy,
+  createComputerProxy
+};
+//# sourceMappingURL=chunk-I5SBSOS6.js.map

package/dist/chunk-I5SBSOS6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/virtual/proxy.ts"],"sourcesContent":["import type { VirtualFs } from \"./fs.js\";\nimport type { VirtualComputer } from \"./computer.js\";\n\n/**\n * Thin forwarding wrappers whose inner target is set by a sandbox factory's\n * `init()`. Methods throw until the target is bound.\n *\n * These proxies let remote sandbox factories return a `Sandbox` synchronously\n * while provisioning the real backend lazily inside `init()`. Consumers hold\n * the proxy reference and get transparent forwarding once `setTarget` fires.\n */\n\nexport type FsProxySetter = { setTarget(target: VirtualFs): void };\nexport type ComputerProxySetter = { setTarget(target: VirtualComputer): void };\n\nexport function uninitError(): never {\n  throw new Error(\n    \"Sandbox not initialized — call init() or pass a pre-created resource\",\n  );\n}\n\nexport function createFsProxy(): VirtualFs & FsProxySetter {\n  let inner: VirtualFs | null = null;\n  const get = (): VirtualFs => inner ?? uninitError();\n  return {\n    setTarget(target: VirtualFs) { inner = target; },\n    readFile: (...args) => get().readFile(...args),\n    readFileBytes: (...args) => get().readFileBytes?.(...args) as any,\n    writeFile: (...args) => get().writeFile(...args),\n    appendFile: (...args) => get().appendFile(...args),\n    deleteFile: (...args) => get().deleteFile(...args),\n    mkdir: (...args) => get().mkdir(...args),\n    readdir: (...args) => get().readdir(...args),\n    exists: (...args) => get().exists(...args),\n    stat: (...args) => get().stat(...args),\n  };\n}\n\nexport function createComputerProxy(): VirtualComputer & ComputerProxySetter {\n  let inner: VirtualComputer | null = null;\n  const get = (): VirtualComputer => inner ?? uninitError();\n  return {\n    setTarget(target: VirtualComputer) { inner = target; },\n    executeCommand: (...args) => get().executeCommand(...args),\n  };\n}\n"],"mappings":";AAeO,SAAS,cAAqB;AACnC,QAAM,IAAI;AAAA,IACR;AAAA,EACF;AACF;AAEO,SAAS,gBAA2C;AACzD,MAAI,QAA0B;AAC9B,QAAM,MAAM,MAAiB,SAAS,YAAY;AAClD,SAAO;AAAA,IACL,UAAU,QAAmB;AAAE,cAAQ;AAAA,IAAQ;AAAA,IAC/C,UAAU,IAAI,SAAS,IAAI,EAAE,SAAS,GAAG,IAAI;AAAA,IAC7C,eAAe,IAAI,SAAS,IAAI,EAAE,gBAAgB,GAAG,IAAI;AAAA,IACzD,WAAW,IAAI,SAAS,IAAI,EAAE,UAAU,GAAG,IAAI;AAAA,IAC/C,YAAY,IAAI,SAAS,IAAI,EAAE,WAAW,GAAG,IAAI;AAAA,IACjD,YAAY,IAAI,SAAS,IAAI,EAAE,WAAW,GAAG,IAAI;AAAA,IACjD,OAAO,IAAI,SAAS,IAAI,EAAE,MAAM,GAAG,IAAI;AAAA,IACvC,SAAS,IAAI,SAAS,IAAI,EAAE,QAAQ,GAAG,IAAI;AAAA,IAC3C,QAAQ,IAAI,SAAS,IAAI,EAAE,OAAO,GAAG,IAAI;AAAA,IACzC,MAAM,IAAI,SAAS,IAAI,EAAE,KAAK,GAAG,IAAI;AAAA,EACvC;AACF;AAEO,SAAS,sBAA6D;AAC3E,MAAI,QAAgC;AACpC,QAAM,MAAM,MAAuB,SAAS,YAAY;AACxD,SAAO;AAAA,IACL,UAAU,QAAyB;AAAE,cAAQ;AAAA,IAAQ;AAAA,IACrD,gBAAgB,IAAI,SAAS,IAAI,EAAE,eAAe,GAAG,IAAI;AAAA,EAC3D;AACF;","names":[]}