zeitlich 0.2.40 → 0.2.42

package/dist/{types-DeQH84C_.d.ts → types-CdALEF3z.d.cts}

@@ -1,8 +1,7 @@
-import { Duration } from '@temporalio/common';
 import { ActivityFunctionWithOptions, QueryDefinition, ChildWorkflowOptions, ActivityInterfaceFor } from '@temporalio/workflow';
 import { UpdateDefinition } from '@temporalio/common/lib/interfaces';
 import { z } from 'zod';
-import { f as SandboxSnapshot, a as SandboxFileSystem, F as FileStat, D as DirentEntry, d as SandboxCreateOptions, g as SandboxOps } from './types-yx0LzPGn.js';
+import { g as SandboxSnapshot, c as SandboxFileSystem, F as FileStat, D as DirentEntry, a as SandboxCreateOptions, S as SandboxOps, h as SandboxCapability } from './types-CJ7tCdl6.cjs';
 
 /**
  * A tool definition with a name, description, and Zod schema for arguments.
@@ -544,6 +543,13 @@ declare class VirtualFileSystem<TCtx = unknown, TMeta = FileEntryMetadata> imple
     getEntry(path: string): FileEntry<TMeta> | undefined;
     readFile(path: string): Promise<string>;
     readFileBuffer(path: string): Promise<Uint8Array>;
+    /**
+     * Resolve the string content for an entry, preferring inline content
+     * carried on the entry itself before consulting the resolver. Used by
+     * `readFile`, `appendFile`, and `cp` so all read paths agree on the
+     * lookup precedence.
+     */
+    private readEntryContent;
     exists(path: string): Promise<boolean>;
     stat(path: string): Promise<FileStat>;
     readdir(path: string): Promise<string[]>;
@@ -577,6 +583,25 @@ interface FileEntry<TMeta = FileEntryMetadata> {
     /** ISO-8601 date string (JSON-safe) */
     mtime: string;
     metadata: TMeta;
+    /**
+     * Optional inline content carried directly on the entry. When present the
+     * {@link VirtualFileSystem} returns this string from `readFile` /
+     * `readFileBuffer` (and uses it as the source for `cp` / `appendFile`)
+     * without consulting the resolver.
+     *
+     * Use this for files that exist purely in workflow state and have no
+     * backing in the consumer's data layer (e.g. skill resources bundled at
+     * session creation time). Because the content travels with the entry,
+     * any tool handler that constructs a `VirtualFileSystem` from `fileTree`
+     * sees the same content — no separate `inlineFiles` plumbing required.
+     *
+     * Read-only: entries with `inlineContent` reject in-place mutations
+     * (`writeFile`, `appendFile`, `rm`, `mv` of the entry, `cp` over the
+     * entry as destination). The resolver has no contract for the synthetic
+     * `id` these entries carry, so attempting a mutation throws an `EROFS`
+     * error instead of silently routing a doomed call through the resolver.
+     */
+    inlineContent?: string;
 }
 /**
  * Flat list of file entries.
@@ -971,6 +996,212 @@ type SubagentDefinition<TResult extends z.ZodType = z.ZodType, TContext extends
 };
 /** Context value or factory — resolved at invocation time when a function is provided */
 type SubagentContext = Record<string, unknown> | (() => Record<string, unknown>);
+/** Shutdown classes that the runtime treats equivalently for cap purposes. */
+type _ShutdownPauseLike = "pause" | "pause-until-parent-close";
+type _ShutdownKeepLike = "keep" | "keep-until-parent-close";
+/**
+ * Caps the child session's sandbox-init dispatch invokes for a given
+ * `(mode, shutdown)`. Mirror of `src/lib/session/session.ts:230-314`.
+ */
+type _ChildModeCaps<Mode, Shutdown> = (Mode extends "fork" ? "fork" : never) | (Mode extends "from-snapshot" ? "restore" : never) | (Mode extends "continue" ? Shutdown extends "pause-until-parent-close" ? "resume" : never : never);
+/**
+ * Caps the child session's exit dispatch invokes for a given `shutdown`.
+ * Only fires when `sandboxOwned` is true (mode != "inherit"). Mirror of
+ * `src/lib/session/session.ts:598-615`.
+ */
+type _ChildShutdownCaps<Mode, Shutdown> = Mode extends "inherit" ? never : (Shutdown extends _ShutdownPauseLike ? "pause" : never) | (Shutdown extends "snapshot" ? "snapshot" : never);
+/**
+ * Caps captured on entry for `mode: "new"` + `shutdown: "snapshot"`
+ * (the seeding-base-snapshot path). Mirror of
+ * `src/lib/session/session.ts:316-317`.
+ */
+type _ChildSeedCaps<Mode, Shutdown> = Mode extends "new" ? Shutdown extends "snapshot" ? "snapshot" : never : never;
+/**
+ * Total caps a single child-session invocation calls for the specific
+ * `(mode, shutdown)` pair the parent passes. The proxy field's required
+ * cap union is the union of this across every `(mode, shutdown)` the
+ * runtime might inject for the given config.
+ */
+type _ChildSessionCaps<Mode, Shutdown> = _ChildModeCaps<Mode, Shutdown> | _ChildShutdownCaps<Mode, Shutdown> | _ChildSeedCaps<Mode, Shutdown>;
+/**
+ * Resolves the user's `shutdown` value through the auto-injection rules
+ * for `(source: "own", continuation: "continue")`. Mirror of
+ * `src/lib/subagent/handler.ts:373-389`:
+ *
+ *   - `pause` / `pause-until-parent-close` / `keep` / `keep-until-parent-close`
+ *     → propagate (`alreadySurvives = true`).
+ *   - everything else (undefined, "destroy", "snapshot") → injected
+ *     `"pause"` (subsequent calls) or `"pause-until-parent-close"`
+ *     (creator first call). Type-level: union both.
+ */
+type _ContinueShutdown<S> = S extends _ShutdownPauseLike | _ShutdownKeepLike ? S : "pause" | "pause-until-parent-close";
+/**
+ * Resolves the user's `shutdown` value through the auto-injection rules
+ * for `(source: "own", continuation: "fork", init: "once")`. Same shape
+ * as `_ContinueShutdown` because both are `mustSurvive` paths.
+ */
+type _ForkOnceShutdown<S> = _ContinueShutdown<S>;
+/**
+ * Modes the child session may be invoked under for `(source: "own",
+ * continuation: "continue")`. First call has no `baseSandboxId` (mode
+ * "new"); subsequent calls reuse it (mode "continue"). The type takes
+ * the union — the matrix can't tell first vs. subsequent statically.
+ */
+type _OwnContinueModes = "new" | "continue";
+/**
+ * Modes the child session may be invoked under for `(source: "own",
+ * continuation: "fork")`. Same first-vs-subsequent shape as continue.
+ */
+type _OwnForkModes = "new" | "fork";
+/**
+ * Modes the child session may be invoked under for `(source: "own",
+ * continuation: "snapshot")`. First call (no base snapshot yet) uses
+ * "new"; subsequent calls (or `init: "once"` after the first creator
+ * publishes a base) use "from-snapshot".
+ */
+type _OwnSnapshotModes = "new" | "from-snapshot";
+/**
+ * Caps required on a subagent's `proxy` for the parent's own gated
+ * calls. The parent only ever calls `destroySandbox` (base) and
+ * `deleteSandboxSnapshot` (`continuation: "snapshot"` cleanup).
+ */
+type _ParentLocalCaps<C> = C extends {
+    continuation: "snapshot";
+} ? "snapshot" : never;
+/**
+ * **SSOT type.** The full cap union a subagent's `proxy` must expose,
+ * derived from `(source, continuation, init, shutdown)`.
+ *
+ * The shape mirrors the rows of the runtime decision table in
+ * `resolveSubagentLifecycle` (`src/lib/subagent/handler.ts`): each
+ * branch here corresponds to exactly one runtime branch, and adding a
+ * new runtime branch requires adding a matching branch here. The
+ * `(adapter × continuation × shutdown × init × source)` matrix in
+ * `src/lib/sandbox/capability-types.test.ts` enforces agreement.
+ */
+type SubagentRequiredCaps<C> = C extends "none" ? never : C extends {
+    source: "inherit";
+    continuation: "continue";
+} ? never : C extends {
+    source: "inherit";
+    continuation: "fork";
+} ? "fork" | _ChildSessionCaps<"fork", C extends {
+    shutdown: infer S;
+} ? S : "destroy"> | _ParentLocalCaps<C> : C extends {
+    source: "own";
+    continuation: "snapshot";
+} ? _ChildSessionCaps<_OwnSnapshotModes, "snapshot"> | _ParentLocalCaps<C> : C extends {
+    source: "own";
+    continuation: "continue";
+} ? _ChildSessionCaps<_OwnContinueModes, _ContinueShutdown<C extends {
+    shutdown: infer S;
+} ? S : undefined>> | _ParentLocalCaps<C> : C extends {
+    source: "own";
+    continuation: "fork";
+    init?: infer I;
+} ? "fork" | _ChildSessionCaps<_OwnForkModes, I extends "once" ? _ForkOnceShutdown<C extends {
+    shutdown: infer S;
+} ? S : undefined> : C extends {
+    shutdown: infer S;
+} ? S extends undefined ? "destroy" : S : "destroy"> | _ParentLocalCaps<C> : never;
+/**
+ * Backwards-compatible alias retained for external callers that imported
+ * the old name. Resolves through the SSOT against a synthetic
+ * `{ source: "own", continuation: C }` config.
+ *
+ * @deprecated Use `SubagentRequiredCaps<C>` against the full subagent
+ * sandbox config — `continuation` alone misses `shutdown` and `init`,
+ * which is why the previous mapping under-rejected `fork`+`pause` and
+ * `continue`+auto-injected pause.
+ */
+type SubagentContinuationCaps<C extends SubagentContinuation> = C extends "snapshot" ? "snapshot" | "restore" : C extends "fork" ? "fork" : never;
+/** Continuation values supported when `source` is `"inherit"`. */
+type InheritContinuation = "continue" | "fork";
+/** Continuation values supported when `source` is `"own"`. */
+type OwnContinuation = "continue" | "fork" | "snapshot";
+/** Union of every continuation value across both sources. */
+type SubagentContinuation = InheritContinuation | OwnContinuation;
+/**
+ * Caps required on a subagent's `proxy` when `source: "inherit"`,
+ * threaded through the SSOT.
+ *
+ * The `inherit` source has no `init` field, and the `shutdown` field
+ * is the user's literal (or `"destroy"` if omitted). We don't have a
+ * way to detect "omitted" in the field type itself, so this row
+ * resolves the user's `S | undefined` directly — `undefined` is treated
+ * as `"destroy"` to match the runtime default in
+ * `src/lib/subagent/handler.ts:469`.
+ */
+type _InheritCaps<C extends InheritContinuation, S> = SubagentRequiredCaps<{
+    source: "inherit";
+    continuation: C;
+    shutdown: S extends undefined ? "destroy" : S;
+}>;
+/**
+ * Variants for `source: "inherit"`. Continuation × shutdown-presence ×
+ * shutdown-literal all distribute, with omitted vs. specified
+ * `shutdown` encoded as separate variants — for the same reason
+ * `OwnVariant` does (forbid TS from matching a permissive cell when
+ * the user omits the field).
+ */
+type InheritVariant<TOptions extends SandboxCreateOptions> = InheritContinuation extends infer C ? C extends InheritContinuation ? ({
+    _s: undefined;
+    shutdown?: never;
+} | (SubagentSandboxShutdown extends infer SL ? SL extends SubagentSandboxShutdown ? {
+    _s: SL;
+    shutdown: SL;
+} : never : never)) extends infer S ? S extends {
+    _s: SubagentSandboxShutdown | undefined;
+    shutdown?: SubagentSandboxShutdown;
+} ? Omit<S, "_s"> & {
+    source: "inherit";
+    continuation: C;
+    proxy: (scope: string) => SandboxOps<TOptions, unknown, _InheritCaps<C, S["_s"]> & SandboxCapability>;
+} : never : never : never : never;
+type _OwnCaps<C extends OwnContinuation, I extends "per-call" | "once" | undefined, S> = SubagentRequiredCaps<{
+    source: "own";
+    continuation: C;
+    init: I extends undefined ? "per-call" : I;
+    shutdown: S;
+}>;
+/**
+ * Variants for `source: "own"`. Continuation × init-presence × shutdown-
+ * presence × shutdown-literal all distribute, so each cell gets its
+ * own variant with a precisely-typed `proxy`.
+ *
+ * Critical: omitted vs. specified `init` / `shutdown` are encoded as
+ * *separate* variants. The omitted variant uses `init?: never` /
+ * `shutdown?: never` so the field is forbidden when the user doesn't
+ * write one — without this, TS would infer `field?: undefined` and
+ * happily match an unrelated permissive variant whose caps don't
+ * cover the auto-injection.
+ */
+type OwnVariant<TOptions extends SandboxCreateOptions> = OwnContinuation extends infer C ? C extends OwnContinuation ? ({
+    _i: undefined;
+    init?: never;
+} | {
+    _i: "per-call";
+    init: "per-call";
+} | {
+    _i: "once";
+    init: "once";
+}) extends infer I ? I extends {
+    _i: "per-call" | "once" | undefined;
+    init?: "per-call" | "once";
+} ? ({
+    _s: undefined;
+    shutdown?: never;
+} | (SubagentSandboxShutdown extends infer SL ? SL extends SubagentSandboxShutdown ? {
+    _s: SL;
+    shutdown: SL;
+} : never : never)) extends infer S ? S extends {
+    _s: SubagentSandboxShutdown | undefined;
+    shutdown?: SubagentSandboxShutdown;
+} ? Omit<I, "_i"> & Omit<S, "_s"> & {
+    source: "own";
+    continuation: C;
+    proxy: (scope: string) => SandboxOps<TOptions, unknown, _OwnCaps<C, I["_i"], S["_s"]> & SandboxCapability>;
+} : never : never : never : never : never : never;
 /**
  * Sandbox configuration for a subagent.
  *
@@ -988,19 +1219,20 @@ type SubagentContext = Record<string, unknown> | (() => Record<string, unknown>)
  * `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.
+ *
+ * The `proxy` field's required `TCaps` is derived from
+ * {@link SubagentRequiredCaps} — the SSOT that mirrors
+ * `resolveSubagentLifecycle` in the handler. It folds in `shutdown` and
+ * `init` (including the handler's auto-injected `"pause"` /
+ * `"pause-until-parent-close"` overrides), so any `(adapter, source,
+ * continuation, init, shutdown)` cell that can't execute at runtime
+ * fails to typecheck at the `defineSubagent` site.
+ *
+ * `TOptions` defaults to {@link SandboxCreateOptions} so the wide,
+ * un-parameterised `SubagentSandboxConfig` keeps working for callers
+ * that don't need adapter-specific options.
  */
-type SubagentSandboxConfig = "none" | {
-    source: "inherit";
-    continuation: "continue" | "fork";
-    shutdown?: SubagentSandboxShutdown;
-    proxy: (scope: string) => SandboxOps;
-} | {
-    source: "own";
-    init?: "per-call" | "once";
-    continuation: "continue" | "fork" | "snapshot";
-    shutdown?: SubagentSandboxShutdown;
-    proxy: (scope: string) => SandboxOps;
-};
+type SubagentSandboxConfig<TOptions extends SandboxCreateOptions = SandboxCreateOptions> = "none" | InheritVariant<TOptions> | OwnVariant<TOptions>;
 /**
  * Configuration for a subagent that can be spawned by the parent workflow.
  *
@@ -1145,6 +1377,14 @@ interface SubagentSessionInput {
         sandboxId?: string;
         snapshot?: SandboxSnapshot;
         threadId: string;
+        usage: {
+            totalInputTokens: number;
+            totalOutputTokens: number;
+            totalCachedWriteTokens: number;
+            totalCachedReadTokens: number;
+            totalReasonTokens: number;
+            turns: number;
+        };
     }) => void;
 }
 
@@ -1316,14 +1556,74 @@ type ScopedPrefix<TScope extends string, TAdapter extends string> = TScope exten
 type PrefixedThreadOps<TPrefix extends string, TContent = string> = {
     [K in keyof ThreadOps<TContent> as `${TPrefix}${Capitalize<K & string>}`]: ThreadOps<TContent>[K];
 };
+/**
+ * Caps the session's sandbox-init dispatch may invoke for a given
+ * `(mode, shutdown)`. Mirror of `src/lib/session/session.ts:241-313`.
+ *
+ * The conditional branches are written non-distributively (each cap
+ * checked against the input `M` / `S` rather than over a union) so
+ * that the *omitted* case (defaults: M = "new", S = "destroy") flows
+ * through to `never`, not to "I don't know, assume everything."
+ */
+type _SessionInitCaps<M, S> = (M extends "fork" ? "fork" : never) | (M extends "from-snapshot" ? "restore" : never) | (M extends "continue" ? S extends "pause-until-parent-close" ? "resume" : never : never);
+/**
+ * Caps the session's exit dispatch may invoke. `"inherit"` mode keeps
+ * `sandboxOwned = false` so exit-shutdown caps NEVER fire — mirror of
+ * `src/lib/session/session.ts:598-615`.
+ */
+type _SessionExitCaps<M, S> = M extends "inherit" ? never : (S extends "snapshot" ? "snapshot" : never) | (S extends "pause" | "pause-until-parent-close" ? "pause" : never);
+/**
+ * Cap captured on entry for `mode: "new"` + `shutdown: "snapshot"` (the
+ * seeding-base-snapshot path). Mirror of
+ * `src/lib/session/session.ts:316-317`.
+ */
+type _SessionSeedCaps<M, S> = M extends "new" ? S extends "snapshot" ? "snapshot" : never : never;
+/**
+ * Resolves an omitted `sandbox` field to the runtime default
+ * `{ mode: "new" }`, and an omitted `sandboxShutdown` field to the
+ * runtime default `"destroy"`. The two `_Resolve…` helpers are the
+ * sole bridge between "user didn't set the field" and the SSOT below
+ * — keeping the defaults out of the conditional table itself.
+ */
+type _ResolveInit<TInit> = [TInit] extends [undefined] ? {
+    mode: "new";
+} : Exclude<TInit, undefined> extends infer Defined ? undefined extends TInit ? Defined | {
+    mode: "new";
+} : Defined : never;
+type _ResolveShutdown<TShutdown> = [TShutdown] extends [undefined] ? "destroy" : Exclude<TShutdown, undefined> extends infer Defined ? undefined extends TShutdown ? Defined | "destroy" : Defined : never;
+/**
+ * Sandbox capabilities a session actually invokes on its
+ * `sandboxOps`, derived from the literal types of the surrounding
+ * `sandbox` and `sandboxShutdown` fields.
+ *
+ * `TInit` / `TShutdown` default to `undefined` so an un-parameterised
+ * `SessionRequiredCaps` resolves to the caps the runtime *defaults*
+ * (`{ mode: "new" }` + `"destroy"`) actually require — i.e.
+ * `never`. This lets a narrow adapter (e.g. `proxyDaytonaSandboxOps`)
+ * satisfy `sandboxOps?: SandboxOps<…, SessionRequiredCaps<…>>` when
+ * the caller doesn't pin literals, matching what's runtime-safe.
+ *
+ * Pin literals via `as const` or by ascribing `SessionConfig<…, TInit,
+ * TShutdown>` to tighten the requirement on a per-call basis.
+ */
+type SessionRequiredCaps<TInit extends SandboxInit | undefined = undefined, TShutdown extends SubagentSandboxShutdown | undefined = undefined> = _ResolveInit<TInit> extends infer M ? _ResolveShutdown<TShutdown> extends infer S ? M extends {
+    mode: infer Mode;
+} ? S extends SubagentSandboxShutdown ? _SessionInitCaps<Mode, S> | _SessionExitCaps<Mode, S> | _SessionSeedCaps<Mode, S> : never : never : never : never;
 /**
  * Configuration for a Zeitlich agent session.
  *
  * @typeParam T - Tool map
  * @typeParam M - SDK-native message type returned by the model invoker
  * @typeParam TContent - SDK-native content type for human messages (defaults to `string`)
- */
-interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
+ * @typeParam TInit - Literal type of `sandbox` (a {@link SandboxInit}
+ *   variant or `undefined`). Defaults to the wide union; pin it via
+ *   `as const` on the call site to narrow the cap requirement on
+ *   `sandboxOps`.
+ * @typeParam TShutdown - Literal type of `sandboxShutdown`. Defaults
+ *   to the wide union; pin it via `as const` on the call site to
+ *   narrow the cap requirement on `sandboxOps`.
+ */
+interface SessionConfig<T extends ToolMap, M = unknown, TContent = string, TInit extends SandboxInit | undefined = SandboxInit | undefined, TShutdown extends SubagentSandboxShutdown | undefined = SubagentSandboxShutdown | undefined> {
     /** The name of the agent, should be unique within the workflows */
     agentName: string;
     /** Metadata for the session */
@@ -1351,8 +1651,6 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
      * Returns SDK-native content for the initial human message.
      */
     buildContextMessage: () => TContent | Promise<TContent>;
-    /** How long to wait for input before cancelling the workflow */
-    waitForInputTimeout?: Duration;
     /**
      * Thread initialization strategy (default: `{ mode: "new" }`).
      *
@@ -1370,8 +1668,21 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
      * same adapter instance.
      */
     threadKey?: string;
-    /** Sandbox lifecycle operations (optional — omit for agents that don't need a sandbox) */
-    sandboxOps?: SandboxOps;
+    /**
+     * Sandbox lifecycle operations (optional — omit for agents that don't
+     * need a sandbox).
+     *
+     * The `TCaps` argument is derived from {@link SessionRequiredCaps}
+     * over the literal types of the surrounding `sandbox` and
+     * `sandboxShutdown` fields. With the default wide
+     * `TInit` / `TShutdown`, this resolves to the full
+     * {@link SandboxCapability} union (current behaviour). When the
+     * caller pins those literals via `as const`, the cap requirement
+     * tightens so a narrow adapter (e.g. Daytona's
+     * `SandboxOps<…, never>`) can satisfy combinations that don't need
+     * a gated method.
+     */
+    sandboxOps?: SandboxOps<SandboxCreateOptions, unknown, SessionRequiredCaps<TInit, TShutdown> & SandboxCapability>;
     /**
      * Sandbox initialization strategy.
      *
@@ -1382,14 +1693,14 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
      *
      * When omitted and `sandboxOps` is provided, defaults to `{ mode: "new" }`.
      */
-    sandbox?: SandboxInit;
+    sandbox?: TInit;
     /**
      * What to do with the sandbox when this session exits.
      *
      * Defaults to `"destroy"` when omitted.
      * Has no effect when the sandbox is inherited (`sandbox.mode === "inherit"`).
      */
-    sandboxShutdown?: SubagentSandboxShutdown;
+    sandboxShutdown?: TShutdown;
     /**
      * Called as soon as the sandbox is created (or resumed/forked), before the
      * agent loop starts. Useful for signalling sandbox readiness to a parent.
@@ -1412,6 +1723,14 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
         threadId: string;
         sandboxId?: string;
         snapshot?: SandboxSnapshot;
+        usage: {
+            totalInputTokens: number;
+            totalOutputTokens: number;
+            totalCachedWriteTokens: number;
+            totalCachedReadTokens: number;
+            totalReasonTokens: number;
+            turns: number;
+        };
     }) => void;
     virtualFsOps?: VirtualFsOps;
     /**
@@ -1455,4 +1774,4 @@ interface ZeitlichSession<M = unknown, HasSandbox extends boolean = boolean> {
     }): Promise<SessionResult<M, T, HasSandbox>>;
 }
 
-export { type SandboxShutdown as $, type AgentResponse as A, type BaseAgentState as B, type PostToolUseFailureHookContext as C, type PostToolUseFailureHookResult as D, type PostToolUseHook as E, type FileEntryMetadata as F, type PostToolUseHookContext as G, type Hooks as H, type InferToolResults as I, type JsonValue as J, type PreHumanMessageAppendHook as K, type PreHumanMessageAppendHookContext as L, type ModelInvokerConfig as M, type PreToolUseHook as N, type PreToolUseHookContext as O, type PersistedThreadState as P, type PreToolUseHookResult as Q, type RouterContext as R, type ScopedPrefix as S, type ThreadOps as T, type ProcessToolCallsContext as U, type VirtualFsContext as V, type ProcessToolCallsResult as W, type RawToolCall as X, type RewindSignal as Y, type RunAgentActivity as Z, type SandboxInit as _, type ModelInvoker as a, type SerializableToolDefinition as a0, type SessionConfig as a1, type SessionEndHook as a2, type SessionEndHookContext as a3, type SessionExitReason as a4, type SessionResult as a5, type SessionStartHook as a6, type SessionStartHookContext as a7, type SubagentChildWorkflowOptions as a8, type SubagentConfig as a9, type VirtualFsOps as aA, type VirtualFsState as aB, type WorkflowTask as aC, type ZeitlichSession as aD, isTerminalStatus as aE, type ToolRouterOptions as aF, type SubagentDefinition as aa, type SubagentFnResult as ab, type SubagentHandlerResponse as ac, type SubagentHooks as ad, type SubagentSandboxConfig as ae, type SubagentSandboxShutdown as af, type SubagentSessionInput as ag, type SubagentWorkflow as ah, type SubagentWorkflowInput as ai, type TaskStatus as aj, type ThreadInit as ak, type TokenUsage as al, type ToolArgs as am, type ToolCallResult as an, type ToolCallResultUnion as ao, type ToolDefinition as ap, type ToolHandler as aq, type ToolHooks as ar, type ToolMap as as, type ToolNames as at, type ToolResult as au, type ToolRouter as av, type ToolRouterHooks as aw, type ToolWithHandler as ax, VirtualFileSystem as ay, type VirtualFileTree as az, type PrefixedThreadOps as b, type ToolHandlerResponse as c, type ActivityToolHandler as d, type ToolResultConfig as e, type RunAgentConfig as f, type SkillProvider as g, type SkillMetadata as h, type Skill as i, type FileResolver as j, type TreeMutation as k, type PrefixedVirtualFsOps as l, type AgentConfig as m, type AgentFile as n, type AgentState as o, type AgentStateManager as p, type AgentStatus as q, type AppendToolResultFn as r, type FileEntry as s, type JsonPrimitive as t, type JsonSerializable as u, type ParsedToolCall as v, type ParsedToolCallUnion as w, type PostHumanMessageAppendHook as x, type PostHumanMessageAppendHookContext as y, type PostToolUseFailureHook as z };
+export { type SandboxShutdown as $, type AgentResponse as A, type BaseAgentState as B, type PostToolUseFailureHookContext as C, type PostToolUseFailureHookResult as D, type PostToolUseHook as E, type FileEntryMetadata as F, type PostToolUseHookContext as G, type Hooks as H, type InferToolResults as I, type JsonValue as J, type PreHumanMessageAppendHook as K, type PreHumanMessageAppendHookContext as L, type ModelInvokerConfig as M, type PreToolUseHook as N, type PreToolUseHookContext as O, type PersistedThreadState as P, type PreToolUseHookResult as Q, type RouterContext as R, type ScopedPrefix as S, type ThreadOps as T, type ProcessToolCallsContext as U, type VirtualFsContext as V, type ProcessToolCallsResult as W, type RawToolCall as X, type RewindSignal as Y, type RunAgentActivity as Z, type SandboxInit as _, type ModelInvoker as a, type SerializableToolDefinition as a0, type SessionConfig as a1, type SessionEndHook as a2, type SessionEndHookContext as a3, type SessionExitReason as a4, type SessionRequiredCaps as a5, type SessionResult as a6, type SessionStartHook as a7, type SessionStartHookContext as a8, type SubagentChildWorkflowOptions as a9, VirtualFileSystem as aA, type VirtualFileTree as aB, type VirtualFsOps as aC, type VirtualFsState as aD, type WorkflowTask as aE, type ZeitlichSession as aF, isTerminalStatus as aG, type ToolRouterOptions as aH, type SubagentConfig as aa, type SubagentContinuationCaps as ab, type SubagentDefinition as ac, type SubagentFnResult as ad, type SubagentHandlerResponse as ae, type SubagentHooks as af, type SubagentSandboxConfig as ag, type SubagentSandboxShutdown as ah, type SubagentSessionInput as ai, type SubagentWorkflow as aj, type SubagentWorkflowInput as ak, type TaskStatus as al, type ThreadInit as am, type TokenUsage as an, type ToolArgs as ao, type ToolCallResult as ap, type ToolCallResultUnion as aq, type ToolDefinition as ar, type ToolHandler as as, type ToolHooks as at, type ToolMap as au, type ToolNames as av, type ToolResult as aw, type ToolRouter as ax, type ToolRouterHooks as ay, type ToolWithHandler as az, type PrefixedThreadOps as b, type ToolHandlerResponse as c, type ActivityToolHandler as d, type ToolResultConfig as e, type RunAgentConfig as f, type SkillProvider as g, type SkillMetadata as h, type Skill as i, type FileResolver as j, type TreeMutation as k, type PrefixedVirtualFsOps as l, type AgentConfig as m, type AgentFile as n, type AgentState as o, type AgentStateManager as p, type AgentStatus as q, type AppendToolResultFn as r, type FileEntry as s, type JsonPrimitive as t, type JsonSerializable as u, type ParsedToolCall as v, type ParsedToolCallUnion as w, type PostHumanMessageAppendHook as x, type PostHumanMessageAppendHookContext as y, type PostToolUseFailureHook as z };