zeitlich 0.2.36 → 0.2.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.36",
+  "version": "0.2.38",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -210,7 +210,7 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.80.0",
+    "@anthropic-ai/sdk": "^0.81.0",
     "@aws-sdk/client-bedrock-agentcore": "^3.900.0",
     "@daytonaio/sdk": "^0.158.1",
     "@e2b/code-interpreter": "^2.3.3",

package/src/adapters/sandbox/bedrock/filesystem.ts

@@ -26,9 +26,7 @@ async function consumeStream(
         event.resourceNotFoundException.message ?? "Resource not found"
       );
     if ("validationException" in event && event.validationException)
-      throw new Error(
-        event.validationException.message ?? "Validation error"
-      );
+      throw new Error(event.validationException.message ?? "Validation error");
     if ("internalServerException" in event && event.internalServerException)
       throw new Error(
         event.internalServerException.message ?? "Internal server error"
@@ -185,9 +183,7 @@ export class BedrockSandboxFileSystem implements SandboxFileSystem {
   async appendFile(path: string, content: string | Uint8Array): Promise<void> {
     const norm = this.normalisePath(path);
     const addition =
-      typeof content === "string"
-        ? content
-        : new TextDecoder().decode(content);
+      typeof content === "string" ? content : new TextDecoder().decode(content);
     const escaped = addition.replace(/'/g, "'\\''");
     const { exitCode, stderr } = await this.execShell(
       `printf '%s' '${escaped}' >> "${norm}"`
@@ -227,9 +223,7 @@ export class BedrockSandboxFileSystem implements SandboxFileSystem {
   async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
     const norm = this.normalisePath(path);
     const flag = options?.recursive ? "-p " : "";
-    const { exitCode, stderr } = await this.execShell(
-      `mkdir ${flag}"${norm}"`
-    );
+    const { exitCode, stderr } = await this.execShell(`mkdir ${flag}"${norm}"`);
     if (exitCode !== 0) throw new Error(`mkdir failed: ${stderr}`);
   }
 
@@ -287,7 +281,8 @@ export class BedrockSandboxFileSystem implements SandboxFileSystem {
   ): Promise<void> {
     const norm = this.normalisePath(path);
     if (options?.recursive || options?.force) {
-      const flags = `${options?.recursive ? "-r" : ""} ${options?.force ? "-f" : ""}`.trim();
+      const flags =
+        `${options?.recursive ? "-r" : ""} ${options?.force ? "-f" : ""}`.trim();
       const { exitCode, stderr } = await this.execShell(
         `rm ${flags} "${norm}"`
       );
@@ -301,8 +296,7 @@ export class BedrockSandboxFileSystem implements SandboxFileSystem {
       paths: [rel],
     });
     if (result.isError) {
-      const msg =
-        result.content?.map((b) => b.text).join("") ?? "rm failed";
+      const msg = result.content?.map((b) => b.text).join("") ?? "rm failed";
       throw new Error(msg);
     }
   }

package/src/adapters/sandbox/bedrock/index.ts

@@ -49,9 +49,7 @@ async function consumeExecStream(
         event.resourceNotFoundException.message ?? "Resource not found"
       );
     if ("validationException" in event && event.validationException)
-      throw new Error(
-        event.validationException.message ?? "Validation error"
-      );
+      throw new Error(event.validationException.message ?? "Validation error");
     if ("internalServerException" in event && event.internalServerException)
       throw new Error(
         event.internalServerException.message ?? "Internal server error"
@@ -118,8 +116,7 @@ class BedrockSandboxImpl implements Sandbox {
       })
     );
 
-    if (!resp.stream)
-      throw new Error("No stream in code interpreter response");
+    if (!resp.stream) throw new Error("No stream in code interpreter response");
     return consumeExecStream(resp.stream);
   }
 
@@ -137,9 +134,10 @@ class BedrockSandboxImpl implements Sandbox {
 // BedrockSandboxProvider
 // ============================================================================
 
-export class BedrockSandboxProvider
-  implements SandboxProvider<BedrockSandboxCreateOptions, BedrockSandbox>
-{
+export class BedrockSandboxProvider implements SandboxProvider<
+  BedrockSandboxCreateOptions,
+  BedrockSandbox
+> {
   readonly id = "bedrock";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
@@ -241,17 +239,30 @@ export class BedrockSandboxProvider
     // Bedrock sandboxes don't support pause, so resume is a no-op
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    _sandboxId: string,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError("snapshot");
   }
 
-  async restore(_snapshot: SandboxSnapshot): Promise<never> {
+  async restore(
+    _snapshot: SandboxSnapshot,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<never> {
     throw new SandboxNotSupportedError("restore");
   }
 
-  async fork(_sandboxId: string): Promise<Sandbox> {
+  async fork(
+    _sandboxId: string,
+    _options?: BedrockSandboxCreateOptions
+  ): Promise<Sandbox> {
     throw new SandboxNotSupportedError("fork");
   }
+
+  async deleteSnapshot(_snapshot: SandboxSnapshot): Promise<void> {
+    throw new SandboxNotSupportedError("deleteSnapshot");
+  }
 }
 
 // Re-exports

package/src/adapters/sandbox/bedrock/proxy.ts

@@ -52,6 +52,8 @@ export function proxyBedrockSandboxOps(
     pauseSandbox: acts[p("pauseSandbox")],
     resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
+    restoreSandbox: acts[p("restoreSandbox")],
+    deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<BedrockSandboxCreateOptions>;
 }

package/src/adapters/sandbox/daytona/index.ts

@@ -149,21 +149,36 @@ export class DaytonaSandboxProvider implements SandboxProvider<
     // Daytona sandboxes don't support pause, so resume is a no-op
   }
 
-  async fork(_sandboxId: string): Promise<Sandbox> {
+  async fork(
+    _sandboxId: string,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<Sandbox> {
     throw new Error("Not implemented");
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    _sandboxId: string,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError(
       "snapshot (use Daytona's native snapshot API directly)"
     );
   }
 
-  async restore(_snapshot: SandboxSnapshot): Promise<never> {
+  async restore(
+    _snapshot: SandboxSnapshot,
+    _options?: DaytonaSandboxCreateOptions
+  ): Promise<never> {
     throw new SandboxNotSupportedError(
       "restore (use Daytona's native snapshot API directly)"
     );
   }
+
+  async deleteSnapshot(_snapshot: SandboxSnapshot): Promise<void> {
+    throw new SandboxNotSupportedError(
+      "deleteSnapshot (use Daytona's native snapshot API directly)"
+    );
+  }
 }
 
 // Re-exports

package/src/adapters/sandbox/daytona/proxy.ts

@@ -52,6 +52,8 @@ export function proxyDaytonaSandboxOps(
     pauseSandbox: acts[p("pauseSandbox")],
     resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
+    restoreSandbox: acts[p("restoreSandbox")],
+    deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<DaytonaSandboxCreateOptions>;
 }

package/src/adapters/sandbox/e2b/filesystem.ts

@@ -7,7 +7,10 @@ import type {
 import { posix } from "node:path";
 
 function toArrayBuffer(u8: Uint8Array): ArrayBuffer {
-  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength) as ArrayBuffer;
+  return u8.buffer.slice(
+    u8.byteOffset,
+    u8.byteOffset + u8.byteLength
+  ) as ArrayBuffer;
 }
 
 /**
@@ -59,9 +62,7 @@ export class E2bSandboxFileSystem implements SandboxFileSystem {
       // file doesn't exist yet — write from scratch
     }
     const addition =
-      typeof content === "string"
-        ? content
-        : new TextDecoder().decode(content);
+      typeof content === "string" ? content : new TextDecoder().decode(content);
     await this.sandbox.files.write(norm, existing + addition);
   }
 

package/src/adapters/sandbox/e2b/index.ts

@@ -62,9 +62,10 @@ class E2bSandboxImpl implements Sandbox {
 // E2bSandboxProvider
 // ============================================================================
 
-export class E2bSandboxProvider
-  implements SandboxProvider<E2bSandboxCreateOptions, E2bSandbox>
-{
+export class E2bSandboxProvider implements SandboxProvider<
+  E2bSandboxCreateOptions,
+  E2bSandbox
+> {
   readonly id = "e2b";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
@@ -75,11 +76,19 @@ export class E2bSandboxProvider
   private readonly defaultTemplate?: string;
   private readonly defaultWorkspaceBase: string;
   private readonly defaultTimeoutMs?: number;
+  private readonly defaultAllowInternetAccess?: boolean;
+  private readonly defaultNetwork?: E2bSandboxConfig["network"];
+  private readonly defaultMetadata?: E2bSandboxConfig["metadata"];
+  private readonly defaultLifecycle?: E2bSandboxConfig["lifecycle"];
 
   constructor(config?: E2bSandboxConfig) {
     this.defaultTemplate = config?.template;
     this.defaultWorkspaceBase = config?.workspaceBase ?? "/home/user";
     this.defaultTimeoutMs = config?.timeoutMs;
+    this.defaultAllowInternetAccess = config?.allowInternetAccess;
+    this.defaultNetwork = config?.network;
+    this.defaultMetadata = config?.metadata;
+    this.defaultLifecycle = config?.lifecycle;
   }
 
   async create(
@@ -87,10 +96,7 @@ export class E2bSandboxProvider
   ): Promise<SandboxCreateResult> {
     const template = options?.template ?? this.defaultTemplate;
     const workspaceBase = this.defaultWorkspaceBase;
-    const createOpts = {
-      envs: options?.env,
-      timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
-    };
+    const createOpts = this.buildSdkCreateOpts(options);
 
     const sdkSandbox = template
       ? await E2bSdkSandbox.create(template, createOpts)
@@ -116,7 +122,11 @@ export class E2bSandboxProvider
   async get(sandboxId: string): Promise<E2bSandbox> {
     try {
       const sdkSandbox = await E2bSdkSandbox.connect(sandboxId);
-      return new E2bSandboxImpl(sandboxId, sdkSandbox, this.defaultWorkspaceBase);
+      return new E2bSandboxImpl(
+        sandboxId,
+        sdkSandbox,
+        this.defaultWorkspaceBase
+      );
     } catch {
       throw new SandboxNotFoundError(sandboxId);
     }
@@ -140,23 +150,86 @@ export class E2bSandboxProvider
     await E2bSdkSandbox.connect(sandboxId);
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
-    throw new SandboxNotSupportedError("snapshot");
+  async snapshot(
+    sandboxId: string,
+    _options?: E2bSandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
+    const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
+    return {
+      sandboxId,
+      providerId: this.id,
+      data: { snapshotId },
+      createdAt: new Date().toISOString(),
+    };
+  }
+
+  async restore(
+    snapshot: SandboxSnapshot,
+    options?: E2bSandboxCreateOptions
+  ): Promise<Sandbox> {
+    const data = snapshot.data as { snapshotId?: string } | null;
+    if (!data?.snapshotId) {
+      throw new SandboxNotSupportedError(
+        "restore: snapshot is missing snapshotId"
+      );
+    }
+    const sdkOpts = this.buildSdkCreateOpts(options);
+    const sdkSandbox = await E2bSdkSandbox.create(data.snapshotId, sdkOpts);
+    return new E2bSandboxImpl(
+      sdkSandbox.sandboxId,
+      sdkSandbox,
+      this.defaultWorkspaceBase
+    );
   }
 
-  async restore(_snapshot: SandboxSnapshot): Promise<Sandbox> {
-    throw new SandboxNotSupportedError("restore");
+  async deleteSnapshot(snapshot: SandboxSnapshot): Promise<void> {
+    const data = snapshot.data as { snapshotId?: string } | null;
+    if (!data?.snapshotId) return;
+    try {
+      await E2bSdkSandbox.deleteSnapshot(data.snapshotId);
+    } catch {
+      // Already deleted or no longer accessible — treat as no-op.
+    }
   }
 
-  async fork(sandboxId: string): Promise<Sandbox> {
+  async fork(
+    sandboxId: string,
+    options?: E2bSandboxCreateOptions
+  ): Promise<Sandbox> {
     const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
-    const sdkSandbox = await E2bSdkSandbox.create(snapshotId);
+    const sdkOpts = this.buildSdkCreateOpts(options);
+    const sdkSandbox = await E2bSdkSandbox.create(snapshotId, sdkOpts);
     return new E2bSandboxImpl(
       sdkSandbox.sandboxId,
       sdkSandbox,
       this.defaultWorkspaceBase
     );
   }
+
+  private buildSdkCreateOpts(options?: E2bSandboxCreateOptions) {
+    const network = options?.network ?? this.defaultNetwork;
+    const lifecycle = options?.lifecycle ?? this.defaultLifecycle;
+    return {
+      envs: options?.env,
+      timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
+      metadata: options?.metadata ?? this.defaultMetadata,
+      allowInternetAccess:
+        options?.allowInternetAccess ?? this.defaultAllowInternetAccess,
+      network: network
+        ? {
+            allowOut: network.allowOut,
+            denyOut: network.denyOut,
+            allowPublicTraffic: network.allowPublicTraffic,
+          }
+        : undefined,
+      lifecycle: lifecycle
+        ? {
+            onTimeout: lifecycle.onTimeout,
+            autoResume: lifecycle.autoResume,
+          }
+        : undefined,
+    };
+  }
 }
 
 // Re-exports

package/src/adapters/sandbox/e2b/proxy.ts

@@ -52,6 +52,8 @@ export function proxyE2bSandboxOps(
     pauseSandbox: acts[p("pauseSandbox")],
     resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
+    restoreSandbox: acts[p("restoreSandbox")],
+    deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps<E2bSandboxCreateOptions>;
 }

package/src/adapters/sandbox/e2b/types.ts

@@ -6,6 +6,14 @@ import type { E2bSandboxFileSystem } from "./filesystem";
  */
 export type E2bSandbox = Sandbox & { fs: E2bSandboxFileSystem };
 
+/**
+ * Provider-level defaults for E2B sandboxes. Every lifecycle op
+ * (`create` / `restore` / `fork`) merges per-call options on top of these —
+ * per-call options win per-field. This is how E2B preserves sandbox-level
+ * config (network policy, metadata, lifecycle, timeout) across
+ * snapshot/restore and fork, since the E2B API treats those as pure
+ * create-time inputs that aren't carried in the snapshot blob.
+ */
 export interface E2bSandboxConfig {
   /** Sandbox template name or ID */
   template?: string;
@@ -13,6 +21,14 @@ export interface E2bSandboxConfig {
   workspaceBase?: string;
   /** Sandbox idle timeout in milliseconds */
   timeoutMs?: number;
+  /** Default outbound internet access policy */
+  allowInternetAccess?: boolean;
+  /** Default outbound network allow/deny rules */
+  network?: SandboxCreateOptions["network"];
+  /** Default metadata surfaced via provider list/query APIs */
+  metadata?: SandboxCreateOptions["metadata"];
+  /** Default sandbox timeout behaviour */
+  lifecycle?: SandboxCreateOptions["lifecycle"];
 }
 
 export interface E2bSandboxCreateOptions extends SandboxCreateOptions {

package/src/adapters/sandbox/inmemory/index.ts

@@ -183,7 +183,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     return { sandbox };
   }
 
-  async snapshot(sandboxId: string): Promise<SandboxSnapshot> {
+  async snapshot(
+    sandboxId: string,
+    _options?: SandboxCreateOptions
+  ): Promise<SandboxSnapshot> {
     const sandbox = this.sandboxes.get(sandboxId);
     if (!sandbox) throw new SandboxNotFoundError(sandboxId);
 
@@ -210,7 +213,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     };
   }
 
-  async fork(sandboxId: string): Promise<Sandbox> {
+  async fork(
+    sandboxId: string,
+    _options?: SandboxCreateOptions
+  ): Promise<Sandbox> {
     const sandbox = await this.get(sandboxId);
 
     const entries = await sandbox.fs.readdirWithFileTypes("/");
@@ -228,7 +234,10 @@ export class InMemorySandboxProvider implements SandboxProvider {
     return newSandbox.sandbox;
   }
 
-  async restore(snapshot: SandboxSnapshot): Promise<Sandbox> {
+  async restore(
+    snapshot: SandboxSnapshot,
+    _options?: SandboxCreateOptions
+  ): Promise<Sandbox> {
     const { files } = snapshot.data as { files: Record<string, string> };
     const initialFiles: InitialFiles = {};
     for (const [path, content] of Object.entries(files)) {
@@ -244,4 +253,9 @@ export class InMemorySandboxProvider implements SandboxProvider {
     this.sandboxes.set(sandbox.id, sandbox);
     return sandbox;
   }
+
+  async deleteSnapshot(_snapshot: SandboxSnapshot): Promise<void> {
+    // In-memory snapshots are opaque data held by the caller — nothing to
+    // delete on the provider side.
+  }
 }

package/src/adapters/sandbox/inmemory/proxy.ts

@@ -49,6 +49,8 @@ export function proxyInMemorySandboxOps(
     pauseSandbox: acts[p("pauseSandbox")],
     resumeSandbox: acts[p("resumeSandbox")],
     snapshotSandbox: acts[p("snapshotSandbox")],
+    restoreSandbox: acts[p("restoreSandbox")],
+    deleteSandboxSnapshot: acts[p("deleteSandboxSnapshot")],
     forkSandbox: acts[p("forkSandbox")],
   } as SandboxOps;
 }

package/src/adapters/thread/anthropic/activities.ts

@@ -25,8 +25,10 @@ import {
 
 const ADAPTER_PREFIX = "anthropic" as const;
 
-export type AnthropicThreadOps<TScope extends string = ""> =
-  PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_PREFIX>, AnthropicContent>;
+export type AnthropicThreadOps<TScope extends string = ""> = PrefixedThreadOps<
+  ScopedPrefix<TScope, typeof ADAPTER_PREFIX>,
+  AnthropicContent
+>;
 
 export interface AnthropicAdapterConfig {
   redis: Redis;
@@ -47,7 +49,8 @@ export interface AnthropicAdapterConfig {
  *   (e.g. `{ type: "text", text: "..." }`, `{ type: "image", source: { ... } }`).
  *   Passed through as-is to the `tool_result` block.
  */
-export type AnthropicToolResponse = Anthropic.Messages.ToolResultBlockParam["content"];
+export type AnthropicToolResponse =
+  Anthropic.Messages.ToolResultBlockParam["content"];
 
 export interface AnthropicAdapter {
   /** Model invoker using the default model (only available when `model` was provided) */
@@ -55,7 +58,7 @@ export interface AnthropicAdapter {
   /** Create an invoker for a specific model name (for multi-model setups) */
   createModelInvoker(
     model: string,
-    maxTokens?: number,
+    maxTokens?: number
   ): ModelInvoker<Anthropic.Messages.Message>;
   /**
    * Create prefixed thread activities for registration on the worker.
@@ -72,9 +75,7 @@ export interface AnthropicAdapter {
    * // → { anthropicResearchAgentInitializeThread, … }
    * ```
    */
-  createActivities<S extends string = "">(
-    scope?: S,
-  ): AnthropicThreadOps<S>;
+  createActivities<S extends string = "">(scope?: S): AnthropicThreadOps<S>;
 
   /**
    * Identity wrapper that types a tool handler for this adapter.
@@ -83,8 +84,8 @@ export interface AnthropicAdapter {
   wrapHandler<TArgs, TResult, TContext extends RouterContext = RouterContext>(
     handler: (
       args: TArgs,
-      context: TContext,
-    ) => Promise<ToolHandlerResponse<TResult, AnthropicToolResponse>>,
+      context: TContext
+    ) => Promise<ToolHandlerResponse<TResult, AnthropicToolResponse>>
   ): ActivityToolHandler<TArgs, TResult, TContext, AnthropicToolResponse>;
 }
 
@@ -130,13 +131,20 @@ export interface AnthropicAdapter {
  * ```
  */
 export function createAnthropicAdapter(
-  config: AnthropicAdapterConfig,
+  config: AnthropicAdapterConfig
 ): AnthropicAdapter {
   const { redis, client } = config;
 
   const threadOps: ThreadOps<AnthropicContent> = {
-    async initializeThread(threadId: string, threadKey?: string): Promise<void> {
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+    async initializeThread(
+      threadId: string,
+      threadKey?: string
+    ): Promise<void> {
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.initialize();
     },
 
@@ -144,9 +152,13 @@ export function createAnthropicAdapter(
       threadId: string,
       id: string,
       content: AnthropicContent,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendUserMessage(id, content);
     },
 
@@ -154,15 +166,23 @@ export function createAnthropicAdapter(
       threadId: string,
       id: string,
       content: AnthropicSystemContent,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendSystemMessage(id, content);
     },
 
     async appendToolResult(id: string, cfg: ToolResultConfig): Promise<void> {
       const { threadId, threadKey, toolCallId, toolName, content } = cfg;
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendToolResult(id, toolCallId, toolName, content);
     },
 
@@ -170,16 +190,20 @@ export function createAnthropicAdapter(
       threadId: string,
       id: string,
       message: Anthropic.Messages.Message,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
-      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      const thread = createAnthropicThreadManager({
+        redis,
+        threadId,
+        key: threadKey,
+      });
       await thread.appendAssistantMessage(id, message.content);
     },
 
     async forkThread(
       sourceThreadId: string,
       targetThreadId: string,
-      threadKey?: string,
+      threadKey?: string
     ): Promise<void> {
       const thread = createAnthropicThreadManager({
         redis,
@@ -188,24 +212,32 @@ export function createAnthropicAdapter(
       });
       await thread.fork(targetThreadId);
     },
+
+    async truncateThread(
+      threadId: string,
+      length: number,
+      threadKey?: string,
+    ): Promise<void> {
+      const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey });
+      await thread.truncate(length);
+    },
   };
 
   function createActivities<S extends string = "">(
-    scope?: S,
+    scope?: S
   ): AnthropicThreadOps<S> {
     const prefix = scope
       ? `${ADAPTER_PREFIX}${scope.charAt(0).toUpperCase()}${scope.slice(1)}`
       : ADAPTER_PREFIX;
-    const cap = (s: string): string =>
-      s.charAt(0).toUpperCase() + s.slice(1);
+    const cap = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
     return Object.fromEntries(
-      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v]),
+      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
     ) as AnthropicThreadOps<S>;
   }
 
   const makeInvoker = (
     model: string,
-    maxTokens?: number,
+    maxTokens?: number
   ): ModelInvoker<Anthropic.Messages.Message> => {
     const invokerConfig: AnthropicModelInvokerConfig = {
       redis,
@@ -225,7 +257,7 @@ export function createAnthropicAdapter(
     : ((() => {
         throw new Error(
           "No default model provided to createAnthropicAdapter. " +
-            "Either pass `model` in the config or use `createModelInvoker(model)` instead.",
+            "Either pass `model` in the config or use `createModelInvoker(model)` instead."
         );
       }) as unknown as ModelInvoker<Anthropic.Messages.Message>);