zeitlich 0.2.45 → 0.2.47

package/dist/index.js

@@ -3,6 +3,10 @@ import z14, { z } from 'zod';
 import { randomUUID, randomFillSync } from 'crypto';
 import { ApplicationFailure as ApplicationFailure$1 } from '@temporalio/common';
 import { join, resolve, posix } from 'path';
+import { gzip, gunzip } from 'zlib';
+import { promisify } from 'util';
+import { DeleteObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
 import { Context } from '@temporalio/activity';
 import { promises } from 'fs';
 
@@ -564,7 +568,8 @@ function createSubagentHandler(subagents) {
     }
     const threadMode = config.thread ?? "new";
     const allowsContinuation = threadMode !== "new";
-    const continuationThreadId = args.threadId && allowsContinuation ? args.threadId : void 0;
+    const newThreadSource = config.newThreadSource ?? "new";
+    const continuationThreadId = !allowsContinuation ? void 0 : args.threadId ?? (newThreadSource === "from-parent" ? context.threadId : void 0);
     let thread;
     if (continuationThreadId) {
       thread = {
@@ -1032,7 +1037,9 @@ async function createSession(config) {
     appendAgentMessage,
     forkThread,
     loadThreadState,
-    saveThreadState
+    saveThreadState,
+    hydrateThread,
+    flushThread
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
@@ -1176,10 +1183,12 @@ async function createSession(config) {
         });
       };
       if (threadMode === "fork" && sourceThreadId) {
+        await hydrateThread(sourceThreadId, threadKey);
         await forkThread(sourceThreadId, threadId, threadKey);
         const forkedSlice = await loadThreadState(threadId, threadKey);
         if (forkedSlice) rehydrateFromSlice(forkedSlice);
       } else if (threadMode === "continue") {
+        await hydrateThread(threadId, threadKey);
         const continuedSlice = await loadThreadState(threadId, threadKey);
         if (continuedSlice) rehydrateFromSlice(continuedSlice);
       } else {
@@ -1361,6 +1370,15 @@ async function createSession(config) {
             error: persistError instanceof Error ? persistError.message : String(persistError)
           });
         }
+        try {
+          await flushThread(threadId, threadKey);
+        } catch (flushError) {
+          log.warn("failed to flush thread to cold tier", {
+            agentName,
+            threadId,
+            error: flushError instanceof Error ? flushError.message : String(flushError)
+          });
+        }
         await callSessionEnd(exitReason, stateManager.getTurns());
         if (sandboxOwned && sandboxId && sandboxOps) {
           switch (resolvedShutdown) {
@@ -1444,6 +1462,9 @@ function getThreadMetaKey(threadKey, threadId) {
 function getThreadStateKey(threadKey, threadId) {
   return `${threadKey}:state:thread:${threadId}`;
 }
+function getThreadDedupKey(threadId, dedupId) {
+  return `dedup:${dedupId}:thread:${threadId}`;
+}
 
 // src/lib/types.ts
 function isTerminalStatus(status) {
@@ -2196,6 +2217,13 @@ IMPORTANT:
   }),
   strict: true
 };
+var textEditSchema = z.object({
+  old_string: z.string().describe("The exact text to replace"),
+  new_string: z.string().describe("The text to replace it with"),
+  replace_all: z.boolean().optional().describe(
+    "If true, replace all occurrences of old_string for this edit (default: false)"
+  )
+});
 var editTool = {
   name: "FileEdit",
   description: `Edit specific sections of a file by replacing text.
@@ -2224,6 +2252,27 @@ IMPORTANT:
   }),
   strict: true
 };
+var multiEditTool = {
+  name: "FileMultiEdit",
+  description: `Apply multiple exact text replacements to one file in order.
+
+Usage:
+- Use this when a task needs several related edits in the same file
+- Each edit is applied to the file content produced by the prior edit
+- The operation is atomic: if any edit fails, the file is left unchanged
+
+IMPORTANT:
+- You must read the file first (in this session) before editing it
+- Each old_string must match exactly (whitespace-sensitive)
+- Each old_string must be unique unless that edit uses replace_all: true
+- old_string and new_string must be different for every edit
+`,
+  schema: z.object({
+    file_path: z.string().describe("The absolute virtual path to the file to modify"),
+    edits: z.array(textEditSchema).min(1).describe("Exact replacements to apply sequentially to the file")
+  }),
+  strict: true
+};
 var taskCreateTool = {
   name: "TaskCreate",
   description: `Use this tool to create a structured task list. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
@@ -2294,7 +2343,7 @@ function createTaskCreateHandler(stateManager) {
     };
     stateManager.setTask(task);
     return {
-      toolResponse: JSON.stringify(task, null, 2),
+      toolResponse: `Task ${task.id} created`,
       data: task
     };
   };
@@ -2393,7 +2442,7 @@ function createTaskUpdateHandler(stateManager) {
     }
     stateManager.setTask(task);
     return {
-      toolResponse: JSON.stringify(task, null, 2),
+      toolResponse: `Task ${task.id} updated`,
       data: task
     };
   };
@@ -2588,9 +2637,6 @@ redis.call('EXPIRE', KEYS[2], tonumber(ARGV[1]))
 redis.call('SET', KEYS[1], '1', 'EX', tonumber(ARGV[1]))
 return 1
 `;
-function getDedupKey(threadId, id) {
-  return `dedup:${id}:thread:${threadId}`;
-}
 function createThreadManager(config) {
   const {
     redis,
@@ -2598,11 +2644,13 @@ function createThreadManager(config) {
     key = "messages",
     serialize = (m) => JSON.stringify(m),
     deserialize = (raw) => JSON.parse(raw),
-    idOf
+    idOf,
+    ttlSeconds = THREAD_TTL_SECONDS
   } = config;
   const redisKey = getThreadListKey(key, threadId);
   const metaKey = getThreadMetaKey(key, threadId);
   const stateKey = getThreadStateKey(key, threadId);
+  const dedupKey = (id) => getThreadDedupKey(threadId, id);
   async function assertThreadExists() {
     const exists = await redis.exists(metaKey);
     if (!exists) {
@@ -2612,7 +2660,7 @@ function createThreadManager(config) {
   return {
     async initialize() {
       await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", THREAD_TTL_SECONDS);
+      await redis.set(metaKey, "1", "EX", ttlSeconds);
     },
     async load() {
       await assertThreadExists();
@@ -2624,18 +2672,17 @@ function createThreadManager(config) {
       await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        const dedupKey = getDedupKey(threadId, dedupId);
         await redis.eval(
           APPEND_IDEMPOTENT_SCRIPT,
           2,
-          dedupKey,
+          dedupKey(dedupId),
           redisKey,
-          String(THREAD_TTL_SECONDS),
+          String(ttlSeconds),
           ...messages.map(serialize)
         );
       } else {
         await redis.rpush(redisKey, ...messages.map(serialize));
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
     },
     async fork(newThreadId) {
@@ -2650,11 +2697,11 @@ function createThreadManager(config) {
       if (data.length > 0) {
         const newKey = getThreadListKey(key, newThreadId);
         await redis.rpush(newKey, ...data);
-        await redis.expire(newKey, THREAD_TTL_SECONDS);
+        await redis.expire(newKey, ttlSeconds);
       }
       if (stateRaw != null) {
         const newStateKey = getThreadStateKey(key, newThreadId);
-        await redis.set(newStateKey, stateRaw, "EX", THREAD_TTL_SECONDS);
+        await redis.set(newStateKey, stateRaw, "EX", ttlSeconds);
       }
       return forked;
     },
@@ -2669,15 +2716,13 @@ function createThreadManager(config) {
       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))
-        );
+        await redis.del(...existingIds.map(dedupKey));
       }
       if (messages.length > 0) {
         await redis.rpush(redisKey, ...messages.map(serialize));
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
-      await redis.expire(metaKey, THREAD_TTL_SECONDS);
+      await redis.expire(metaKey, ttlSeconds);
     },
     async delete() {
       await redis.del(redisKey, metaKey, stateKey);
@@ -2689,12 +2734,7 @@ function createThreadManager(config) {
     },
     async saveState(state) {
       await assertThreadExists();
-      await redis.set(
-        stateKey,
-        JSON.stringify(state),
-        "EX",
-        THREAD_TTL_SECONDS
-      );
+      await redis.set(stateKey, JSON.stringify(state), "EX", ttlSeconds);
     },
     async deleteState() {
       await redis.del(stateKey);
@@ -2723,15 +2763,13 @@ function createThreadManager(config) {
       if (idx === -1) return;
       if (idx === 0) {
         await redis.del(redisKey);
-        await redis.expire(metaKey, THREAD_TTL_SECONDS);
+        await redis.expire(metaKey, ttlSeconds);
       } else {
         await redis.ltrim(redisKey, 0, idx - 1);
-        await redis.expire(redisKey, THREAD_TTL_SECONDS);
+        await redis.expire(redisKey, ttlSeconds);
       }
       if (removedIds.length > 0) {
-        await redis.del(
-          ...removedIds.map((id) => getDedupKey(threadId, id))
-        );
+        await redis.del(...removedIds.map(dedupKey));
       }
     }
   };
@@ -2771,6 +2809,199 @@ function withParentWorkflowState(client, handler) {
   };
 }
 
+// src/lib/thread/cold-store.ts
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
+function joinKey(parts) {
+  return parts.map((p) => p.replace(/^\/+|\/+$/g, "")).filter((p) => p.length > 0).join("/");
+}
+function buildKey(prefix, threadKey, threadId, gzip) {
+  const ext = gzip ? "json.gz" : "json";
+  return joinKey([
+    prefix ?? "threads",
+    threadKey,
+    `${threadId}.${ext}`
+  ]);
+}
+async function streamToBuffer(body, onChunk) {
+  if (body == null) return Buffer.alloc(0);
+  if (body instanceof Uint8Array) return Buffer.from(body);
+  if (typeof body[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    for await (const chunk of body) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      onChunk?.();
+    }
+    return Buffer.concat(chunks);
+  }
+  if (typeof body.transformToByteArray === "function") {
+    const bytes = await body.transformToByteArray();
+    return Buffer.from(bytes);
+  }
+  if (typeof body.arrayBuffer === "function") {
+    const ab = await body.arrayBuffer();
+    return Buffer.from(ab);
+  }
+  return Buffer.alloc(0);
+}
+function createS3ColdStore(config) {
+  const { s3, bucket, prefix, gzip = true } = config;
+  const contentType = config.contentType ?? (gzip ? "application/gzip" : "application/json");
+  return {
+    async read(threadKey, threadId) {
+      const Key = buildKey(prefix, threadKey, threadId, gzip);
+      try {
+        const resp = await s3.send(
+          new GetObjectCommand({ Bucket: bucket, Key })
+        );
+        const { heartbeat } = getActivityContext();
+        const buf = await streamToBuffer(resp.Body, heartbeat);
+        const json = gzip ? (await gunzipAsync(buf)).toString("utf8") : buf.toString("utf8");
+        return JSON.parse(json);
+      } catch (err) {
+        if (isNotFound(err)) return null;
+        throw err;
+      }
+    },
+    async write(threadKey, threadId, snapshot) {
+      const Key = buildKey(prefix, threadKey, threadId, gzip);
+      const json = JSON.stringify(snapshot);
+      const body = gzip ? await gzipAsync(Buffer.from(json, "utf8")) : json;
+      const upload = new Upload({
+        client: s3,
+        params: { Bucket: bucket, Key, Body: body, ContentType: contentType }
+      });
+      const { heartbeat } = getActivityContext();
+      if (heartbeat) upload.on("httpUploadProgress", heartbeat);
+      await upload.done();
+    },
+    async delete(threadKey, threadId) {
+      const Key = buildKey(prefix, threadKey, threadId, gzip);
+      await s3.send(new DeleteObjectCommand({ Bucket: bucket, Key }));
+    }
+  };
+}
+function isNotFound(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const e = err;
+  return e.name === "NoSuchKey" || e.Code === "NoSuchKey" || e.code === "NoSuchKey" || e.name === "NotFound" || e.$metadata?.httpStatusCode === 404;
+}
+
+// src/lib/thread/snapshot.ts
+async function encodeSnapshot(config) {
+  const { redis, threadKey, threadId, idOf } = config;
+  const metaKey = getThreadMetaKey(threadKey, threadId);
+  if (await redis.exists(metaKey) === 0) {
+    return null;
+  }
+  const listKey = getThreadListKey(threadKey, threadId);
+  const stateKey = getThreadStateKey(threadKey, threadId);
+  const messages = await redis.lrange(listKey, 0, -1);
+  const stateRaw = await redis.get(stateKey);
+  const state = stateRaw == null ? null : JSON.parse(stateRaw);
+  const dedupIds = idOf ? messages.map(idOf) : [];
+  return { v: 1, messages, state, dedupIds };
+}
+async function applySnapshot(config) {
+  const {
+    redis,
+    threadKey,
+    threadId,
+    snapshot,
+    ttlSeconds = THREAD_TTL_SECONDS
+  } = config;
+  const metaKey = getThreadMetaKey(threadKey, threadId);
+  if (await redis.exists(metaKey) === 1) {
+    return;
+  }
+  const listKey = getThreadListKey(threadKey, threadId);
+  const stateKey = getThreadStateKey(threadKey, threadId);
+  await redis.del(listKey, stateKey);
+  const pipeline = redis.pipeline();
+  if (snapshot.messages.length > 0) {
+    pipeline.rpush(listKey, ...snapshot.messages);
+    pipeline.expire(listKey, ttlSeconds);
+  }
+  if (snapshot.state != null) {
+    pipeline.set(stateKey, JSON.stringify(snapshot.state), "EX", ttlSeconds);
+  }
+  for (const id of snapshot.dedupIds) {
+    pipeline.set(getThreadDedupKey(threadId, id), "1", "EX", ttlSeconds);
+  }
+  const results = await pipeline.exec();
+  if (results) {
+    const firstErr = results.find(([err]) => err)?.[0] ?? null;
+    if (firstErr) {
+      await redis.del(
+        listKey,
+        stateKey,
+        ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
+      ).catch(() => void 0);
+      throw firstErr;
+    }
+  }
+  await redis.set(metaKey, "1", "EX", ttlSeconds);
+}
+async function clearHotTier(config) {
+  const { redis, threadKey, threadId, dedupIds = [] } = config;
+  const keys = [
+    getThreadListKey(threadKey, threadId),
+    getThreadMetaKey(threadKey, threadId),
+    getThreadStateKey(threadKey, threadId),
+    ...dedupIds.map((id) => getThreadDedupKey(threadId, id))
+  ];
+  await redis.del(...keys);
+}
+
+// src/lib/thread/tiered.ts
+function createTieredThreadManager(config) {
+  const {
+    redis,
+    threadId,
+    key = "messages",
+    coldStore,
+    idOf,
+    deserialize = (raw) => JSON.parse(raw),
+    ttlSeconds = THREAD_TTL_SECONDS
+  } = config;
+  const base = createThreadManager(config);
+  const rawIdOf = idOf ? (raw) => idOf(deserialize(raw)) : void 0;
+  return Object.assign(base, {
+    async hydrate() {
+      if (!coldStore) return;
+      const snapshot = await coldStore.read(key, threadId);
+      if (!snapshot) return;
+      await applySnapshot({
+        redis,
+        threadKey: key,
+        threadId,
+        snapshot,
+        ttlSeconds
+      });
+    },
+    async flush(opts) {
+      if (!coldStore) return;
+      const snapshot = await encodeSnapshot({
+        redis,
+        threadKey: key,
+        threadId,
+        ...rawIdOf ? { idOf: rawIdOf } : {}
+      });
+      if (!snapshot) return;
+      await coldStore.write(key, threadId, snapshot);
+      const deleteHot = opts?.deleteHot ?? true;
+      if (deleteHot) {
+        await clearHotTier({
+          redis,
+          threadKey: key,
+          threadId,
+          dedupIds: snapshot.dedupIds
+        });
+      }
+    }
+  });
+}
+
 // src/lib/sandbox/manager.ts
 var CAP_METHOD_TO_CAPABILITY = [
   { method: "pause", capability: "pause" },
@@ -3441,57 +3672,190 @@ ${result.stderr}`,
 };
 
 // src/tools/edit/handler.ts
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function splitLines(text) {
+  if (text.length === 0) return [];
+  return text.replace(/\r\n/g, "\n").split("\n");
+}
+function lineNumberAt(content, index) {
+  let line = 1;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+function lineEnd(startLine, lines) {
+  return lines.length === 0 ? startLine : startLine + lines.length - 1;
+}
+function indicesOf(content, needle) {
+  const indices = [];
+  let cursor = 0;
+  while (cursor <= content.length) {
+    const index = content.indexOf(needle, cursor);
+    if (index === -1) break;
+    indices.push(index);
+    cursor = index + needle.length;
+  }
+  return indices;
+}
+function makeHunk(editIndex, beforeContent, replacementIndex, oldString, newString) {
+  const oldStartLine = lineNumberAt(beforeContent, replacementIndex);
+  const oldLines = splitLines(oldString);
+  const newLines = splitLines(newString);
+  return {
+    editIndex,
+    oldStartLine,
+    oldEndLine: lineEnd(oldStartLine, oldLines),
+    newStartLine: oldStartLine,
+    newEndLine: lineEnd(oldStartLine, newLines),
+    oldLines,
+    newLines
+  };
+}
+function applyOneEdit(content, edit, editIndex) {
+  const { old_string, new_string, replace_all = false } = edit;
+  if (old_string.length === 0) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string for edit ${editIndex} must not be empty.`
+    };
+  }
+  if (old_string === new_string) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string and new_string must be different for edit ${editIndex}.`
+    };
+  }
+  const matches = indicesOf(content, old_string);
+  if (matches.length === 0) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: Could not find old_string for edit ${editIndex}. Make sure it matches exactly (whitespace-sensitive).`
+    };
+  }
+  if (!replace_all && matches.length > 1) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string for edit ${editIndex} appears ${matches.length} times. Provide more context to make it unique, or use replace_all: true for that edit.`
+    };
+  }
+  if (replace_all) {
+    const hunks = matches.map(
+      (index2) => makeHunk(editIndex, content, index2, old_string, new_string)
+    );
+    return {
+      ok: true,
+      content: content.split(old_string).join(new_string),
+      replacements: matches.length,
+      hunks
+    };
+  }
+  const index = matches[0];
+  if (index === void 0) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: Could not find old_string for edit ${editIndex}.`
+    };
+  }
+  return {
+    ok: true,
+    content: content.slice(0, index) + new_string + content.slice(index + old_string.length),
+    replacements: 1,
+    hunks: [makeHunk(editIndex, content, index, old_string, new_string)]
+  };
+}
+function applyEditPlan(content, edits) {
+  if (edits.length === 0) {
+    return {
+      ok: false,
+      message: "Error: edits must contain at least one edit."
+    };
+  }
+  let current = content;
+  let replacements = 0;
+  const hunks = [];
+  for (const [index, edit] of edits.entries()) {
+    const result = applyOneEdit(current, edit, index);
+    if (!result.ok) return result;
+    current = result.content;
+    replacements += result.replacements;
+    hunks.push(...result.hunks);
+  }
+  return { ok: true, content: current, replacements, hunks };
+}
+function editFailureResult(filePath, message) {
+  return {
+    toolResponse: message,
+    data: { path: filePath, success: false, replacements: 0 }
+  };
 }
 var editHandler = async (args, { sandbox }) => {
   const { fs } = sandbox;
   const { file_path, old_string, new_string, replace_all = false } = args;
-  if (old_string === new_string) {
+  try {
+    const exists = await fs.exists(file_path);
+    if (!exists) {
+      return editFailureResult(
+        file_path,
+        `Error: File "${file_path}" does not exist.`
+      );
+    }
+    const content = await fs.readFile(file_path);
+    const result = applyEditPlan(content, [
+      { old_string, new_string, replace_all }
+    ]);
+    if (!result.ok) {
+      return editFailureResult(file_path, result.message);
+    }
+    await fs.writeFile(file_path, result.content);
+    const summary = replace_all ? `Replaced ${result.replacements} occurrence(s)` : `Replaced 1 occurrence`;
+    return {
+      toolResponse: `${summary} in ${file_path}`,
+      data: {
+        path: file_path,
+        success: true,
+        replacements: result.replacements,
+        hunks: result.hunks
+      }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
     return {
-      toolResponse: `Error: old_string and new_string must be different.`,
+      toolResponse: `Error editing file "${file_path}": ${message}`,
       data: { path: file_path, success: false, replacements: 0 }
     };
   }
+};
+var multiEditHandler = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { file_path, edits } = args;
   try {
     const exists = await fs.exists(file_path);
     if (!exists) {
-      return {
-        toolResponse: `Error: File "${file_path}" does not exist.`,
-        data: { path: file_path, success: false, replacements: 0 }
-      };
+      return editFailureResult(
+        file_path,
+        `Error: File "${file_path}" does not exist.`
+      );
     }
     const content = await fs.readFile(file_path);
-    if (!content.includes(old_string)) {
-      return {
-        toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-        data: { path: file_path, success: false, replacements: 0 }
-      };
+    const result = applyEditPlan(content, edits);
+    if (!result.ok) {
+      const suffix = result.editIndex === void 0 ? "" : ` in ${file_path}`;
+      return editFailureResult(file_path, `${result.message}${suffix}`);
     }
-    const escapedOldString = escapeRegExp(old_string);
-    const globalRegex = new RegExp(escapedOldString, "g");
-    const occurrences = (content.match(globalRegex) || []).length;
-    if (!replace_all && occurrences > 1) {
-      return {
-        toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-        data: { path: file_path, success: false, replacements: 0 }
-      };
-    }
-    let newContent;
-    let replacements;
-    if (replace_all) {
-      newContent = content.split(old_string).join(new_string);
-      replacements = occurrences;
-    } else {
-      const index = content.indexOf(old_string);
-      newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
-      replacements = 1;
-    }
-    await fs.writeFile(file_path, newContent);
-    const summary = replace_all ? `Replaced ${replacements} occurrence(s)` : `Replaced 1 occurrence`;
+    await fs.writeFile(file_path, result.content);
     return {
-      toolResponse: `${summary} in ${file_path}`,
-      data: { path: file_path, success: true, replacements }
+      toolResponse: `Applied ${edits.length} edit(s), ${result.replacements} replacement(s) in ${file_path}`,
+      data: {
+        path: file_path,
+        success: true,
+        replacements: result.replacements,
+        hunks: result.hunks
+      }
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -3671,6 +4035,6 @@ var toTree = async (fs, opts = {}) => {
   return base + subtree;
 };
 
-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 };
+export { DEFAULT_SUBAGENT_WORKFLOW_RUN_TIMEOUT, FileSystemSkillProvider, NodeFsSandboxFileSystem, SandboxManager, SandboxNotFoundError, SandboxNotSupportedError, THREAD_TTL_SECONDS, VirtualFileSystem, applySnapshot, applyVirtualTreeMutations, askUserQuestionTool, bashHandler, bashTool, clearHotTier, composeHooks, createAgentStateManager, createAskUserQuestionHandler, createBashToolDescription, createObservabilityHooks, createReadSkillHandler, createReadSkillTool, createRunAgentActivity, createS3ColdStore, createSession, createTaskCreateHandler, createTaskGetHandler, createTaskListHandler, createTaskUpdateHandler, createThreadManager, createTieredThreadManager, createToolRouter, createVirtualFsActivities, defineSubagent, defineSubagentWorkflow, defineTool, defineWorkflow, editHandler, editTool, encodeSnapshot, filesWithMimeType, formatVirtualFileTree, getActivityContext, getShortId, getThreadDedupKey, getThreadListKey, getThreadMetaKey, getThreadStateKey, globHandler, globTool, grepTool, hasDirectory, hasFileWithMimeType, hasNoOtherToolCalls, isTerminalStatus, multiEditHandler, multiEditTool, 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