zeitlich 0.2.37 → 0.2.39

package/dist/{proxy-DEtowJyd.d.cts → proxy-BAKzNGRq.d.cts}

@@ -1,5 +1,5 @@
 import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-BO7Yju20.cjs';
+import { T as ThreadOps } from './types-Bcbiq8iv.cjs';
 
 /**
  * Shared proxy helper for thread operations.

package/dist/{proxy-0smGKvx8.d.ts → proxy-DO_MXbY4.d.ts}

@@ -1,5 +1,5 @@
 import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-CPKDl-y_.js';
+import { T as ThreadOps } from './types-Dt8-HBBT.js';
 
 /**
  * Shared proxy helper for thread operations.

package/dist/{thread-manager-C-C4pI2z.d.ts → thread-manager-CcRXasqs.d.ts}

@@ -1,7 +1,7 @@
 import Redis from 'ioredis';
 import Anthropic from '@anthropic-ai/sdk';
-import { J as JsonValue } from './types-CPKDl-y_.js';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-B37hKoWA.js';
+import { J as JsonValue } from './types-Dt8-HBBT.js';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DpHTX-iO.js';
 
 /** SDK-native content type for Anthropic human messages */
 type AnthropicContent = string | Anthropic.Messages.ContentBlockParam[];

package/dist/{thread-manager-D4vgzYrh.d.cts → thread-manager-ClwSaUnj.d.cts}

@@ -1,7 +1,7 @@
 import Redis from 'ioredis';
 import Anthropic from '@anthropic-ai/sdk';
-import { J as JsonValue } from './types-BO7Yju20.cjs';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-D08CXPh8.cjs';
+import { J as JsonValue } from './types-Bcbiq8iv.cjs';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-hFFi-Zd9.cjs';
 
 /** SDK-native content type for Anthropic human messages */
 type AnthropicContent = string | Anthropic.Messages.ContentBlockParam[];

package/dist/{thread-manager-3fszQih4.d.ts → thread-manager-D-7lp1JK.d.ts}

@@ -1,7 +1,7 @@
 import Redis from 'ioredis';
-import { J as JsonValue } from './types-CPKDl-y_.js';
+import { J as JsonValue } from './types-Dt8-HBBT.js';
 import { MessageContent, StoredMessage, BaseMessage } from '@langchain/core/messages';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-B37hKoWA.js';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-DpHTX-iO.js';
 
 /** SDK-native content type for LangChain human messages */
 type LangChainContent = string | MessageContent;

package/dist/{thread-manager-CzYln2OC.d.cts → thread-manager-Y8Ucf0Tf.d.cts}

@@ -1,7 +1,7 @@
 import Redis from 'ioredis';
-import { J as JsonValue } from './types-BO7Yju20.cjs';
+import { J as JsonValue } from './types-Bcbiq8iv.cjs';
 import { MessageContent, StoredMessage, BaseMessage } from '@langchain/core/messages';
-import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-D08CXPh8.cjs';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from './types-hFFi-Zd9.cjs';
 
 /** SDK-native content type for LangChain human messages */
 type LangChainContent = string | MessageContent;

package/dist/{types-CPKDl-y_.d.ts → types-Bcbiq8iv.d.cts}

@@ -1,8 +1,8 @@
 import { Duration } from '@temporalio/common';
-import { ActivityFunctionWithOptions, QueryDefinition, ActivityInterfaceFor } from '@temporalio/workflow';
+import { ActivityFunctionWithOptions, QueryDefinition, ChildWorkflowOptions, 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, f as SandboxSnapshot, g as SandboxOps } from './types-tQL9njTu.js';
+import { f as SandboxSnapshot, a as SandboxFileSystem, F as FileStat, D as DirentEntry, d as SandboxCreateOptions, g as SandboxOps } from './types-yx0LzPGn.cjs';
 
 /**
  * A tool definition with a name, description, and Zod schema for arguments.
@@ -98,12 +98,29 @@ 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 and the LLM call is retried. The session reuses
+     * the same `assistantMessageId` for the retry; the next `runAgent`
+     * activity truncates the thread from that id on entry, wiping the
+     * triggering assistant message and any tool results already appended
+     * before re-invoking the LLM.
+     *
+     * The `toolResponse` for a rewinding tool call is ignored (never
+     * appended) since the thread is rewound back to the pre-assistant
+     * state on the next invocation.
+     */
+    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) */
     threadId?: string;
     /** Sandbox ID created or used by the handler (e.g. child agent sandbox) */
     sandboxId?: string;
+    /** 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;
     /** Unvalidated metadata passthrough from handler to hooks (e.g. infrastructure state) */
     metadata?: Record<string, unknown>;
 }
@@ -186,6 +203,28 @@ 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 reuse the same
+ * `assistantMessageId` for the retry; the next `runAgent` activity
+ * then truncates the thread from that id on entry.
+ */
+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 +383,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.
@@ -388,6 +427,22 @@ type JsonSerializable<T> = {
  * Full state type combining base state with custom state
  */
 type AgentState<TCustom extends JsonSerializable<TCustom>> = BaseAgentState & TCustom;
+/**
+ * The slice of agent state that is persisted alongside the thread in the
+ * thread store (e.g. Redis) so that a workflow can terminate, store its
+ * state, and be continued or forked later with that state rehydrated.
+ *
+ * Only fields that make sense to carry across workflow runs belong here.
+ * Runtime bookkeeping like status, version, turns, tools, fileTree, token
+ * counters, and the system prompt is intentionally NOT persisted — each run
+ * rebuilds those from scratch.
+ */
+interface PersistedThreadState {
+    /** Task map serialized as entries so it round-trips through JSON. */
+    tasks: [string, WorkflowTask][];
+    /** All custom state fields declared by the caller. */
+    custom: Record<string, JsonValue>;
+}
 /**
  * Agent state manager interface
  * Note: Temporal handlers must be set up in the workflow file due to
@@ -447,6 +502,13 @@ interface AgentStateManager<TCustom extends JsonSerializable<TCustom>> {
     deleteTask(id: string): boolean;
     /** Set the tools (converts Zod schemas to JSON Schema for serialization) */
     setTools(newTools: ToolDefinition[]): void;
+    /**
+     * Snapshot the fields that should survive across workflow runs
+     * (tasks + all custom state). Safe to pass directly to
+     * {@link ThreadOps.saveThreadState}. Rehydrate on the next run with
+     * `mergeUpdate({ tasks: new Map(slice.tasks), ...slice.custom })`.
+     */
+    getPersistedSlice(): PersistedThreadState;
     /** Update the usage */
     updateUsage(usage: TokenUsage): void;
     /** Get the total usage */
@@ -667,6 +729,18 @@ interface RunAgentConfig extends AgentConfig {
     threadKey?: string;
     /** Metadata for the session */
     metadata?: Record<string, unknown>;
+    /**
+     * The id under which the assistant message produced by this call will
+     * be appended. The activity truncates the thread from this id on
+     * entry (no-op on the first attempt) so that:
+     *
+     * - Rewind retries can reuse the same id and the previous (bad)
+     *   assistant + its tool results are wiped before the retry LLM call.
+     * - Resetting the Temporal workflow to this activity restores the
+     *   pre-call thread state: replay re-truncates, re-invokes, and
+     *   appends under the same id.
+     */
+    assistantMessageId: string;
 }
 /**
  * Configuration for appending a tool result
@@ -785,7 +859,9 @@ interface Hooks<T extends ToolMap, TResult = unknown, TContent = unknown> extend
  * - `"new"` — start a fresh thread (optionally specify its ID).
  * - `"continue"` — append directly to an existing thread in-place.
  * - `"fork"` — copy all messages from an existing thread into a new one and
- *   continue there.
+ *   continue there. When the adapter has `onForkPrepareThread` and/or
+ *   `onForkTransform` hooks configured, they are applied once to the forked
+ *   thread before the session starts.
  */
 type ThreadInit = {
     mode: "new";
@@ -808,9 +884,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.
  */
@@ -823,9 +902,11 @@ type SandboxInit = {
 } | {
     mode: "fork";
     sandboxId: string;
+    options?: SandboxCreateOptions;
 } | {
     mode: "from-snapshot";
     snapshot: SandboxSnapshot;
+    options?: SandboxCreateOptions;
 } | {
     mode: "inherit";
     sandboxId: string;
@@ -852,19 +933,20 @@ type SandboxShutdown = "destroy" | "pause" | "keep" | "snapshot";
  */
 type SubagentSandboxShutdown = SandboxShutdown | "pause-until-parent-close" | "keep-until-parent-close";
 
+/**
+ * Subset of {@link ChildWorkflowOptions} that callers may override when a
+ * subagent is invoked. `workflowId`, `taskQueue`, and `args` are managed by
+ * the subagent handler itself and therefore cannot be set here.
+ *
+ * Configuring `workflowRunTimeout` (or `workflowExecutionTimeout`) is strongly
+ * recommended: it is the only reliable way to guarantee that a child workflow
+ * which fails during initialization or repeatedly fails workflow tasks will
+ * eventually be terminated, allowing the parent's `Subagent` tool call to fail
+ * deterministically instead of hanging forever waiting for a result.
+ */
+type SubagentChildWorkflowOptions = Omit<ChildWorkflowOptions, "workflowId" | "taskQueue" | "args">;
 /** ToolHandlerResponse with threadId required (subagents must always surface their thread) */
-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;
-};
+type SubagentHandlerResponse<TResult = null, TToolResponse = JsonValue> = ToolHandlerResponse<TResult, TToolResponse>;
 /**
  * Raw workflow input fields passed from parent to child workflow.
  * `defineSubagentWorkflow` maps this into `SubagentSessionInput`.
@@ -935,6 +1017,24 @@ interface SubagentConfig<TResult extends z.ZodType = z.ZodType> {
     workflow: SubagentWorkflow<TResult>;
     /** Optional task queue - defaults to parent's queue if not specified */
     taskQueue?: string;
+    /**
+     * Optional child workflow options forwarded to `executeChild` when the
+     * subagent is spawned. Use this to configure timeouts, retry policies, or
+     * parent-close behavior for the child workflow.
+     *
+     * **Recommended:** configure a `workflowRunTimeout` (or
+     * `workflowExecutionTimeout`) so that a child workflow that fails to
+     * initialize — or repeatedly fails workflow tasks without ever reaching a
+     * terminal state — is eventually terminated by the Temporal server. Without
+     * such a timeout, the parent's `Subagent` tool call can hang indefinitely
+     * waiting for the child to finish. When Temporal terminates the child, the
+     * tool call fails with a structured `ChildWorkflowFailure` that the router's
+     * failure hooks can handle just like any other tool error.
+     *
+     * `workflowId`, `taskQueue`, and `args` are managed by the subagent handler
+     * and cannot be overridden here.
+     */
+    workflowOptions?: SubagentChildWorkflowOptions;
     /** Optional Zod schema to validate the child workflow's result. If omitted, result is passed through as-is. */
     resultSchema?: TResult;
     /** Optional context passed to the subagent — a static object or a function evaluated at invocation time */
@@ -1026,8 +1126,26 @@ interface SubagentSessionInput {
     sandbox?: SandboxInit;
     /** Sandbox shutdown policy (default: "destroy") */
     sandboxShutdown?: SubagentSandboxShutdown;
-    /** Called by the session as soon as the sandbox is created, before the agent loop starts. */
-    onSandboxReady?: (sandboxId: string) => void;
+    /**
+     * Called by the session as soon as the sandbox is created, before the
+     * agent loop starts. `baseSnapshot` is populated only when the session
+     * captured a seed snapshot (fresh creation + `sandboxShutdown === "snapshot"`).
+     */
+    onSandboxReady?: (args: {
+        sandboxId: string;
+        baseSnapshot?: SandboxSnapshot;
+    }) => void;
+    /**
+     * Called by the session right before `runSession` returns. Installed by
+     * `defineSubagentWorkflow` to capture sandbox outputs and auto-forward
+     * them to the subagent's final result so user code never has to thread
+     * `sandboxId` / `snapshot` manually.
+     */
+    onSessionExit?: (result: {
+        sandboxId?: string;
+        snapshot?: SandboxSnapshot;
+        threadId: string;
+    }) => void;
 }
 
 /**
@@ -1100,6 +1218,13 @@ interface ModelInvokerConfig {
     agentName: string;
     state: BaseAgentState;
     metadata?: Record<string, unknown>;
+    /**
+     * The id the assistant message produced by this call will be stored
+     * under. Invokers truncate the thread from this id on entry so that
+     * rewind retries and Temporal workflow resets restore the pre-call
+     * state before re-invoking the LLM. See {@link RunAgentConfig}.
+     */
+    assistantMessageId: string;
 }
 /**
  * Generic model invocation contract.
@@ -1131,8 +1256,39 @@ interface ThreadOps<TContent = string> {
     appendAgentMessage(threadId: string, id: string, message: unknown, threadKey?: string): Promise<void>;
     /** Append a system message to the thread */
     appendSystemMessage(threadId: string, id: string, content: unknown, threadKey?: string): Promise<void>;
-    /** Copy all messages from sourceThreadId into a new thread at targetThreadId */
+    /**
+     * Copy all messages AND the persisted state slice (tasks + custom
+     * state) from `sourceThreadId` into a new thread at `targetThreadId`.
+     * Adapters that have `onForkPrepareThread` and/or `onForkTransform`
+     * hooks configured apply them once to the new thread's messages
+     * before returning.
+     */
     forkThread(sourceThreadId: string, targetThreadId: string, threadKey?: string): Promise<void>;
+    /**
+     * Truncate the thread starting at `messageId`: that message and every
+     * message after it are removed. If `messageId` is not present the call
+     * is a no-op.
+     *
+     * The `runAgent` activity invokes this on entry with the pre-generated
+     * `assistantMessageId`. On the happy path the id is not yet in the
+     * thread and the call is a no-op. On a rewind retry (same assistant
+     * id reused) or a Temporal workflow reset-to-this-activity the id is
+     * present, so the bad assistant + any tool results it produced are
+     * wiped and the call is then replayable.
+     */
+    truncateThread(threadId: string, messageId: string, threadKey?: string): Promise<void>;
+    /**
+     * Load the persisted state slice (tasks + custom state) associated with
+     * the thread, or `null` if none has been saved yet. Called on session
+     * start for `continue`/`fork` threads to rehydrate {@link AgentStateManager}.
+     */
+    loadThreadState(threadId: string, threadKey?: string): Promise<PersistedThreadState | null>;
+    /**
+     * Overwrite the persisted state slice for the thread. Called once from
+     * the session's `finally` block on every exit path so that "finish,
+     * store, continue later" works regardless of exit reason.
+     */
+    saveThreadState(threadId: string, state: PersistedThreadState, threadKey?: string): Promise<void>;
 }
 /**
  * Composes an adapter prefix + workflow scope for activity naming.
@@ -1237,8 +1393,25 @@ interface SessionConfig<T extends ToolMap, M = unknown, TContent = string> {
     /**
      * Called as soon as the sandbox is created (or resumed/forked), before the
      * agent loop starts. Useful for signalling sandbox readiness to a parent.
+     *
+     * `baseSnapshot` is only populated when the sandbox was freshly created
+     * this run and `sandboxShutdown === "snapshot"` — i.e. when the session
+     * captured a seed snapshot intended for reuse.
+     */
+    onSandboxReady?: (args: {
+        sandboxId: string;
+        baseSnapshot?: SandboxSnapshot;
+    }) => void;
+    /**
+     * Called right before `runSession` returns, with the session's sandbox
+     * outputs. Useful for callers (e.g. `defineSubagentWorkflow`) that want to
+     * forward these fields to their own return value without requiring user
+     * code to manually thread them through.
      */
-    onSandboxReady?: (sandboxId: string) => void;
+    onSessionExit?: (result: {
+        sandboxId?: string;
+        snapshot?: SandboxSnapshot;
+    }) => void;
     virtualFsOps?: VirtualFsOps;
     /**
      * Virtual filesystem configuration (optional — independent of sandbox).
@@ -1281,4 +1454,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 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 };

package/dist/{types-CNuWnvy9.d.ts → types-DAsQ21Rt.d.ts}

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

package/dist/{types-B37hKoWA.d.ts → types-DpHTX-iO.d.ts}

@@ -1,5 +1,5 @@
 import Redis from 'ioredis';
-import { J as JsonValue } from './types-CPKDl-y_.js';
+import { P as PersistedThreadState, J as JsonValue } from './types-Dt8-HBBT.js';
 
 interface ThreadManagerConfig<T> {
     redis: Redis;
@@ -34,8 +34,50 @@ interface BaseThreadManager<T> {
      * forks — each call creates an independent copy.
      */
     fork(newThreadId: string): Promise<BaseThreadManager<T>>;
+    /**
+     * Atomically replace the entire contents of the thread with `messages`.
+     * The existing list is cleared, the new messages are appended in order,
+     * and dedup markers from prior appends are cleared so future idempotent
+     * appends with ids that were removed aren't silently skipped.
+     *
+     * Requires the thread manager to be configured with `idOf`.
+     */
+    replaceAll(messages: T[]): Promise<void>;
     /** Delete the thread */
     delete(): Promise<void>;
+    /** Get the number of stored messages currently in the thread */
+    length(): Promise<number>;
+    /**
+     * Truncate the thread starting at the message with id `messageId`.
+     * That message and every message after it are removed. If `messageId`
+     * is not present in the thread this is a no-op — useful as the
+     * "truncate on entry" step of the `runAgent` activity, which becomes a
+     * no-op on the first attempt and a cleanup on Temporal workflow reset
+     * or in-workflow rewind retries.
+     *
+     * Dedup markers for removed single-message appends are also cleared so
+     * that appending the same id again (e.g. the same assistant message id
+     * on a rewind retry) is not silently skipped.
+     *
+     * Requires the thread manager to be configured with `idOf`.
+     */
+    truncateFromId(messageId: string): Promise<void>;
+    /**
+     * Load the persisted state slice associated with this thread, or
+     * `null` if none has been saved yet. Safe to call on any thread —
+     * treats a missing slice as a non-error.
+     */
+    loadState(): Promise<PersistedThreadState | null>;
+    /**
+     * Overwrite the persisted state slice for this thread. The thread
+     * itself must already exist (same TTL as the message list).
+     *
+     * Note: {@link BaseThreadManager.fork} already copies the slice to
+     * the new thread, so there's no separate `forkState` method.
+     */
+    saveState(state: PersistedThreadState): Promise<void>;
+    /** Delete just the persisted state slice, leaving messages intact. */
+    deleteState(): Promise<void>;
 }
 /**
  * Shared contract for provider-specific thread managers.
@@ -63,6 +105,21 @@ interface ThreadManagerHooks<TStored, TPrepared = TStored> {
     onPrepareMessage?: (message: TStored, index: number, thread: readonly TStored[]) => TStored;
     /** Called for each SDK-native message after all processing, right before the payload is returned */
     onPreparedMessage?: (message: TPrepared, index: number, messages: readonly TPrepared[]) => TPrepared;
+    /**
+     * One-shot list-level pre-pass applied once when a thread is forked with
+     * `transform: true`. Runs before {@link onForkTransform}. May filter,
+     * compact, prepend, or otherwise rewrite the whole forked thread — so the
+     * returned length need not match the input length. Async, so implementations
+     * may call an LLM or other I/O.
+     */
+    onForkPrepareThread?: (messages: readonly TStored[]) => TStored[] | Promise<TStored[]>;
+    /**
+     * Per-message final pass applied once when a thread is forked with
+     * `transform: true`. Runs after {@link onForkPrepareThread}. Pure 1:1 map —
+     * must return a value for every input message; length cannot change. Same
+     * shape as {@link onPreparedMessage}.
+     */
+    onForkTransform?: (message: TStored, index: number, messages: readonly TStored[]) => TStored;
 }
 interface ProviderThreadManager<TStored, TContent = string, TToolContent = JsonValue, TSystemContent = string> extends BaseThreadManager<TStored> {
     appendUserMessage(id: string, content: TContent): Promise<void>;