noumen 0.2.0 → 0.3.0

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

@@ -1,8 +1,8 @@
-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-3c88cRKH.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-CwKKucOF.js';
-import { C as CacheControlConfig } from './cache-DVqaCX8v.js';
+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 { 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-DwdzmXfs.js';
+import { c as PermissionHandler, d as PermissionConfig } from './types-CD0rUKKT.js';
 
 type ProviderName = "openai" | "anthropic" | "gemini" | "openrouter" | "bedrock" | "vertex" | "ollama";
 declare const DEFAULT_MODELS: Record<string, string>;
@@ -168,6 +168,54 @@ declare class E2BComputer implements VirtualComputer {
     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.
  *
@@ -178,6 +226,29 @@ declare class E2BComputer implements VirtualComputer {
 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. */
@@ -221,21 +292,76 @@ declare function LocalSandbox(opts?: LocalSandboxOptions): Sandbox;
 interface SpritesSandboxOptions {
     /** sprites.dev API token. */
     token: string;
-    /** Name of the sprite container. */
-    spriteName: 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 dockerode Container instance for the target container. */
-    container: DockerContainer;
+    /**
+     * 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. */
@@ -244,11 +370,50 @@ interface DockerSandboxOptions {
 /**
  * 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 {
-    /** An E2B Sandbox instance created via `Sandbox.create()`. */
-    sandbox: E2BSandboxInstance;
+    /**
+     * 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. */
@@ -257,8 +422,110 @@ interface E2BSandboxOptions {
 /**
  * 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;
@@ -427,10 +694,22 @@ declare function enforceToolResultBudget(messages: ChatMessage[], config: ToolRe
 declare class SessionStorage {
     private fs;
     private sessionDir;
+    private writeLock;
     constructor(fs: VirtualFs, sessionDir: string);
+    /**
+     * Serialize writes through a simple promise chain so parallel
+     * appendEntry calls don't interleave large JSONL records.
+     */
+    private serializedWrite;
     private getTranscriptPath;
     ensureDir(): Promise<void>;
     appendEntry(sessionId: string, entry: Entry): Promise<void>;
+    /**
+     * Append multiple entries atomically as a single write.
+     * All entries are serialized into one string and written in one appendFile
+     * call, preventing partial writes on crash.
+     */
+    appendEntriesBatch(sessionId: string, entries: Entry[]): Promise<void>;
     appendMessage(sessionId: string, message: ChatMessage, parentUuid?: UUID | null): Promise<UUID>;
     appendCompactBoundary(sessionId: string): Promise<UUID>;
     appendSummary(sessionId: string, summaryMessage: ChatMessage, parentUuid?: UUID | null): Promise<UUID>;
@@ -439,9 +718,15 @@ declare class SessionStorage {
     appendSnipBoundary(sessionId: string, removedUuids: string[]): Promise<void>;
     appendContentReplacement(sessionId: string, replacements: ContentReplacementRecord$1[]): Promise<void>;
     appendMetadata(sessionId: string, key: string, value: unknown): Promise<void>;
+    /**
+     * Re-append custom-title and key metadata entries after a compact boundary
+     * so they remain discoverable in the active-entries window.
+     */
+    reAppendMetadataAfterCompact(sessionId: string): Promise<void>;
     loadMessages(sessionId: string): Promise<ChatMessage[]>;
     loadAllEntries(sessionId: string): Promise<Entry[]>;
     sessionExists(sessionId: string): Promise<boolean>;
+    deleteSession(sessionId: string): Promise<void>;
     listSessions(): Promise<SessionInfo[]>;
 }
 
@@ -462,7 +747,9 @@ interface ReactiveCompactResult {
  * Returns `null` if there are not enough messages to meaningfully compact
  * or truncate (less than 2 messages).
  */
-declare function tryReactiveCompact(provider: AIProvider, model: string, messages: ChatMessage[], storage: SessionStorage, sessionId: string): Promise<ReactiveCompactResult | null>;
+declare function tryReactiveCompact(provider: AIProvider, model: string, messages: ChatMessage[], storage: SessionStorage, sessionId: string, opts?: {
+    signal?: AbortSignal;
+}): Promise<ReactiveCompactResult | null>;
 
 /**
  * Disk-backed tool result storage.
@@ -664,8 +951,10 @@ declare function createAutoCompactTracking(maxFailures?: number): AutoCompactTra
  *
  * @param tokensFreed — tokens already reclaimed by microcompact/budget in
  *   this turn; subtracted from the estimate so we don't over-eagerly compact.
+ * @param querySource — the source of the current query; prevents recursive
+ *   compaction when called from a compact or session_memory context.
  */
-declare function shouldAutoCompact(messages: ChatMessage[], config: AutoCompactConfig, lastUsage?: ChatCompletionUsage, anchorMessageIndex?: number, tokensFreed?: number): boolean;
+declare function shouldAutoCompact(messages: ChatMessage[], config: AutoCompactConfig, lastUsage?: ChatCompletionUsage, anchorMessageIndex?: number, tokensFreed?: number, querySource?: string): boolean;
 /**
  * Check whether the circuit breaker allows another auto-compact attempt.
  */
@@ -701,6 +990,8 @@ interface ThreadConfig {
     hooks?: HookDefinition[];
     spawnSubagent?: (config: SubagentConfig) => SubagentRun;
     streamingToolExecution?: boolean;
+    /** Truncate individual tool results exceeding this character count. Default: 100000. */
+    maxResultChars?: number;
     userInputHandler?: (question: string) => Promise<string>;
     taskStore?: TaskStore;
     lspManager?: LspServerManager;
@@ -729,6 +1020,8 @@ interface ThreadConfig {
     outputFormat?: OutputFormat;
     /** Default structured output mode for all runs on this thread. */
     structuredOutputMode?: "alongside_tools" | "final_response";
+    /** When true, assert normalization invariants after every API message preparation. */
+    debug?: boolean;
 }
 declare class Thread {
     readonly sessionId: string;
@@ -753,10 +1046,13 @@ declare class Thread {
     private budgetState;
     private hasAttemptedReactiveCompact;
     private microcompactTokensFreed;
+    private querySource;
     private resumeRequested;
     private fileStateCache;
     private contentReplacementState;
     private denialTracker;
+    /** Tracks file paths read by ReadFile for post-compact reinjection. */
+    private recentlyReadFiles;
     constructor(config: ThreadConfig, opts?: ThreadOptions);
     run(prompt: string | ContentPart[], opts?: RunOptions): AsyncGenerator<StreamEvent, void, unknown>;
     /**
@@ -785,6 +1081,7 @@ declare class Thread {
     setModel(model: string): void;
     setProvider(provider: AIProvider, model?: string): void;
     getModel(): string;
+    getCwd(): string;
     abort(): void;
 }
 
@@ -917,6 +1214,7 @@ declare class Agent {
     private resolvedProvider;
     private fs;
     private computer;
+    private sandbox;
     private sessionDir;
     private skills;
     private skillsPaths;
@@ -968,13 +1266,15 @@ declare class Agent {
     private historySnipConfig;
     private outputFormat;
     private structuredOutputMode;
+    private providerPromise;
+    private initPromise;
     constructor(opts: AgentOptions);
     private ensureProvider;
     private getProvider;
     private getSkills;
     private getAllTools;
     private createSpawnSubagent;
-    createThread(opts?: ThreadOptions): Thread;
+    createThread(opts?: ThreadOptions): Promise<Thread>;
     listSessions(): Promise<SessionInfo[]>;
     getCostSummary(): CostSummary | null;
     /**
@@ -982,7 +1282,7 @@ declare class Agent {
      * messages (respecting compact boundaries), file checkpoint state, and
      * cost tracking state from the persisted JSONL transcript.
      */
-    resumeThread(sessionId: string, opts?: Omit<ThreadOptions, "sessionId" | "resume">): Thread;
+    resumeThread(sessionId: string, opts?: Omit<ThreadOptions, "sessionId" | "resume">): Promise<Thread>;
     /**
      * One-shot streaming: creates an ephemeral thread and yields events.
      * Auto-resolves string providers on first call (no need to call `init()`).
@@ -1012,6 +1312,7 @@ declare class Agent {
      * mcpServers, or lsp, so that createThread() has everything available synchronously.
      */
     init(): Promise<void>;
+    private doInit;
     /**
      * Run health checks on the provider, sandbox, MCP servers, and LSP servers.
      * Returns a structured report — useful for debugging integration issues.
@@ -1019,10 +1320,13 @@ declare class Agent {
      * @param timeoutMs Per-check timeout in milliseconds (default 10 000).
      */
     diagnose(timeoutMs?: number): Promise<DiagnoseResult>;
+    private get sandboxIndexPath();
+    private loadSandboxId;
+    private storeSandboxId;
     /**
      * Disconnect all MCP clients. Call when done with this Agent instance.
      */
     close(): Promise<void>;
 }
 
-export { type SandboxedLocalComputerOptions as $, Agent as A, type BudgetState as B, type ContextFile as C, type DockerContainer as D, type E2BSandboxInstance as E, E2BComputer as F, type E2BComputerOptions as G, E2BSandbox as H, type E2BSandboxOptions as I, type LocalSandboxOptions as J, type MicrocompactResult as K, LocalSandbox as L, type MicrocompactConfig as M, type ProviderName as N, type ReactiveCompactConfig as O, type ProjectContextConfig as P, type ReactiveCompactResult as Q, type RetryConfig as R, type Sandbox as S, type ThreadConfig as T, type ResolveProviderOptions as U, type RetryEvent as V, type RunCallbacks as W, type RunResult as X, SUPPORTED_PROVIDERS as Y, type SandboxConfig as Z, SandboxedLocalComputer as _, type SkillDefinition as a, type SnipConfig as a0, type SnipResult as a1, SpritesSandbox as a2, type SpritesSandboxOptions as a3, Thread as a4, type ThreadOptions as a5, type ToolResultBudgetConfig as a6, type ToolResultBudgetResult as a7, type ContentReplacementRecord as a8, type ToolResultSpillResult as a9, tryReactiveCompact as aA, webSearchToolPlaceholder as aB, type ToolResultStorageConfig as aa, type TracingConfig as ab, UnsandboxedLocal as ac, type UnsandboxedLocalOptions as ad, type WebSearchConfig as ae, type WebSearchResult as af, applyPersistedReplacements as ag, applySnipRemovals as ah, canAutoCompact as ai, createAutoCompactConfig as aj, createAutoCompactTracking as ak, createBudgetState as al, createContentReplacementState as am, createWebSearchTool as an, detectProvider as ao, enforceToolResultBudget as ap, enforceToolResultStorageBudget as aq, microcompactMessages as ar, persistToolResult as as, projectSnippedView as at, reconstructContentReplacementState as au, recordAutoCompactFailure as av, recordAutoCompactSuccess as aw, resolveProvider as ax, shouldAutoCompact as ay, snipMessagesByUuids 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 { 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 };

package/dist/{cache-DVqaCX8v.d.ts → cache-DsRqxx6v.d.ts}

@@ -1,4 +1,4 @@
-import { b as ChatMessage, T as ToolDefinition } from './types-3c88cRKH.js';
+import { b as ChatMessage, T as ToolDefinition } from './types-LrU4LRmX.js';
 
 /**
  * Provider-agnostic prompt caching utilities.

package/dist/{chunk-BGG2E6JD.js → chunk-3HEYCV26.js}

@@ -7,4 +7,4 @@ function generateUUID() {
 export {
   generateUUID
 };
-//# sourceMappingURL=chunk-BGG2E6JD.js.map
+//# sourceMappingURL=chunk-3HEYCV26.js.map

package/dist/chunk-3SK5GCI6.js

@@ -0,0 +1,75 @@
+// src/utils/zod.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function zodToJsonSchema(schema) {
+  const hit = cache.get(schema);
+  if (hit) return hit;
+  const zod = schema._zod ? schema : void 0;
+  if (!zod) {
+    throw new Error(
+      "zodToJsonSchema requires a Zod v4 schema. Install zod and pass a z.object(\u2026) schema."
+    );
+  }
+  let toJSONSchema;
+  try {
+    const sAny = schema;
+    if (typeof sAny._toJSONSchema === "function") {
+      const result = sAny._toJSONSchema();
+      cache.set(schema, result);
+      return result;
+    }
+    toJSONSchema = globalThis.__noumen_toJSONSchema;
+  } catch {
+  }
+  if (toJSONSchema) {
+    const result = toJSONSchema(schema);
+    cache.set(schema, result);
+    return result;
+  }
+  throw new Error(
+    "Could not convert Zod schema to JSON Schema. Call `registerZodToJsonSchema(toJSONSchema)` from zod/v4 or upgrade to Zod v4."
+  );
+}
+function registerZodToJsonSchema(fn) {
+  globalThis.__noumen_toJSONSchema = fn;
+}
+function formatZodValidationError(toolName, issues) {
+  if (!issues || !issues.issues.length) {
+    return `${toolName}: validation failed with unknown error`;
+  }
+  const parts = [];
+  const missing = issues.issues.filter(
+    (i) => i.code === "invalid_type" && i.message.includes("required")
+  );
+  const unrecognized = issues.issues.filter(
+    (i) => i.code === "unrecognized_keys"
+  );
+  const other = issues.issues.filter(
+    (i) => !missing.includes(i) && !unrecognized.includes(i)
+  );
+  if (missing.length) {
+    parts.push(
+      `Missing required parameter${missing.length > 1 ? "s" : ""}: ${missing.map((m) => formatPath(m.path)).join(", ")}`
+    );
+  }
+  if (unrecognized.length) {
+    parts.push(
+      `Unrecognized parameter${unrecognized.length > 1 ? "s" : ""}: ${unrecognized.map((u) => u.message).join(", ")}`
+    );
+  }
+  for (const issue of other) {
+    const path = formatPath(issue.path);
+    parts.push(`${path ? path + ": " : ""}${issue.message}`);
+  }
+  return `${toolName} failed due to the following ${parts.length > 1 ? "issues" : "issue"}:
+${parts.join("\n")}`;
+}
+function formatPath(path) {
+  return path.map((p, i) => typeof p === "number" ? `[${p}]` : i > 0 ? `.${p}` : p).join("");
+}
+
+export {
+  zodToJsonSchema,
+  registerZodToJsonSchema,
+  formatZodValidationError
+};
+//# sourceMappingURL=chunk-3SK5GCI6.js.map

package/dist/chunk-3SK5GCI6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/zod.ts"],"sourcesContent":["/**\n * Zod integration utilities. Users bring their own `zod` dependency — these\n * helpers accept duck-typed schemas so we don't force a hard dependency.\n */\n\nexport type JsonSchemaType = Record<string, unknown>;\n\n/**\n * Minimal interface matching Zod v4's safeParse return. Allows noumen to\n * validate tool input without depending on zod directly.\n */\nexport interface SafeParseResult {\n  success: boolean;\n  data?: unknown;\n  error?: {\n    issues: Array<{\n      code: string;\n      path: (string | number)[];\n      message: string;\n    }>;\n  };\n}\n\nexport interface ZodLikeSchema {\n  safeParse(data: unknown): SafeParseResult;\n}\n\nconst cache = new WeakMap<object, JsonSchemaType>();\n\n/**\n * Convert a Zod v4 schema to JSON Schema. Caches by schema identity.\n * Requires `zod/v4` to be installed — calls its native `toJSONSchema`.\n */\nexport function zodToJsonSchema(schema: ZodLikeSchema): JsonSchemaType {\n  const hit = cache.get(schema);\n  if (hit) return hit;\n\n  const zod = (schema as unknown as { _zod?: unknown })._zod\n    ? schema\n    : undefined;\n\n  if (!zod) {\n    throw new Error(\n      \"zodToJsonSchema requires a Zod v4 schema. Install zod and pass a z.object(…) schema.\",\n    );\n  }\n\n  let toJSONSchema: ((s: unknown) => JsonSchemaType) | undefined;\n  try {\n    // Dynamic import isn't possible synchronously, so we look for the\n    // schema's own conversion method first (Zod v4 attaches _toJSONSchema).\n    const sAny = schema as unknown as Record<string, unknown>;\n    if (typeof sAny._toJSONSchema === \"function\") {\n      const result = sAny._toJSONSchema() as JsonSchemaType;\n      cache.set(schema, result);\n      return result;\n    }\n    // Fallback: try the module-level toJSONSchema from zod/v4\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    toJSONSchema = (globalThis as unknown as Record<string, unknown>)\n      .__noumen_toJSONSchema as typeof toJSONSchema;\n  } catch {\n    // not available\n  }\n\n  if (toJSONSchema) {\n    const result = toJSONSchema(schema) as JsonSchemaType;\n    cache.set(schema, result);\n    return result;\n  }\n\n  throw new Error(\n    \"Could not convert Zod schema to JSON Schema. \" +\n      \"Call `registerZodToJsonSchema(toJSONSchema)` from zod/v4 or upgrade to Zod v4.\",\n  );\n}\n\n/**\n * Register the `toJSONSchema` function from `zod/v4` so `zodToJsonSchema` can use it.\n *\n * ```ts\n * import { toJSONSchema } from \"zod/v4\";\n * import { registerZodToJsonSchema } from \"noumen\";\n * registerZodToJsonSchema(toJSONSchema);\n * ```\n */\nexport function registerZodToJsonSchema(\n  fn: (schema: unknown) => JsonSchemaType,\n): void {\n  (globalThis as unknown as Record<string, unknown>).__noumen_toJSONSchema = fn;\n}\n\n/**\n * Format a Zod validation error into a human-readable string suitable\n * for feeding back to the model as a tool_result error.\n */\nexport function formatZodValidationError(\n  toolName: string,\n  issues: SafeParseResult[\"error\"],\n): string {\n  if (!issues || !issues.issues.length) {\n    return `${toolName}: validation failed with unknown error`;\n  }\n\n  const parts: string[] = [];\n\n  const missing = issues.issues.filter(\n    (i) => i.code === \"invalid_type\" && i.message.includes(\"required\"),\n  );\n  const unrecognized = issues.issues.filter(\n    (i) => i.code === \"unrecognized_keys\",\n  );\n  const other = issues.issues.filter(\n    (i) =>\n      !missing.includes(i) && !unrecognized.includes(i),\n  );\n\n  if (missing.length) {\n    parts.push(\n      `Missing required parameter${missing.length > 1 ? \"s\" : \"\"}: ${missing.map((m) => formatPath(m.path)).join(\", \")}`,\n    );\n  }\n  if (unrecognized.length) {\n    parts.push(\n      `Unrecognized parameter${unrecognized.length > 1 ? \"s\" : \"\"}: ${unrecognized.map((u) => u.message).join(\", \")}`,\n    );\n  }\n  for (const issue of other) {\n    const path = formatPath(issue.path);\n    parts.push(`${path ? path + \": \" : \"\"}${issue.message}`);\n  }\n\n  return `${toolName} failed due to the following ${parts.length > 1 ? \"issues\" : \"issue\"}:\\n${parts.join(\"\\n\")}`;\n}\n\nfunction formatPath(path: (string | number)[]): string {\n  return path\n    .map((p, i) => (typeof p === \"number\" ? `[${p}]` : i > 0 ? `.${p}` : p))\n    .join(\"\");\n}\n"],"mappings":";AA2BA,IAAM,QAAQ,oBAAI,QAAgC;AAM3C,SAAS,gBAAgB,QAAuC;AACrE,QAAM,MAAM,MAAM,IAAI,MAAM;AAC5B,MAAI,IAAK,QAAO;AAEhB,QAAM,MAAO,OAAyC,OAClD,SACA;AAEJ,MAAI,CAAC,KAAK;AACR,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI;AACJ,MAAI;AAGF,UAAM,OAAO;AACb,QAAI,OAAO,KAAK,kBAAkB,YAAY;AAC5C,YAAM,SAAS,KAAK,cAAc;AAClC,YAAM,IAAI,QAAQ,MAAM;AACxB,aAAO;AAAA,IACT;AAGA,mBAAgB,WACb;AAAA,EACL,QAAQ;AAAA,EAER;AAEA,MAAI,cAAc;AAChB,UAAM,SAAS,aAAa,MAAM;AAClC,UAAM,IAAI,QAAQ,MAAM;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,IAAI;AAAA,IACR;AAAA,EAEF;AACF;AAWO,SAAS,wBACd,IACM;AACN,EAAC,WAAkD,wBAAwB;AAC7E;AAMO,SAAS,yBACd,UACA,QACQ;AACR,MAAI,CAAC,UAAU,CAAC,OAAO,OAAO,QAAQ;AACpC,WAAO,GAAG,QAAQ;AAAA,EACpB;AAEA,QAAM,QAAkB,CAAC;AAEzB,QAAM,UAAU,OAAO,OAAO;AAAA,IAC5B,CAAC,MAAM,EAAE,SAAS,kBAAkB,EAAE,QAAQ,SAAS,UAAU;AAAA,EACnE;AACA,QAAM,eAAe,OAAO,OAAO;AAAA,IACjC,CAAC,MAAM,EAAE,SAAS;AAAA,EACpB;AACA,QAAM,QAAQ,OAAO,OAAO;AAAA,IAC1B,CAAC,MACC,CAAC,QAAQ,SAAS,CAAC,KAAK,CAAC,aAAa,SAAS,CAAC;AAAA,EACpD;AAEA,MAAI,QAAQ,QAAQ;AAClB,UAAM;AAAA,MACJ,6BAA6B,QAAQ,SAAS,IAAI,MAAM,EAAE,KAAK,QAAQ,IAAI,CAAC,MAAM,WAAW,EAAE,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IAClH;AAAA,EACF;AACA,MAAI,aAAa,QAAQ;AACvB,UAAM;AAAA,MACJ,yBAAyB,aAAa,SAAS,IAAI,MAAM,EAAE,KAAK,aAAa,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,IAC/G;AAAA,EACF;AACA,aAAW,SAAS,OAAO;AACzB,UAAM,OAAO,WAAW,MAAM,IAAI;AAClC,UAAM,KAAK,GAAG,OAAO,OAAO,OAAO,EAAE,GAAG,MAAM,OAAO,EAAE;AAAA,EACzD;AAEA,SAAO,GAAG,QAAQ,gCAAgC,MAAM,SAAS,IAAI,WAAW,OAAO;AAAA,EAAM,MAAM,KAAK,IAAI,CAAC;AAC/G;AAEA,SAAS,WAAW,MAAmC;AACrD,SAAO,KACJ,IAAI,CAAC,GAAG,MAAO,OAAO,MAAM,WAAW,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAE,EACtE,KAAK,EAAE;AACZ;","names":[]}