zeitlich 0.2.37 → 0.2.39

package/dist/index.js

@@ -1,4 +1,4 @@
-import { defineSignal, uuid4, setHandler, defineUpdate, ApplicationFailure, log, condition, defineQuery, proxySinks, workflowInfo, proxyActivities, getExternalWorkflowHandle, executeChild } from '@temporalio/workflow';
+import { defineSignal, CancellationScope, isCancellation, uuid4, setHandler, defineUpdate, ApplicationFailure, log, condition, defineQuery, proxySinks, workflowInfo, proxyActivities, getExternalWorkflowHandle, executeChild } from '@temporalio/workflow';
 import z14, { z } from 'zod';
 import { randomUUID, randomFillSync } from 'crypto';
 import { ApplicationFailure as ApplicationFailure$1 } from '@temporalio/common';
@@ -111,7 +111,7 @@ function createToolRouter(options) {
       });
     }
   }
-  async function processToolCall(toolCall, turn, sandboxId) {
+  async function processToolCall(toolCall, turn, sandboxId, onRewindRequested) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
     const preResult = await runPreHooks(toolCall, tool, turn);
@@ -126,7 +126,7 @@ function createToolRouter(options) {
           reason: "Skipped by PreToolUse hook"
         })
       });
-      return null;
+      return { kind: "skipped" };
     }
     const effectiveArgs = preResult.args;
     log.debug("tool call dispatched", {
@@ -138,6 +138,7 @@ function createToolRouter(options) {
     let content;
     let resultAppended = false;
     let metadata;
+    let rewindRequested = false;
     try {
       if (tool) {
         const routerContext = {
@@ -155,11 +156,15 @@ function createToolRouter(options) {
         content = response.toolResponse;
         resultAppended = response.resultAppended === true;
         metadata = response.metadata;
+        rewindRequested = response.rewind === true;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      if (isCancellation(error)) {
+        throw error;
+      }
       log.warn("tool call failed", {
         toolName: toolCall.name,
         toolCallId: toolCall.id,
@@ -177,6 +182,15 @@ function createToolRouter(options) {
       result = recovery.result;
       content = recovery.content;
     }
+    if (rewindRequested) {
+      const signal = {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name
+      };
+      log.info("tool requested rewind", { ...signal });
+      onRewindRequested?.(signal);
+      return { kind: "rewind", signal };
+    }
     if (!resultAppended) {
       const config = {
         threadId: options.threadId,
@@ -213,7 +227,7 @@ function createToolRouter(options) {
       turn,
       durationMs
     );
-    return toolResult;
+    return { kind: "result", value: toolResult };
   }
   return {
     hasTools() {
@@ -248,27 +262,59 @@ function createToolRouter(options) {
       }));
     },
     async processToolCalls(toolCalls, context) {
+      const attachRewind = (arr, rewind) => {
+        if (rewind) {
+          arr.rewind = rewind;
+        }
+        return arr;
+      };
       if (toolCalls.length === 0) {
-        return [];
+        return attachRewind([], void 0);
       }
       const turn = context?.turn ?? 0;
       const sandboxId = context?.sandboxId;
+      let rewindSignal;
       if (options.parallel) {
-        const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId))
-        );
-        return results2.filter(
-          (r) => r !== null
+        const scope = new CancellationScope({ cancellable: true });
+        const onRewindRequested = (signal) => {
+          if (!rewindSignal) {
+            rewindSignal = signal;
+            scope.cancel();
+          }
+        };
+        const outcomes = await scope.run(
+          async () => Promise.allSettled(
+            toolCalls.map(
+              (tc) => processToolCall(tc, turn, sandboxId, onRewindRequested)
+            )
+          )
         );
+        const results2 = [];
+        for (const outcome of outcomes) {
+          if (outcome.status === "rejected") {
+            if (isCancellation(outcome.reason)) {
+              continue;
+            }
+            throw outcome.reason;
+          }
+          if (outcome.value.kind === "result") {
+            results2.push(outcome.value.value);
+          }
+        }
+        return attachRewind(results2, rewindSignal);
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, sandboxId);
-        if (result !== null) {
-          results.push(result);
+        const outcome = await processToolCall(toolCall, turn, sandboxId);
+        if (outcome.kind === "rewind") {
+          rewindSignal = outcome.signal;
+          break;
+        }
+        if (outcome.kind === "result") {
+          results.push(outcome.value);
         }
       }
-      return results;
+      return attachRewind(results, rewindSignal);
     },
     async processToolCallsByName(toolCalls, toolName, handler, context) {
       const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
@@ -392,6 +438,7 @@ function createSubagentTool(subagents) {
 var childSandboxReadySignal = defineSignal("childSandboxReady");
 
 // src/lib/subagent/handler.ts
+var DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT = "1h";
 function resolveSandboxConfig(config) {
   if (!config || config === "none") {
     return { source: "none", init: "per-call", continuation: "fork" };
@@ -423,17 +470,28 @@ function createSubagentHandler(subagents) {
   const threadSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxCreating = /* @__PURE__ */ new Set();
+  const persistentSandboxCreationError = /* @__PURE__ */ new Map();
   const lazyCreatorAgent = /* @__PURE__ */ new Map();
+  const snapshotBaseCreatorAgent = /* @__PURE__ */ new Map();
   const threadSnapshots = /* @__PURE__ */ new Map();
   const persistentBaseSnapshot = /* @__PURE__ */ new Map();
   const persistentBaseSnapshotCreating = /* @__PURE__ */ new Set();
-  setHandler(childSandboxReadySignal, ({ childWorkflowId, sandboxId }) => {
-    const agentName = lazyCreatorAgent.get(childWorkflowId);
-    if (agentName && !persistentSandboxes.has(agentName)) {
-      persistentSandboxes.set(agentName, sandboxId);
-      lazyCreatorAgent.delete(childWorkflowId);
+  const persistentBaseSnapshotCreationError = /* @__PURE__ */ new Map();
+  setHandler(
+    childSandboxReadySignal,
+    ({ childWorkflowId, sandboxId, baseSnapshot }) => {
+      const lazyAgent = lazyCreatorAgent.get(childWorkflowId);
+      if (lazyAgent && !persistentSandboxes.has(lazyAgent)) {
+        persistentSandboxes.set(lazyAgent, sandboxId);
+        lazyCreatorAgent.delete(childWorkflowId);
+      }
+      const snapAgent = snapshotBaseCreatorAgent.get(childWorkflowId);
+      if (snapAgent && baseSnapshot && !persistentBaseSnapshot.has(snapAgent)) {
+        persistentBaseSnapshot.set(snapAgent, baseSnapshot);
+        snapshotBaseCreatorAgent.delete(childWorkflowId);
+      }
     }
-  });
+  );
   const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
@@ -489,8 +547,20 @@ function createSubagentHandler(subagents) {
         baseSnap = persistentBaseSnapshot.get(config.agentName);
         if (!baseSnap) {
           if (persistentBaseSnapshotCreating.has(config.agentName)) {
-            await condition(() => persistentBaseSnapshot.has(config.agentName));
+            await condition(
+              () => persistentBaseSnapshot.has(config.agentName) || persistentBaseSnapshotCreationError.has(config.agentName) || !persistentBaseSnapshotCreating.has(config.agentName)
+            );
+            const creatorErr = persistentBaseSnapshotCreationError.get(
+              config.agentName
+            );
+            if (creatorErr !== void 0) {
+              throw creatorErr;
+            }
             baseSnap = persistentBaseSnapshot.get(config.agentName);
+            if (!baseSnap) {
+              persistentBaseSnapshotCreating.add(config.agentName);
+              isSnapshotBaseCreator = true;
+            }
           } else {
             persistentBaseSnapshotCreating.add(config.agentName);
             isSnapshotBaseCreator = true;
@@ -508,8 +578,20 @@ function createSubagentHandler(subagents) {
         baseSandboxId = persistentSandboxes.get(config.agentName);
         if (!baseSandboxId) {
           if (persistentSandboxCreating.has(config.agentName)) {
-            await condition(() => persistentSandboxes.has(config.agentName));
+            await condition(
+              () => persistentSandboxes.has(config.agentName) || persistentSandboxCreationError.has(config.agentName) || !persistentSandboxCreating.has(config.agentName)
+            );
+            const creatorErr = persistentSandboxCreationError.get(
+              config.agentName
+            );
+            if (creatorErr !== void 0) {
+              throw creatorErr;
+            }
             baseSandboxId = persistentSandboxes.get(config.agentName);
+            if (!baseSandboxId) {
+              persistentSandboxCreating.add(config.agentName);
+              isLazyCreator = true;
+            }
           } else {
             persistentSandboxCreating.add(config.agentName);
             isLazyCreator = true;
@@ -538,6 +620,12 @@ function createSubagentHandler(subagents) {
     };
     const resolvedContext = config.context === void 0 ? void 0 : typeof config.context === "function" ? config.context() : config.context;
     const childOpts = {
+      // Apply a bounded run timeout by default so a child workflow that
+      // fails to initialize or otherwise never reaches a terminal state
+      // cannot hang the parent's `Subagent` tool call forever. Callers can
+      // raise, lower, or disable it via `workflowOptions.workflowRunTimeout`.
+      workflowRunTimeout: DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT,
+      ...config.workflowOptions ?? {},
       workflowId: childWorkflowId,
       args: resolvedContext === void 0 ? [args.prompt, workflowInput] : [args.prompt, workflowInput, resolvedContext],
       taskQueue: config.taskQueue ?? parentTaskQueue
@@ -545,13 +633,39 @@ function createSubagentHandler(subagents) {
     if (isLazyCreator) {
       lazyCreatorAgent.set(childWorkflowId, config.agentName);
     }
+    if (isSnapshotBaseCreator) {
+      snapshotBaseCreatorAgent.set(childWorkflowId, config.agentName);
+    }
     log.info("subagent spawned", {
       subagent: config.agentName,
       childWorkflowId,
       threadMode,
       sandboxSource: sandboxCfg.source
     });
-    const childResult = await executeChild(config.workflow, childOpts);
+    let childResult;
+    try {
+      childResult = await executeChild(
+        config.workflow,
+        childOpts
+      );
+    } catch (err) {
+      log.warn("subagent failed", {
+        subagent: config.agentName,
+        childWorkflowId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      if (isLazyCreator) {
+        persistentSandboxCreating.delete(config.agentName);
+        persistentSandboxCreationError.set(config.agentName, err);
+        lazyCreatorAgent.delete(childWorkflowId);
+      }
+      if (isSnapshotBaseCreator) {
+        persistentBaseSnapshotCreating.delete(config.agentName);
+        persistentBaseSnapshotCreationError.set(config.agentName, err);
+        snapshotBaseCreatorAgent.delete(childWorkflowId);
+      }
+      throw err;
+    }
     const effectiveShutdown = sandboxShutdownOverride ?? sandboxCfg.shutdown ?? "destroy";
     log.info("subagent completed", {
       subagent: config.agentName,
@@ -595,10 +709,13 @@ function createSubagentHandler(subagents) {
     }
     if (isLazyCreator) {
       persistentSandboxCreating.delete(config.agentName);
+      persistentSandboxCreationError.delete(config.agentName);
       lazyCreatorAgent.delete(childWorkflowId);
     }
     if (isSnapshotBaseCreator) {
       persistentBaseSnapshotCreating.delete(config.agentName);
+      persistentBaseSnapshotCreationError.delete(config.agentName);
+      snapshotBaseCreatorAgent.delete(childWorkflowId);
     }
     if (!toolResponse) {
       return {
@@ -841,6 +958,7 @@ async function createSession({
   sandbox: sandboxInit,
   sandboxShutdown = "destroy",
   onSandboxReady,
+  onSessionExit,
   virtualFs: virtualFsConfig,
   virtualFsOps
 }) {
@@ -865,7 +983,9 @@ async function createSession({
     initializeThread,
     appendSystemMessage,
     appendAgentMessage,
-    forkThread
+    forkThread,
+    loadThreadState,
+    saveThreadState
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
@@ -959,8 +1079,10 @@ async function createSession({
             nonRetryable: true
           });
         }
+        const forkInit = sandboxInit;
         sandboxId = await sandboxOps.forkSandbox(
-          sandboxInit.sandboxId
+          forkInit.sandboxId,
+          forkInit.options
         );
         sandboxOwned = true;
       } else if (sandboxMode === "from-snapshot") {
@@ -970,8 +1092,11 @@ async function createSession({
             nonRetryable: true
           });
         }
-        const snap = sandboxInit.snapshot;
-        sandboxId = await sandboxOps.restoreSandbox(snap);
+        const restoreInit = sandboxInit;
+        sandboxId = await sandboxOps.restoreSandbox(
+          restoreInit.snapshot,
+          restoreInit.options
+        );
         sandboxOwned = true;
       } else if (sandboxOps) {
         const skillFiles = skills ? collectSkillFiles(skills) : void 0;
@@ -988,7 +1113,10 @@ async function createSession({
         baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
       }
       if (sandboxId && sandboxOwned && onSandboxReady) {
-        onSandboxReady(sandboxId);
+        onSandboxReady({
+          sandboxId,
+          ...baseSnapshot && { baseSnapshot }
+        });
       }
       if (virtualFsConfig) {
         if (!virtualFsOps) {
@@ -1031,9 +1159,20 @@ async function createSession({
       });
       const sessionStartMs = Date.now();
       const systemPrompt = stateManager.getSystemPrompt();
+      const rehydrateFromSlice = (slice) => {
+        stateManager.mergeUpdate({
+          tasks: new Map(slice.tasks),
+          ...slice.custom
+        });
+      };
       if (threadMode === "fork" && sourceThreadId) {
         await forkThread(sourceThreadId, threadId, threadKey);
-      } else if (threadMode === "continue") ; else {
+        const forkedSlice = await loadThreadState(threadId, threadKey);
+        if (forkedSlice) rehydrateFromSlice(forkedSlice);
+      } else if (threadMode === "continue") {
+        const continuedSlice = await loadThreadState(threadId, threadKey);
+        if (continuedSlice) rehydrateFromSlice(continuedSlice);
+      } else {
         if (appendSystemPrompt) {
           if (systemPrompt == null || typeof systemPrompt === "string" && systemPrompt.trim() === "") {
             throw ApplicationFailure.create({
@@ -1055,18 +1194,21 @@ async function createSession({
       let exitReason = "completed";
       let finalMessage = null;
       try {
+        let assistantId;
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
           log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
+          assistantId ??= uuid4();
           const { message, rawToolCalls, usage } = await runAgent({
             threadId,
             threadKey,
             agentName,
-            metadata
+            metadata,
+            assistantMessageId: assistantId
           });
-          await appendAgentMessage(threadId, uuid4(), message, threadKey);
+          await appendAgentMessage(threadId, assistantId, message, threadKey);
           if (usage) {
             stateManager.updateUsage(usage);
           }
@@ -1111,6 +1253,18 @@ async function createSession({
               stateManager.updateUsage(result.usage);
             }
           }
+          const rewind = toolCallResults.rewind;
+          if (rewind) {
+            log.info("rewinding turn", {
+              agentName,
+              threadId,
+              turn: currentTurn,
+              toolCallId: rewind.toolCallId,
+              toolName: rewind.toolName
+            });
+            continue;
+          }
+          assistantId = void 0;
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             const conditionMet = await condition(
               () => stateManager.getStatus() === "RUNNING",
@@ -1143,6 +1297,19 @@ async function createSession({
         });
         throw ApplicationFailure.fromError(error);
       } finally {
+        try {
+          await saveThreadState(
+            threadId,
+            stateManager.getPersistedSlice(),
+            threadKey
+          );
+        } catch (persistError) {
+          log.warn("failed to persist thread state", {
+            agentName,
+            threadId,
+            error: persistError instanceof Error ? persistError.message : String(persistError)
+          });
+        }
         await callSessionEnd(exitReason, stateManager.getTurns());
         if (sandboxOwned && sandboxId && sandboxOps) {
           switch (sandboxShutdown) {
@@ -1179,6 +1346,12 @@ async function createSession({
         ...baseSnapshot && { hasBaseSnapshot: true },
         ...exitSnapshot && { hasExitSnapshot: true }
       });
+      if (onSessionExit) {
+        onSessionExit({
+          ...sandboxId && { sandboxId },
+          ...exitSnapshot && { snapshot: exitSnapshot }
+        });
+      }
       return {
         threadId,
         finalMessage,
@@ -1207,6 +1380,18 @@ function defineWorkflow(config, fn) {
   return workflow;
 }
 
+// src/lib/thread/keys.ts
+var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
+function getThreadListKey(threadKey, threadId) {
+  return `${threadKey}:thread:${threadId}`;
+}
+function getThreadMetaKey(threadKey, threadId) {
+  return `${threadKey}:meta:thread:${threadId}`;
+}
+function getThreadStateKey(threadKey, threadId) {
+  return `${threadKey}:state:thread:${threadId}`;
+}
+
 // src/lib/types.ts
 function isTerminalStatus(status) {
   return status === "COMPLETED" || status === "FAILED" || status === "CANCELLED";
@@ -1226,11 +1411,19 @@ function createAgentStateManager({
   let systemPrompt = initialState?.systemPrompt;
   const tasks = new Map(initialState?.tasks);
   const {
-    status: _,
-    version: __,
-    turns: ___,
-    tasks: ____,
-    tools: _____,
+    status: _status,
+    version: _version,
+    turns: _turns,
+    tasks: _tasks,
+    tools: _tools,
+    systemPrompt: _systemPrompt,
+    fileTree: _fileTree,
+    inlineFiles: _inlineFiles,
+    virtualFsCtx: _virtualFsCtx,
+    totalInputTokens: _totalInputTokens,
+    totalOutputTokens: _totalOutputTokens,
+    cachedWriteTokens: _cachedWriteTokens,
+    cachedReadTokens: _cachedReadTokens,
     ...custom
   } = initialState ?? {};
   const customState = custom;
@@ -1310,7 +1503,14 @@ function createAgentStateManager({
       version++;
     },
     mergeUpdate(update) {
-      Object.assign(customState, update);
+      const { tasks: nextTasks, ...rest } = update;
+      if (nextTasks) {
+        tasks.clear();
+        for (const [id, task] of nextTasks) {
+          tasks.set(id, task);
+        }
+      }
+      Object.assign(customState, rest);
       version++;
     },
     getCurrentState() {
@@ -1348,6 +1548,12 @@ function createAgentStateManager({
       }
       return deleted;
     },
+    getPersistedSlice() {
+      return {
+        tasks: Array.from(tasks.entries()),
+        custom: { ...customState }
+      };
+    },
     updateUsage(usage) {
       totalInputTokens += usage.inputTokens ?? 0;
       totalOutputTokens += usage.outputTokens ?? 0;
@@ -1469,22 +1675,42 @@ function defineSubagentWorkflow(config, fn) {
       });
     }
     const parentHandle = getExternalWorkflowHandle(parent.workflowId);
+    let capturedSandboxId;
+    let capturedSnapshot;
+    let capturedBaseSnapshot;
+    let capturedThreadId;
     const sessionInput = {
       agentName: config.name,
       sandboxShutdown: effectiveShutdown,
       ...workflowInput.thread && { thread: workflowInput.thread },
       ...workflowInput.sandbox && { sandbox: workflowInput.sandbox },
-      onSandboxReady: (sandboxId) => {
+      onSandboxReady: ({ sandboxId, baseSnapshot }) => {
+        capturedBaseSnapshot = baseSnapshot;
         const isReuse = workflowInput.sandbox?.mode === "continue";
         if (!isReuse) {
           void parentHandle.signal(childSandboxReadySignal, {
             childWorkflowId: workflowInfo().workflowId,
-            sandboxId
+            sandboxId,
+            ...baseSnapshot && { baseSnapshot }
           });
         }
+      },
+      onSessionExit: ({ sandboxId, snapshot, threadId }) => {
+        capturedSandboxId = sandboxId;
+        capturedSnapshot = snapshot;
+        capturedThreadId = threadId;
+      }
+    };
+    const result = await fn(prompt, sessionInput, context ?? {});
+    return {
+      ...result,
+      ...capturedThreadId !== void 0 && { threadId: capturedThreadId },
+      ...capturedSandboxId !== void 0 && { sandboxId: capturedSandboxId },
+      ...capturedSnapshot !== void 0 && { snapshot: capturedSnapshot },
+      ...capturedBaseSnapshot !== void 0 && {
+        baseSnapshot: capturedBaseSnapshot
       }
     };
-    return fn(prompt, sessionInput, context ?? {});
   };
   Object.defineProperty(workflow, "name", { value: config.name });
   return Object.assign(workflow, {
@@ -2254,7 +2480,6 @@ var FileSystemSkillProvider = class {
 };
 
 // src/lib/thread/manager.ts
-var THREAD_TTL_SECONDS = 60 * 60 * 24 * 90;
 var APPEND_IDEMPOTENT_SCRIPT = `
 if redis.call('EXISTS', KEYS[1]) == 1 then
   return 0
@@ -2266,8 +2491,8 @@ redis.call('EXPIRE', KEYS[2], tonumber(ARGV[1]))
 redis.call('SET', KEYS[1], '1', 'EX', tonumber(ARGV[1]))
 return 1
 `;
-function getThreadKey(threadId, key) {
-  return `${key}:thread:${threadId}`;
+function getDedupKey(threadId, id) {
+  return `dedup:${id}:thread:${threadId}`;
 }
 function createThreadManager(config) {
   const {
@@ -2278,8 +2503,9 @@ function createThreadManager(config) {
     deserialize = (raw) => JSON.parse(raw),
     idOf
   } = config;
-  const redisKey = getThreadKey(threadId, key);
-  const metaKey = getThreadKey(threadId, `${key}:meta`);
+  const redisKey = getThreadListKey(key, threadId);
+  const metaKey = getThreadMetaKey(key, threadId);
+  const stateKey = getThreadStateKey(key, threadId);
   async function assertThreadExists() {
     const exists = await redis.exists(metaKey);
     if (!exists) {
@@ -2301,7 +2527,7 @@ function createThreadManager(config) {
       await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        const dedupKey = getThreadKey(threadId, `dedup:${dedupId}`);
+        const dedupKey = getDedupKey(threadId, dedupId);
         await redis.eval(
           APPEND_IDEMPOTENT_SCRIPT,
           2,
@@ -2318,20 +2544,98 @@ function createThreadManager(config) {
     async fork(newThreadId) {
       await assertThreadExists();
       const data = await redis.lrange(redisKey, 0, -1);
+      const stateRaw = await redis.get(stateKey);
       const forked = createThreadManager({
         ...config,
         threadId: newThreadId
       });
       await forked.initialize();
       if (data.length > 0) {
-        const newKey = getThreadKey(newThreadId, key);
+        const newKey = getThreadListKey(key, newThreadId);
         await redis.rpush(newKey, ...data);
         await redis.expire(newKey, THREAD_TTL_SECONDS);
       }
+      if (stateRaw != null) {
+        const newStateKey = getThreadStateKey(key, newThreadId);
+        await redis.set(newStateKey, stateRaw, "EX", THREAD_TTL_SECONDS);
+      }
       return forked;
     },
+    async replaceAll(messages) {
+      await assertThreadExists();
+      if (!idOf) {
+        throw new Error(
+          "replaceAll requires the thread manager to be configured with `idOf`"
+        );
+      }
+      const existing = await redis.lrange(redisKey, 0, -1);
+      const existingIds = existing.map((raw) => idOf(deserialize(raw))).filter((id) => typeof id === "string");
+      await redis.del(redisKey);
+      if (existingIds.length > 0) {
+        await redis.del(
+          ...existingIds.map((id) => getDedupKey(threadId, id))
+        );
+      }
+      if (messages.length > 0) {
+        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
+      await redis.expire(metaKey, THREAD_TTL_SECONDS);
+    },
     async delete() {
-      await redis.del(redisKey, metaKey);
+      await redis.del(redisKey, metaKey, stateKey);
+    },
+    async loadState() {
+      const raw = await redis.get(stateKey);
+      if (raw == null) return null;
+      return JSON.parse(raw);
+    },
+    async saveState(state) {
+      await assertThreadExists();
+      await redis.set(
+        stateKey,
+        JSON.stringify(state),
+        "EX",
+        THREAD_TTL_SECONDS
+      );
+    },
+    async deleteState() {
+      await redis.del(stateKey);
+    },
+    async length() {
+      await assertThreadExists();
+      return redis.llen(redisKey);
+    },
+    async truncateFromId(messageId) {
+      await assertThreadExists();
+      if (!idOf) {
+        throw new Error(
+          "truncateFromId requires the thread manager to be configured with `idOf`"
+        );
+      }
+      const data = await redis.lrange(redisKey, 0, -1);
+      let idx = -1;
+      const removedIds = [];
+      for (let i = 0; i < data.length; i++) {
+        const raw = data[i];
+        if (raw === void 0) continue;
+        const id = idOf(deserialize(raw));
+        if (idx === -1 && id === messageId) idx = i;
+        if (idx !== -1) removedIds.push(id);
+      }
+      if (idx === -1) return;
+      if (idx === 0) {
+        await redis.del(redisKey);
+        await redis.expire(metaKey, THREAD_TTL_SECONDS);
+      } else {
+        await redis.ltrim(redisKey, 0, idx - 1);
+        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+      }
+      if (removedIds.length > 0) {
+        await redis.del(
+          ...removedIds.map((id) => getDedupKey(threadId, id))
+        );
+      }
     }
   };
 }
@@ -2418,18 +2722,18 @@ var SandboxManager = class {
   async resume(id) {
     await this.provider.resume(id);
   }
-  async snapshot(id) {
-    return this.provider.snapshot(id);
+  async snapshot(id, options) {
+    return this.provider.snapshot(id, options);
   }
-  async restore(snapshot) {
-    const sandbox = await this.provider.restore(snapshot);
+  async restore(snapshot, options) {
+    const sandbox = await this.provider.restore(snapshot, options);
     return sandbox.id;
   }
   async deleteSnapshot(snapshot) {
     await this.provider.deleteSnapshot(snapshot);
   }
-  async fork(sandboxId) {
-    const sandbox = await this.provider.fork(sandboxId);
+  async fork(sandboxId, options) {
+    const sandbox = await this.provider.fork(sandboxId, options);
     return sandbox.id;
   }
   /**
@@ -2467,17 +2771,17 @@ var SandboxManager = class {
       resumeSandbox: async (sandboxId) => {
         await this.resume(sandboxId);
       },
-      snapshotSandbox: async (sandboxId) => {
-        return this.snapshot(sandboxId);
+      snapshotSandbox: async (sandboxId, options) => {
+        return this.snapshot(sandboxId, options);
       },
-      restoreSandbox: async (snapshot) => {
-        return this.restore(snapshot);
+      restoreSandbox: async (snapshot, options) => {
+        return this.restore(snapshot, options);
       },
       deleteSandboxSnapshot: async (snapshot) => {
         await this.deleteSnapshot(snapshot);
       },
-      forkSandbox: async (sandboxId) => {
-        return this.fork(sandboxId);
+      forkSandbox: async (sandboxId, options) => {
+        return this.fork(sandboxId, options);
       }
     };
     const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
@@ -3146,6 +3450,6 @@ var toTree = async (fs, opts = {}) => {
   return base + subtree;
 };
 
-export { FileSystemSkillProvider, NodeFsSandboxFileSystem, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, VirtualFileSystem, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, createVirtualFsActivities, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editHandler, editTool, filesWithMimeType, formatVirtualFileTree, getActivityContext, getShortId, globHandler, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, queryParentWorkflowState, readFileHandler, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, withParentWorkflowState, withSandbox, withVirtualFs, writeFileHandler, writeFileTool };
+export { DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, FileSystemSkillProvider, NodeFsSandboxFileSystem, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, THREAD_TTL_SECONDS, VirtualFileSystem, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createToolRouter, createVirtualFsActivities, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editHandler, editTool, filesWithMimeType, formatVirtualFileTree, getActivityContext, getShortId, getThreadListKey, getThreadMetaKey, globHandler, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, parseSkillFile, proxyRunAgent, proxyVirtualFsOps, queryParentWorkflowState, readFileHandler, readFileTool, taskCreateTool, taskGetTool, taskListTool, taskUpdateTool, toTree, withAutoAppend, withParentWorkflowState, withSandbox, withVirtualFs, writeFileHandler, writeFileTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map