zeitlich 0.2.35 → 0.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.35",
+  "version": "0.2.37",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

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,
@@ -252,6 +250,10 @@ export class BedrockSandboxProvider
   async fork(_sandboxId: string): 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/filesystem.ts

@@ -28,6 +28,28 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     return posix.resolve(this.workspaceBase, path);
   }
 
+  private async ensureParentDirs(absolutePaths: string[]): Promise<void> {
+    const prefix = this.workspaceBase === "/" ? "/" : `${this.workspaceBase}/`;
+    const dirs = new Set<string>();
+    for (const p of absolutePaths) {
+      let dir = posix.dirname(p);
+      while (dir.startsWith(prefix)) {
+        dirs.add(dir);
+        dir = posix.dirname(dir);
+      }
+    }
+    const sorted = [...dirs].sort(
+      (a, b) => a.split("/").length - b.split("/").length
+    );
+    for (const dir of sorted) {
+      try {
+        await this.sandbox.fs.createFolder(dir, "755");
+      } catch {
+        // Folder already exists — Daytona's createFolder throws in that case.
+      }
+    }
+  }
+
   async readFile(path: string): Promise<string> {
     const norm = this.normalisePath(path);
     const buf = await this.sandbox.fs.downloadFile(norm);
@@ -46,18 +68,19 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
       typeof content === "string"
         ? Buffer.from(content, "utf-8")
         : Buffer.from(content);
+    await this.ensureParentDirs([norm]);
     await this.sandbox.fs.uploadFile(buf, norm);
   }
 
   async writeFiles(
     files: { path: string; content: string | Uint8Array }[]
   ): Promise<void> {
-    await this.sandbox.fs.uploadFiles(
-      files.map((f) => ({
-        source: Buffer.from(f.content),
-        destination: this.normalisePath(f.path),
-      }))
-    );
+    const uploads = files.map((f) => ({
+      source: Buffer.from(f.content),
+      destination: this.normalisePath(f.path),
+    }));
+    await this.ensureParentDirs(uploads.map((u) => u.destination));
+    await this.sandbox.fs.uploadFiles(uploads);
   }
 
   async appendFile(path: string, content: string | Uint8Array): Promise<void> {

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

@@ -164,6 +164,12 @@ export class DaytonaSandboxProvider implements SandboxProvider<
       "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,
@@ -87,10 +88,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 +114,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,12 +142,39 @@ export class E2bSandboxProvider
     await E2bSdkSandbox.connect(sandboxId);
   }
 
-  async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
-    throw new SandboxNotSupportedError("snapshot");
+  async snapshot(sandboxId: string): Promise<SandboxSnapshot> {
+    const { snapshotId } = await E2bSdkSandbox.createSnapshot(sandboxId);
+    return {
+      sandboxId,
+      providerId: this.id,
+      data: { snapshotId },
+      createdAt: new Date().toISOString(),
+    };
+  }
+
+  async restore(snapshot: SandboxSnapshot): Promise<Sandbox> {
+    const data = snapshot.data as { snapshotId?: string } | null;
+    if (!data?.snapshotId) {
+      throw new SandboxNotSupportedError(
+        "restore: snapshot is missing snapshotId"
+      );
+    }
+    const sdkSandbox = await E2bSdkSandbox.create(data.snapshotId);
+    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> {
@@ -157,6 +186,28 @@ export class E2bSandboxProvider
       this.defaultWorkspaceBase
     );
   }
+
+  private buildSdkCreateOpts(options?: E2bSandboxCreateOptions) {
+    return {
+      envs: options?.env,
+      timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
+      metadata: options?.metadata,
+      allowInternetAccess: options?.allowInternetAccess,
+      network: options?.network
+        ? {
+            allowOut: options.network.allowOut,
+            denyOut: options.network.denyOut,
+            allowPublicTraffic: options.network.allowPublicTraffic,
+          }
+        : undefined,
+      lifecycle: options?.lifecycle
+        ? {
+            onTimeout: options.lifecycle.onTimeout,
+            autoResume: options.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/inmemory/index.ts

@@ -244,4 +244,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,
@@ -191,21 +215,20 @@ export function createAnthropicAdapter(
   };
 
   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 +248,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>);
 

package/src/adapters/thread/anthropic/model-invoker.ts

@@ -2,7 +2,10 @@ import type Redis from "ioredis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { SerializableToolDefinition } from "../../../lib/types";
 import type { AgentResponse, ModelInvokerConfig } from "../../../lib/model";
-import { createAnthropicThreadManager, type AnthropicThreadManagerHooks } from "./thread-manager";
+import {
+  createAnthropicThreadManager,
+  type AnthropicThreadManagerHooks,
+} from "./thread-manager";
 import { getActivityContext } from "../../../lib/activity";
 
 export interface AnthropicModelInvokerConfig {
@@ -15,7 +18,7 @@ export interface AnthropicModelInvokerConfig {
 }
 
 function toAnthropicTools(
-  tools: SerializableToolDefinition[],
+  tools: SerializableToolDefinition[]
 ): Anthropic.Messages.Tool[] {
   return tools.map((t) => ({
     name: t.name,
@@ -56,12 +59,17 @@ export function createAnthropicModelInvoker({
   hooks,
 }: AnthropicModelInvokerConfig) {
   return async function invokeAnthropicModel(
-    config: ModelInvokerConfig,
+    config: ModelInvokerConfig
   ): Promise<AgentResponse<Anthropic.Messages.Message>> {
     const { threadId, threadKey, state } = config;
     const { heartbeat, signal } = getActivityContext();
 
-    const thread = createAnthropicThreadManager({ redis, threadId, key: threadKey, hooks });
+    const thread = createAnthropicThreadManager({
+      redis,
+      threadId,
+      key: threadKey,
+      hooks,
+    });
     const { messages, system } = await thread.prepareForInvocation();
 
     const anthropicTools = toAnthropicTools(state.tools);
@@ -85,7 +93,7 @@ export function createAnthropicModelInvoker({
 
     const toolCalls = response.content.filter(
       (block): block is Anthropic.Messages.ToolUseBlock =>
-        block.type === "tool_use",
+        block.type === "tool_use"
     );
 
     return {
@@ -98,7 +106,8 @@ export function createAnthropicModelInvoker({
       usage: {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens,
-        cachedWriteTokens: response.usage.cache_creation_input_tokens ?? undefined,
+        cachedWriteTokens:
+          response.usage.cache_creation_input_tokens ?? undefined,
         cachedReadTokens: response.usage.cache_read_input_tokens ?? undefined,
       },
     };

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

@@ -27,7 +27,11 @@ const ADAPTER_PREFIX = "anthropic";
 
 export function proxyAnthropicThreadOps(
   scope?: string,
-  options?: Parameters<typeof createThreadOpsProxy>[2],
+  options?: Parameters<typeof createThreadOpsProxy>[2]
 ): ActivityInterfaceFor<ThreadOps<AnthropicContent>> {
-  return createThreadOpsProxy(ADAPTER_PREFIX, scope, options) as ActivityInterfaceFor<ThreadOps<AnthropicContent>>;
+  return createThreadOpsProxy(
+    ADAPTER_PREFIX,
+    scope,
+    options
+  ) as ActivityInterfaceFor<ThreadOps<AnthropicContent>>;
 }