zeitlich 0.2.36 → 0.2.38

package/dist/{types-CADc5V_P.d.ts → types-DNr31FzL.d.ts}

@@ -2,7 +2,7 @@ import { Duration } from '@temporalio/common';
 import { ActivityFunctionWithOptions, QueryDefinition, ActivityInterfaceFor } from '@temporalio/workflow';
 import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
 import { z } from 'zod';
-import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, g as SandboxOps } from './types-DxCpFNv_.js';
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, d as SandboxCreateOptions, f as SandboxSnapshot, g as SandboxOps } from './types-yx0LzPGn.js';
 
 /**
  * A tool definition with a name, description, and Zod schema for arguments.
@@ -98,6 +98,17 @@ interface ToolHandlerResponse<TResult = null, TToolResponse = JsonValue> {
      * payloads through Temporal's activity payload limit.
      */
     resultAppended?: boolean;
+    /**
+     * When true, the session will rewind: any in-flight parallel tool calls
+     * are cancelled, previously appended tool results and the triggering
+     * assistant message are removed from the thread, and the LLM call that
+     * produced the tool calls is retried.
+     *
+     * The `toolResponse` for a rewinding tool call is ignored (never
+     * appended) since the session truncates the thread back to the
+     * pre-invocation state.
+     */
+    rewind?: boolean;
     /** Token usage from the tool execution (e.g. child agent invocations) */
     usage?: TokenUsage;
     /** Thread ID used by the handler (surfaced to the LLM for subagent thread continuation) */
@@ -186,6 +197,27 @@ interface ProcessToolCallsContext {
     /** Active sandbox ID (when a sandbox is configured for this session) */
     sandboxId?: string;
 }
+/**
+ * Signal that a tool handler requested a rewind. Attached to the
+ * {@link ProcessToolCallsResult} so the session can roll the thread
+ * back to the pre-invocation snapshot and retry the LLM call.
+ */
+interface RewindSignal {
+    toolCallId: string;
+    toolName: string;
+}
+/**
+ * Result returned by {@link ToolRouter.processToolCalls}.
+ *
+ * The object is a standard array of tool call results for successful
+ * tool calls (cancelled or rewinding siblings are omitted), extended
+ * with a `rewind` property when any tool in the batch requested a
+ * rewind. Using an array-with-property lets existing code that treats
+ * the return value as `ToolCallResultUnion[]` continue to work.
+ */
+type ProcessToolCallsResult<TResults extends Record<string, unknown>> = ToolCallResultUnion<TResults>[] & {
+    rewind?: RewindSignal;
+};
 /**
  * Result from PreToolUse hook - can block or modify execution
  */
@@ -344,7 +376,7 @@ interface ToolRouter<T extends ToolMap> {
      * @param toolCalls - Array of parsed tool calls to process
      * @param context - Optional context including turn number for hooks
      */
-    processToolCalls(toolCalls: ParsedToolCallUnion<T>[], context?: ProcessToolCallsContext): Promise<ToolCallResultUnion<InferToolResults<T>>[]>;
+    processToolCalls(toolCalls: ParsedToolCallUnion<T>[], context?: ProcessToolCallsContext): Promise<ProcessToolCallsResult<InferToolResults<T>>>;
     /**
      * Process tool calls matching a specific name with a custom handler.
      * Useful for overriding the default handler for specific cases.
@@ -797,6 +829,7 @@ type ThreadInit = {
     mode: "fork";
     threadId: string;
 };
+
 /**
  * Sandbox initialization strategy.
  *
@@ -807,7 +840,12 @@ type ThreadInit = {
  *   Paused sandboxes are automatically resumed. The shutdown policy applies
  *   on exit.
  * - `"fork"` — fork from an existing (or paused) sandbox; a new sandbox is
- *   created and owned by this session.
+ *   created and owned by this session. `options` is an optional per-call
+ *   override merged on top of the provider's static defaults.
+ * - `"from-snapshot"` — restore a fresh sandbox from a previously captured
+ *   {@link SandboxSnapshot}. The new sandbox is owned by this session.
+ *   `options` is an optional per-call override merged on top of the
+ *   provider's static defaults.
  * - `"inherit"` — use a sandbox owned by someone else (e.g. a parent agent).
  *   The session will **not** manage its lifecycle on exit.
  */
@@ -820,6 +858,11 @@ type SandboxInit = {
 } | {
     mode: "fork";
     sandboxId: string;
+    options?: SandboxCreateOptions;
+} | {
+    mode: "from-snapshot";
+    snapshot: SandboxSnapshot;
+    options?: SandboxCreateOptions;
 } | {
     mode: "inherit";
     sandboxId: string;
@@ -830,8 +873,11 @@ type SandboxInit = {
  * - `"destroy"` — tear down the sandbox entirely.
  * - `"pause"` — pause the sandbox so it can be resumed later.
  * - `"keep"` — leave the sandbox running (no-op on exit).
+ * - `"snapshot"` — capture a snapshot then destroy the sandbox. The snapshot
+ *   is surfaced on the session result so the caller can reuse it to spawn
+ *   future sandboxes.
  */
-type SandboxShutdown = "destroy" | "pause" | "keep";
+type SandboxShutdown = "destroy" | "pause" | "keep" | "snapshot";
 /**
  * Extended shutdown options available to subagent workflows.
  *
@@ -847,6 +893,14 @@ type SubagentSandboxShutdown = SandboxShutdown | "pause-until-parent-close" | "k
 type SubagentHandlerResponse<TResult = null, TToolResponse = JsonValue> = ToolHandlerResponse<TResult, TToolResponse> & {
     threadId: string;
     sandboxId?: string;
+    /** Snapshot captured on session exit when `sandboxShutdown === "snapshot"`. */
+    snapshot?: SandboxSnapshot;
+    /**
+     * Snapshot captured immediately after the sandbox was seeded (before the
+     * first agent turn) when `continuation === "snapshot"`. Only set on the
+     * first call that actually created the sandbox.
+     */
+    baseSnapshot?: SandboxSnapshot;
 };
 /**
  * Raw workflow input fields passed from parent to child workflow.
@@ -876,23 +930,31 @@ type SubagentContext = Record<string, unknown> | (() => Record<string, unknown>)
  * Sandbox configuration for a subagent.
  *
  * - `"none"` — no sandbox (default).
- * - `{ source: "inherit", continuation }` — reuse the parent's sandbox.
+ * - `{ source: "inherit", continuation, proxy }` — reuse the parent's sandbox.
  *   `continuation: "continue"` shares the parent sandbox directly;
  *   `continuation: "fork"` forks from the parent on every call.
- * - `{ source: "own", init?, continuation }` — the child gets its own sandbox.
- *   `init: "per-call"` (default) creates fresh each call (thread continuation
- *   uses the previous sandbox). `init: "once"` creates on the first call and
- *   stores it for all subsequent calls.
+ * - `{ source: "own", init?, continuation, proxy }` — the child gets its own
+ *   sandbox. `init: "per-call"` (default) creates fresh each call (thread
+ *   continuation uses the previous sandbox). `init: "once"` creates on the
+ *   first call and stores it for all subsequent calls.
+ *
+ * `proxy` is a factory that returns workflow-safe sandbox ops matching the
+ * subagent's own activities. Called once inside `createSubagentHandler` with
+ * `scope = agentName`, so the returned proxy resolves to the same activity
+ * prefix the child session uses. The parent uses it to destroy lingering
+ * sandboxes and delete stored snapshots at shutdown.
  */
 type SubagentSandboxConfig = "none" | {
     source: "inherit";
     continuation: "continue" | "fork";
     shutdown?: SubagentSandboxShutdown;
+    proxy: (scope: string) => SandboxOps;
 } | {
     source: "own";
     init?: "per-call" | "once";
-    continuation: "continue" | "fork";
+    continuation: "continue" | "fork" | "snapshot";
     shutdown?: SubagentSandboxShutdown;
+    proxy: (scope: string) => SandboxOps;
 };
 /**
  * Configuration for a subagent that can be spawned by the parent workflow.
@@ -930,6 +992,21 @@ interface SubagentConfig<TResult extends z.ZodType = z.ZodType> {
      * Sandbox strategy for this subagent.
      *
      * @see {@link SubagentSandboxConfig}
+     *
+     * @example
+     * ```ts
+     * import { proxyDaytonaSandboxOps } from "zeitlich/adapters/sandbox/daytona/workflow";
+     *
+     * const researcher: SubagentConfig = {
+     *   agentName: "researcher",
+     *   workflow: researcherWorkflow,
+     *   sandbox: {
+     *     source: "own",
+     *     continuation: "snapshot",
+     *     proxy: proxyDaytonaSandboxOps,
+     *   },
+     * };
+     * ```
      */
     sandbox?: SubagentSandboxConfig;
 }
@@ -963,18 +1040,16 @@ interface SubagentHooks<TArgs = unknown, TResult = unknown> {
     }) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
 }
 /**
- * Extended response from the subagent `fn` — includes optional cleanup callbacks
- * stripped before signaling the parent.
+ * Response returned from a subagent workflow `fn`.
  *
  * When `TSandboxShutdown` is `"pause-until-parent-close"` or
- * `"keep-until-parent-close"`, both `destroySandbox` and `sandboxId` become
- * required so the parent can coordinate cleanup.
+ * `"keep-until-parent-close"`, the parent needs the `sandboxId` to destroy
+ * the sandbox at its own shutdown, so the field becomes required.
  */
 type SubagentFnResult<TResult = null, TSandboxShutdown extends SubagentSandboxShutdown = SubagentSandboxShutdown> = SubagentHandlerResponse<TResult> & (TSandboxShutdown extends "pause-until-parent-close" | "keep-until-parent-close" ? {
-    destroySandbox: () => Promise<void>;
     sandboxId: string;
 } : {
-    destroySandbox?: () => Promise<void>;
+    sandboxId?: string;
 });
 /**
  * Session config fields passed from parent to child workflow.
@@ -1045,6 +1120,16 @@ interface AgentResponse<M = unknown> {
     message: M;
     rawToolCalls: RawToolCall[];
     usage?: TokenUsage;
+    /**
+     * Number of stored messages in the thread at the moment the LLM was
+     * invoked — i.e. *before* the assistant message is appended. The
+     * session uses this as a rewind snapshot so it can roll the thread
+     * back to this exact state if a tool requests a rewind.
+     *
+     * Adapters compute this for free from the array of stored messages
+     * they load when preparing the payload.
+     */
+    threadLengthAtCall?: number;
 }
 /**
  * Type signature for workflow-specific runAgent activity
@@ -1095,6 +1180,14 @@ interface ThreadOps<TContent = string> {
     appendSystemMessage(threadId: string, id: string, content: unknown, threadKey?: string): Promise<void>;
     /** Copy all messages from sourceThreadId into a new thread at targetThreadId */
     forkThread(sourceThreadId: string, targetThreadId: string, threadKey?: string): Promise<void>;
+    /**
+     * Truncate the thread back to `length` messages. Used by the session's
+     * rewind flow to roll the thread back before retrying a turn. The
+     * session obtains `length` from `AgentResponse.threadLengthAtCall`,
+     * which the model invoker computes for free from the messages it
+     * loaded before invoking the LLM.
+     */
+    truncateThread(threadId: string, length: number, threadKey?: string): Promise<void>;
 }
 /**
  * Composes an adapter prefix + workflow scope for activity naming.
@@ -1221,6 +1314,17 @@ type SessionResult<M, TState extends JsonSerializable<TState>, HasSandbox extend
     finalMessage: M | null;
     exitReason: SessionExitReason;
     usage: ReturnType<AgentStateManager<TState>["getTotalUsage"]>;
+    /**
+     * Snapshot captured on exit when `sandboxShutdown === "snapshot"`.
+     */
+    snapshot?: SandboxSnapshot;
+    /**
+     * Snapshot captured immediately after sandbox seeding (before the agent
+     * loop starts) when `sandbox.mode === "new"` and
+     * `sandboxShutdown === "snapshot"`. Intended as a reusable "base" for new
+     * threads that want to skip re-seeding.
+     */
+    baseSnapshot?: SandboxSnapshot;
 } & (HasSandbox extends true ? {
     sandboxId: string;
 } : {
@@ -1232,4 +1336,4 @@ interface ZeitlichSession<M = unknown, HasSandbox extends boolean = boolean> {
     }): Promise<SessionResult<M, T, HasSandbox>>;
 }
 
-export { type SessionEndHook as $, type AgentResponse as A, type BaseAgentState as B, type PostToolUseFailureHookResult as C, type PostToolUseHook as D, type PostToolUseHookContext as E, type FileEntryMetadata as F, type PreHumanMessageAppendHook as G, type Hooks as H, type InferToolResults as I, type JsonValue as J, type PreHumanMessageAppendHookContext as K, type PreToolUseHook as L, type ModelInvokerConfig as M, type PreToolUseHookContext as N, type PreToolUseHookResult as O, type PrefixedThreadOps as P, type ProcessToolCallsContext as Q, type RouterContext as R, type ScopedPrefix as S, type ThreadOps as T, type RawToolCall as U, type VirtualFsContext as V, type RunAgentActivity as W, type SandboxInit as X, type SandboxShutdown as Y, type SerializableToolDefinition as Z, type SessionConfig as _, type ModelInvoker as a, type SessionEndHookContext as a0, type SessionExitReason as a1, type SessionResult as a2, type SessionStartHook as a3, type SessionStartHookContext as a4, type SubagentConfig as a5, type SubagentDefinition as a6, type SubagentFnResult as a7, type SubagentHandlerResponse as a8, type SubagentHooks as a9, isTerminalStatus as aA, type ToolRouterOptions as aB, type SubagentSandboxConfig as aa, type SubagentSandboxShutdown as ab, type SubagentSessionInput as ac, type SubagentWorkflow as ad, type SubagentWorkflowInput as ae, type TaskStatus as af, type ThreadInit as ag, type TokenUsage as ah, type ToolArgs as ai, type ToolCallResult as aj, type ToolCallResultUnion as ak, type ToolDefinition as al, type ToolHandler as am, type ToolHooks as an, type ToolMap as ao, type ToolNames as ap, type ToolResult as aq, type ToolRouter as ar, type ToolRouterHooks as as, type ToolWithHandler as at, VirtualFileSystem as au, type VirtualFileTree as av, type VirtualFsOps as aw, type VirtualFsState as ax, type WorkflowTask as ay, type ZeitlichSession as az, type ToolHandlerResponse as b, type ActivityToolHandler as c, type ToolResultConfig as d, type RunAgentConfig as e, type SkillProvider as f, type SkillMetadata as g, type Skill as h, type FileResolver as i, type TreeMutation as j, type PrefixedVirtualFsOps as k, type AgentConfig as l, type AgentFile as m, type AgentState as n, type AgentStateManager as o, type AgentStatus as p, type AppendToolResultFn as q, type FileEntry as r, type JsonPrimitive as s, type JsonSerializable as t, type ParsedToolCall as u, type ParsedToolCallUnion as v, type PostHumanMessageAppendHook as w, type PostHumanMessageAppendHookContext as x, type PostToolUseFailureHook as y, type PostToolUseFailureHookContext as z };
+export { type SerializableToolDefinition as $, type AgentResponse as A, type BaseAgentState as B, type PostToolUseFailureHookResult as C, type PostToolUseHook as D, type PostToolUseHookContext as E, type FileEntryMetadata as F, type PreHumanMessageAppendHook as G, type Hooks as H, type InferToolResults as I, type JsonValue as J, type PreHumanMessageAppendHookContext as K, type PreToolUseHook as L, type ModelInvokerConfig as M, type PreToolUseHookContext as N, type PreToolUseHookResult as O, type PrefixedThreadOps as P, type ProcessToolCallsContext as Q, type RouterContext as R, type ScopedPrefix as S, type ThreadOps as T, type ProcessToolCallsResult as U, type VirtualFsContext as V, type RawToolCall as W, type RewindSignal as X, type RunAgentActivity as Y, type SandboxInit as Z, type SandboxShutdown as _, type ModelInvoker as a, type SessionConfig as a0, type SessionEndHook as a1, type SessionEndHookContext as a2, type SessionExitReason as a3, type SessionResult as a4, type SessionStartHook as a5, type SessionStartHookContext as a6, type SubagentConfig as a7, type SubagentDefinition as a8, type SubagentFnResult as a9, type WorkflowTask as aA, type ZeitlichSession as aB, isTerminalStatus as aC, type ToolRouterOptions as aD, type SubagentHandlerResponse as aa, type SubagentHooks as ab, type SubagentSandboxConfig as ac, type SubagentSandboxShutdown as ad, type SubagentSessionInput as ae, type SubagentWorkflow as af, type SubagentWorkflowInput as ag, type TaskStatus as ah, type ThreadInit as ai, type TokenUsage as aj, type ToolArgs as ak, type ToolCallResult as al, type ToolCallResultUnion as am, type ToolDefinition as an, type ToolHandler as ao, type ToolHooks as ap, type ToolMap as aq, type ToolNames as ar, type ToolResult as as, type ToolRouter as at, type ToolRouterHooks as au, type ToolWithHandler as av, VirtualFileSystem as aw, type VirtualFileTree as ax, type VirtualFsOps as ay, type VirtualFsState as az, type ToolHandlerResponse as b, type ActivityToolHandler as c, type ToolResultConfig as d, type RunAgentConfig as e, type SkillProvider as f, type SkillMetadata as g, type Skill as h, type FileResolver as i, type TreeMutation as j, type PrefixedVirtualFsOps as k, type AgentConfig as l, type AgentFile as m, type AgentState as n, type AgentStateManager as o, type AgentStatus as p, type AppendToolResultFn as q, type FileEntry as r, type JsonPrimitive as s, type JsonSerializable as t, type ParsedToolCall as u, type ParsedToolCallUnion as v, type PostHumanMessageAppendHook as w, type PostHumanMessageAppendHookContext as x, type PostToolUseFailureHook as y, type PostToolUseFailureHookContext as z };

package/dist/{types-CBH54cwr.d.cts → types-lm8tMNJQ.d.cts}

@@ -1,4 +1,4 @@
-import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-DxCpFNv_.cjs';
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-yx0LzPGn.cjs';
 import { BedrockAgentCoreClient, BedrockAgentCoreClientConfig } from '@aws-sdk/client-bedrock-agentcore';
 
 /**

package/dist/{types-DxCpFNv_.d.cts → types-yx0LzPGn.d.cts}

@@ -13,6 +13,15 @@ interface FileStat {
     size: number;
     mtime: Date;
 }
+interface SandboxNetworkConfig {
+    allowOut?: string[];
+    denyOut?: string[];
+    allowPublicTraffic?: boolean;
+}
+interface SandboxLifecycleConfig {
+    onTimeout: "kill" | "pause";
+    autoResume?: boolean;
+}
 /**
  * Provider-agnostic filesystem interface.
  *
@@ -83,6 +92,16 @@ interface SandboxCreateOptions {
     initialFiles?: Record<string, string | Uint8Array>;
     /** Environment variables available inside the sandbox */
     env?: Record<string, string>;
+    /** Key-value metadata surfaced via provider list/query APIs */
+    metadata?: Record<string, string>;
+    /** Sandbox idle timeout in milliseconds */
+    timeoutMs?: number;
+    /** Enable or disable outbound internet access */
+    allowInternetAccess?: boolean;
+    /** Outbound network allow/deny rules */
+    network?: SandboxNetworkConfig;
+    /** Sandbox timeout behaviour */
+    lifecycle?: SandboxLifecycleConfig;
 }
 interface SandboxCreateResult {
     sandbox: Sandbox;
@@ -96,9 +115,23 @@ interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateO
     pause(sandboxId: string, ttlSeconds?: number): Promise<void>;
     /** Resume a paused sandbox. No-op if already running. */
     resume(sandboxId: string): Promise<void>;
-    snapshot(sandboxId: string): Promise<SandboxSnapshot>;
-    restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
-    fork(sandboxId: string): Promise<Sandbox>;
+    /**
+     * Capture a snapshot of a running sandbox. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    snapshot(sandboxId: string, options?: TOptions): Promise<SandboxSnapshot>;
+    /**
+     * Restore a sandbox from a snapshot. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    restore(snapshot: SandboxSnapshot, options?: TOptions): Promise<Sandbox>;
+    /** Delete a previously captured snapshot. No-op if already deleted. */
+    deleteSnapshot(snapshot: SandboxSnapshot): Promise<void>;
+    /**
+     * Fork a running sandbox into a new one. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    fork(sandboxId: string, options?: TOptions): Promise<Sandbox>;
 }
 interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> {
     createSandbox(options?: TOptions, ctx?: TCtx): Promise<{
@@ -108,8 +141,14 @@ interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOption
     pauseSandbox(sandboxId: string): Promise<void>;
     /** Resume a paused sandbox. No-op if already running. */
     resumeSandbox(sandboxId: string): Promise<void>;
-    snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
-    forkSandbox(sandboxId: string): Promise<string>;
+    /** Capture a snapshot. `options` is a per-call override merged on top of provider defaults. */
+    snapshotSandbox(sandboxId: string, options?: TOptions): Promise<SandboxSnapshot>;
+    /** Create a fresh sandbox from a snapshot. `options` is a per-call override merged on top of provider defaults. */
+    restoreSandbox(snapshot: SandboxSnapshot, options?: TOptions): Promise<string>;
+    /** Delete a previously captured snapshot. No-op if already deleted. */
+    deleteSandboxSnapshot(snapshot: SandboxSnapshot): Promise<void>;
+    /** Fork a running sandbox. `options` is a per-call override merged on top of provider defaults. */
+    forkSandbox(sandboxId: string, options?: TOptions): Promise<string>;
 }
 /**
  * Maps generic {@link SandboxOps} method names to adapter-prefixed names.

package/dist/{types-DxCpFNv_.d.ts → types-yx0LzPGn.d.ts}

@@ -13,6 +13,15 @@ interface FileStat {
     size: number;
     mtime: Date;
 }
+interface SandboxNetworkConfig {
+    allowOut?: string[];
+    denyOut?: string[];
+    allowPublicTraffic?: boolean;
+}
+interface SandboxLifecycleConfig {
+    onTimeout: "kill" | "pause";
+    autoResume?: boolean;
+}
 /**
  * Provider-agnostic filesystem interface.
  *
@@ -83,6 +92,16 @@ interface SandboxCreateOptions {
     initialFiles?: Record<string, string | Uint8Array>;
     /** Environment variables available inside the sandbox */
     env?: Record<string, string>;
+    /** Key-value metadata surfaced via provider list/query APIs */
+    metadata?: Record<string, string>;
+    /** Sandbox idle timeout in milliseconds */
+    timeoutMs?: number;
+    /** Enable or disable outbound internet access */
+    allowInternetAccess?: boolean;
+    /** Outbound network allow/deny rules */
+    network?: SandboxNetworkConfig;
+    /** Sandbox timeout behaviour */
+    lifecycle?: SandboxLifecycleConfig;
 }
 interface SandboxCreateResult {
     sandbox: Sandbox;
@@ -96,9 +115,23 @@ interface SandboxProvider<TOptions extends SandboxCreateOptions = SandboxCreateO
     pause(sandboxId: string, ttlSeconds?: number): Promise<void>;
     /** Resume a paused sandbox. No-op if already running. */
     resume(sandboxId: string): Promise<void>;
-    snapshot(sandboxId: string): Promise<SandboxSnapshot>;
-    restore(snapshot: SandboxSnapshot): Promise<Sandbox>;
-    fork(sandboxId: string): Promise<Sandbox>;
+    /**
+     * Capture a snapshot of a running sandbox. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    snapshot(sandboxId: string, options?: TOptions): Promise<SandboxSnapshot>;
+    /**
+     * Restore a sandbox from a snapshot. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    restore(snapshot: SandboxSnapshot, options?: TOptions): Promise<Sandbox>;
+    /** Delete a previously captured snapshot. No-op if already deleted. */
+    deleteSnapshot(snapshot: SandboxSnapshot): Promise<void>;
+    /**
+     * Fork a running sandbox into a new one. `options` is a per-call override
+     * merged on top of the provider's static defaults.
+     */
+    fork(sandboxId: string, options?: TOptions): Promise<Sandbox>;
 }
 interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOptions, TCtx = unknown> {
     createSandbox(options?: TOptions, ctx?: TCtx): Promise<{
@@ -108,8 +141,14 @@ interface SandboxOps<TOptions extends SandboxCreateOptions = SandboxCreateOption
     pauseSandbox(sandboxId: string): Promise<void>;
     /** Resume a paused sandbox. No-op if already running. */
     resumeSandbox(sandboxId: string): Promise<void>;
-    snapshotSandbox(sandboxId: string): Promise<SandboxSnapshot>;
-    forkSandbox(sandboxId: string): Promise<string>;
+    /** Capture a snapshot. `options` is a per-call override merged on top of provider defaults. */
+    snapshotSandbox(sandboxId: string, options?: TOptions): Promise<SandboxSnapshot>;
+    /** Create a fresh sandbox from a snapshot. `options` is a per-call override merged on top of provider defaults. */
+    restoreSandbox(snapshot: SandboxSnapshot, options?: TOptions): Promise<string>;
+    /** Delete a previously captured snapshot. No-op if already deleted. */
+    deleteSandboxSnapshot(snapshot: SandboxSnapshot): Promise<void>;
+    /** Fork a running sandbox. `options` is a per-call override merged on top of provider defaults. */
+    forkSandbox(sandboxId: string, options?: TOptions): Promise<string>;
 }
 /**
  * Maps generic {@link SandboxOps} method names to adapter-prefixed names.

package/dist/{workflow-DhtWRovz.d.cts → workflow-CSCkpwAL.d.ts}

@@ -1,5 +1,5 @@
-import { ao as ToolMap, _ as SessionConfig, az as ZeitlichSession, Y as SandboxShutdown, ag as ThreadInit, X as SandboxInit, t as JsonSerializable, B as BaseAgentState, o as AgentStateManager, aB as ToolRouterOptions, ar as ToolRouter, R as RouterContext, J as JsonValue, at as ToolWithHandler, v as ParsedToolCallUnion, ap as ToolNames, a6 as SubagentDefinition, a9 as SubagentHooks, aa as SubagentSandboxConfig, a5 as SubagentConfig, ab as SubagentSandboxShutdown, ac as SubagentSessionInput, a7 as SubagentFnResult, a3 as SessionStartHook, $ as SessionEndHook, D as PostToolUseHook, y as PostToolUseFailureHook, a1 as SessionExitReason, ah as TokenUsage, e as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, av as VirtualFileTree, j as TreeMutation, r as FileEntry, aw as VirtualFsOps, g as SkillMetadata, h as Skill, b as ToolHandlerResponse, am as ToolHandler, ay as WorkflowTask, c as ActivityToolHandler } from './types-DQ1l_gXL.cjs';
-import { g as SandboxOps } from './types-DxCpFNv_.cjs';
+import { aq as ToolMap, a0 as SessionConfig, aB as ZeitlichSession, _ as SandboxShutdown, ai as ThreadInit, Z as SandboxInit, t as JsonSerializable, B as BaseAgentState, o as AgentStateManager, aD as ToolRouterOptions, at as ToolRouter, R as RouterContext, J as JsonValue, av as ToolWithHandler, v as ParsedToolCallUnion, ar as ToolNames, a8 as SubagentDefinition, ab as SubagentHooks, ac as SubagentSandboxConfig, a7 as SubagentConfig, ad as SubagentSandboxShutdown, ae as SubagentSessionInput, a9 as SubagentFnResult, a5 as SessionStartHook, a1 as SessionEndHook, D as PostToolUseHook, y as PostToolUseFailureHook, a3 as SessionExitReason, aj as TokenUsage, e as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, ax as VirtualFileTree, j as TreeMutation, r as FileEntry, ay as VirtualFsOps, g as SkillMetadata, h as Skill, b as ToolHandlerResponse, ao as ToolHandler, aA as WorkflowTask, c as ActivityToolHandler } from './types-DNr31FzL.js';
+import { g as SandboxOps } from './types-yx0LzPGn.js';
 import z$1, { z } from 'zod';
 import { Sinks, proxyActivities } from '@temporalio/workflow';
 

package/dist/{workflow-P2pTSfKu.d.ts → workflow-DuvMZ8Vm.d.cts}

@@ -1,5 +1,5 @@
-import { ao as ToolMap, _ as SessionConfig, az as ZeitlichSession, Y as SandboxShutdown, ag as ThreadInit, X as SandboxInit, t as JsonSerializable, B as BaseAgentState, o as AgentStateManager, aB as ToolRouterOptions, ar as ToolRouter, R as RouterContext, J as JsonValue, at as ToolWithHandler, v as ParsedToolCallUnion, ap as ToolNames, a6 as SubagentDefinition, a9 as SubagentHooks, aa as SubagentSandboxConfig, a5 as SubagentConfig, ab as SubagentSandboxShutdown, ac as SubagentSessionInput, a7 as SubagentFnResult, a3 as SessionStartHook, $ as SessionEndHook, D as PostToolUseHook, y as PostToolUseFailureHook, a1 as SessionExitReason, ah as TokenUsage, e as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, av as VirtualFileTree, j as TreeMutation, r as FileEntry, aw as VirtualFsOps, g as SkillMetadata, h as Skill, b as ToolHandlerResponse, am as ToolHandler, ay as WorkflowTask, c as ActivityToolHandler } from './types-CADc5V_P.js';
-import { g as SandboxOps } from './types-DxCpFNv_.js';
+import { aq as ToolMap, a0 as SessionConfig, aB as ZeitlichSession, _ as SandboxShutdown, ai as ThreadInit, Z as SandboxInit, t as JsonSerializable, B as BaseAgentState, o as AgentStateManager, aD as ToolRouterOptions, at as ToolRouter, R as RouterContext, J as JsonValue, av as ToolWithHandler, v as ParsedToolCallUnion, ar as ToolNames, a8 as SubagentDefinition, ab as SubagentHooks, ac as SubagentSandboxConfig, a7 as SubagentConfig, ad as SubagentSandboxShutdown, ae as SubagentSessionInput, a9 as SubagentFnResult, a5 as SessionStartHook, a1 as SessionEndHook, D as PostToolUseHook, y as PostToolUseFailureHook, a3 as SessionExitReason, aj as TokenUsage, e as RunAgentConfig, A as AgentResponse, F as FileEntryMetadata, ax as VirtualFileTree, j as TreeMutation, r as FileEntry, ay as VirtualFsOps, g as SkillMetadata, h as Skill, b as ToolHandlerResponse, ao as ToolHandler, aA as WorkflowTask, c as ActivityToolHandler } from './types-C06FwR96.cjs';
+import { g as SandboxOps } from './types-yx0LzPGn.cjs';
 import z$1, { z } from 'zod';
 import { Sinks, proxyActivities } from '@temporalio/workflow';