zeitlich 0.2.21 → 0.2.23

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

@@ -29,7 +29,7 @@ function parentDir(p: string): string {
  */
 function inferDirectories(
   entries: { path: string }[],
-  workspaceBase: string,
+  workspaceBase: string
 ): Set<string> {
   const dirs = new Set<string>();
   dirs.add("/");
@@ -54,8 +54,7 @@ function inferDirectories(
 export class VirtualSandboxFileSystem<
   TCtx = unknown,
   TMeta = FileEntryMetadata,
-> implements SandboxFileSystem
-{
+> implements SandboxFileSystem {
   readonly workspaceBase: string;
   private entries: Map<string, FileEntry<TMeta>>;
   private directories: Set<string>;
@@ -65,11 +64,11 @@ export class VirtualSandboxFileSystem<
     tree: FileEntry<TMeta>[],
     private resolver: FileResolver<TCtx, TMeta>,
     private ctx: TCtx,
-    workspaceBase = "/",
+    workspaceBase = "/"
   ) {
     this.workspaceBase = normalisePath(workspaceBase);
     this.entries = new Map(
-      tree.map((e) => [normalisePath(e.path, this.workspaceBase), e]),
+      tree.map((e) => [normalisePath(e.path, this.workspaceBase), e])
     );
     this.directories = inferDirectories(tree, this.workspaceBase);
   }
@@ -91,13 +90,13 @@ export class VirtualSandboxFileSystem<
   async readFile(path: string): Promise<string> {
     const entry = this.entries.get(normalisePath(path, this.workspaceBase));
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
-    return this.resolver.readFile(entry.id, this.ctx);
+    return this.resolver.readFile(entry.id, this.ctx, entry.metadata);
   }
 
   async readFileBuffer(path: string): Promise<Uint8Array> {
     const entry = this.entries.get(normalisePath(path, this.workspaceBase));
     if (!entry) throw new Error(`ENOENT: no such file: ${path}`);
-    return this.resolver.readFileBuffer(entry.id, this.ctx);
+    return this.resolver.readFileBuffer(entry.id, this.ctx, entry.metadata);
   }
 
   // --------------------------------------------------------------------------
@@ -180,7 +179,12 @@ export class VirtualSandboxFileSystem<
     const existing = this.entries.get(norm);
 
     if (existing) {
-      await this.resolver.writeFile(existing.id, content, this.ctx);
+      await this.resolver.writeFile(
+        existing.id,
+        content,
+        this.ctx,
+        existing.metadata
+      );
       const size =
         typeof content === "string"
           ? new TextEncoder().encode(content).byteLength
@@ -209,12 +213,21 @@ export class VirtualSandboxFileSystem<
       return this.writeFile(path, content);
     }
 
-    const current = await this.resolver.readFile(existing.id, this.ctx);
+    const current = await this.resolver.readFile(
+      existing.id,
+      this.ctx,
+      existing.metadata
+    );
     const appended =
       typeof content === "string"
         ? current + content
         : current + new TextDecoder().decode(content);
-    await this.resolver.writeFile(existing.id, appended, this.ctx);
+    await this.resolver.writeFile(
+      existing.id,
+      appended,
+      this.ctx,
+      existing.metadata
+    );
 
     const size = new TextEncoder().encode(appended).byteLength;
     const updated: FileEntry<TMeta> = {
@@ -226,7 +239,10 @@ export class VirtualSandboxFileSystem<
     this.mutations.push({ type: "update", path: norm, entry: updated });
   }
 
-  async mkdir(_path: string, _options?: { recursive?: boolean }): Promise<void> {
+  async mkdir(
+    _path: string,
+    _options?: { recursive?: boolean }
+  ): Promise<void> {
     const norm = normalisePath(_path, this.workspaceBase);
     if (this.directories.has(norm)) return;
 
@@ -244,13 +260,13 @@ export class VirtualSandboxFileSystem<
 
   async rm(
     path: string,
-    options?: { recursive?: boolean; force?: boolean },
+    options?: { recursive?: boolean; force?: boolean }
   ): Promise<void> {
     const norm = normalisePath(path, this.workspaceBase);
     const entry = this.entries.get(norm);
 
     if (entry) {
-      await this.resolver.deleteFile(entry.id, this.ctx);
+      await this.resolver.deleteFile(entry.id, this.ctx, entry.metadata);
       this.entries.delete(norm);
       this.mutations.push({ type: "remove", path: norm });
       return;
@@ -263,7 +279,7 @@ export class VirtualSandboxFileSystem<
       const prefix = norm === "/" ? "/" : norm + "/";
       for (const [p, e] of this.entries) {
         if (p.startsWith(prefix)) {
-          await this.resolver.deleteFile(e.id, this.ctx);
+          await this.resolver.deleteFile(e.id, this.ctx, e.metadata);
           this.entries.delete(p);
           this.mutations.push({ type: "remove", path: p });
         }
@@ -283,14 +299,18 @@ export class VirtualSandboxFileSystem<
   async cp(
     src: string,
     dest: string,
-    _options?: { recursive?: boolean },
+    _options?: { recursive?: boolean }
   ): Promise<void> {
     const normSrc = normalisePath(src, this.workspaceBase);
     const normDest = normalisePath(dest, this.workspaceBase);
 
     const entry = this.entries.get(normSrc);
     if (entry) {
-      const content = await this.resolver.readFile(entry.id, this.ctx);
+      const content = await this.resolver.readFile(
+        entry.id,
+        this.ctx,
+        entry.metadata
+      );
       await this.writeFile(normDest, content);
       return;
     }
@@ -306,7 +326,11 @@ export class VirtualSandboxFileSystem<
     for (const [p, e] of this.entries) {
       if (p.startsWith(prefix)) {
         const relative = p.slice(normSrc.length);
-        const content = await this.resolver.readFile(e.id, this.ctx);
+        const content = await this.resolver.readFile(
+          e.id,
+          this.ctx,
+          e.metadata
+        );
         await this.writeFile(normDest + relative, content);
       }
     }

package/src/adapters/sandbox/virtual/provider.ts

@@ -26,7 +26,7 @@ import type {
  * const manager = new SandboxManager(provider);
  *
  * export const activities = {
- *   ...manager.createActivities(),
+ *   ...manager.createActivities("CodingAgent"),
  *   readFile: withVirtualSandbox(client, provider, readHandler),
  * };
  * ```
@@ -90,6 +90,14 @@ export class VirtualSandboxProvider<
     // No-op — no internal state to clean up
   }
 
+  async pause(): Promise<void> {
+    // No-op — virtual sandbox state lives in workflow AgentState
+  }
+
+  async fork(_sandboxId: string): Promise<never> {
+    throw new Error("Not implemented");
+  }
+
   async snapshot(): Promise<never> {
     throw new SandboxNotSupportedError(
       "snapshot (virtual sandbox state lives in workflow AgentState)"

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

@@ -0,0 +1,53 @@
+/**
+ * Workflow-safe proxy for virtual sandbox operations.
+ *
+ * Import this from `zeitlich/adapters/sandbox/virtual/workflow`
+ * in your Temporal workflow files.
+ *
+ * By default the scope is derived from `workflowInfo().workflowType`,
+ * so activities are automatically namespaced per workflow.
+ *
+ * @example
+ * ```typescript
+ * import { proxyVirtualSandboxOps } from 'zeitlich/adapters/sandbox/virtual/workflow';
+ *
+ * const sandbox = proxyVirtualSandboxOps();
+ * ```
+ */
+import { proxyActivities, workflowInfo } from "@temporalio/workflow";
+import type { SandboxOps } from "../../../lib/sandbox/types";
+import type { VirtualSandboxCreateOptions } from "./types";
+
+const ADAPTER_PREFIX = "virtual";
+
+export function proxyVirtualSandboxOps(
+  scope?: string,
+  options?: Parameters<typeof proxyActivities>[0]
+): SandboxOps<VirtualSandboxCreateOptions<unknown>> {
+  const resolvedScope = scope ?? workflowInfo().workflowType;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const acts = proxyActivities<Record<string, (...args: any[]) => any>>(
+    options ?? {
+      startToCloseTimeout: "30s",
+      retry: {
+        maximumAttempts: 3,
+        initialInterval: "2s",
+        maximumInterval: "30s",
+        backoffCoefficient: 2,
+      },
+    }
+  );
+
+  const prefix = `${ADAPTER_PREFIX}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
+  const p = (key: string): string =>
+    `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+
+  return {
+    createSandbox: acts[p("createSandbox")],
+    destroySandbox: acts[p("destroySandbox")],
+    pauseSandbox: acts[p("pauseSandbox")],
+    snapshotSandbox: acts[p("snapshotSandbox")],
+    forkSandbox: acts[p("forkSandbox")],
+  } as SandboxOps<VirtualSandboxCreateOptions<unknown>>;
+}

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

@@ -56,15 +56,20 @@ export type TreeMutation<TMeta = FileEntryMetadata> =
  */
 export interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
   resolveEntries(ctx: TCtx): Promise<FileEntry<TMeta>[]>;
-  readFile(id: string, ctx: TCtx): Promise<string>;
-  readFileBuffer(id: string, ctx: TCtx): Promise<Uint8Array>;
-  writeFile(id: string, content: string | Uint8Array, ctx: TCtx): Promise<void>;
+  readFile(id: string, ctx: TCtx, metadata: TMeta): Promise<string>;
+  readFileBuffer(id: string, ctx: TCtx, metadata: TMeta): Promise<Uint8Array>;
+  writeFile(
+    id: string,
+    content: string | Uint8Array,
+    ctx: TCtx,
+    metadata: TMeta
+  ): Promise<void>;
   createFile(
     path: string,
     content: string | Uint8Array,
     ctx: TCtx
   ): Promise<FileEntry<TMeta>>;
-  deleteFile(id: string, ctx: TCtx): Promise<void>;
+  deleteFile(id: string, ctx: TCtx, metadata: TMeta): Promise<void>;
 }
 
 // ============================================================================

package/src/adapters/thread/google-genai/activities.ts

@@ -2,11 +2,20 @@ import type Redis from "ioredis";
 import type { GoogleGenAI, Content } from "@google/genai";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { MessageContent } from "../../../lib/types";
-import type { ThreadOps } from "../../../lib/session/types";
+import type {
+  ThreadOps,
+  PrefixedThreadOps,
+  ScopedPrefix,
+} from "../../../lib/session/types";
 import type { ModelInvoker } from "../../../lib/model";
 import { createGoogleGenAIThreadManager } from "./thread-manager";
 import { createGoogleGenAIModelInvoker } from "./model-invoker";
 
+const ADAPTER_PREFIX = "googleGenAI" as const;
+
+export type GoogleGenAIThreadOps<TScope extends string = ""> =
+  PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_PREFIX>>;
+
 export interface GoogleGenAIAdapterConfig {
   redis: Redis;
   client: GoogleGenAI;
@@ -15,21 +24,37 @@ export interface GoogleGenAIAdapterConfig {
 }
 
 export interface GoogleGenAIAdapter {
-  /** Thread operations (register these as Temporal activities on the worker) */
-  threadOps: ThreadOps;
   /** Model invoker using the default model (only available when `model` was provided) */
   invoker: ModelInvoker<Content>;
   /** Create an invoker for a specific model name (for multi-model setups) */
   createModelInvoker(model: string): ModelInvoker<Content>;
+  /**
+   * Create prefixed thread activities for registration on the worker.
+   *
+   * @param scope - Workflow name appended to the adapter prefix.
+   *   Use different scopes for the main agent vs subagents to avoid collisions.
+   *
+   * @example
+   * ```typescript
+   * adapter.createActivities("codingAgent")
+   * // → { googleGenAICodingAgentInitializeThread, googleGenAICodingAgentAppendHumanMessage, … }
+   *
+   * adapter.createActivities("researchAgent")
+   * // → { googleGenAIResearchAgentInitializeThread, … }
+   * ```
+   */
+  createActivities<S extends string = "">(
+    scope?: S
+  ): GoogleGenAIThreadOps<S>;
 }
 
 /**
  * Creates a Google GenAI adapter that bundles thread operations and model
  * invocation using the `@google/genai` SDK.
  *
- * The returned `threadOps` should be registered as Temporal activities on
- * the worker. The `invoker` (or invokers created via `createModelInvoker`)
- * should be wrapped with `createRunAgentActivity` for per-agent activities.
+ * Use `createActivities(scope)` to register scoped thread operations as
+ * Temporal activities on the worker. The `invoker` (or invokers created via
+ * `createModelInvoker`) should be wrapped with `createRunAgentActivity`.
  *
  * @example
  * ```typescript
@@ -42,27 +67,23 @@ export interface GoogleGenAIAdapter {
  *
  * export function createActivities(temporalClient: WorkflowClient) {
  *   return {
- *     ...adapter.threadOps,
- *     runAgent: createRunAgentActivity(temporalClient, adapter.invoker),
+ *     ...adapter.createActivities("codingAgent"),
+ *     runCodingAgent: createRunAgentActivity(temporalClient, adapter.invoker),
  *   };
  * }
  * ```
  *
- * @example Multi-model setup
+ * @example Multi-agent worker (main + subagent share the adapter)
  * ```typescript
- * const adapter = createGoogleGenAIAdapter({ redis, client });
- *
  * export function createActivities(temporalClient: WorkflowClient) {
  *   return {
- *     ...adapter.threadOps,
+ *     ...adapter.createActivities("codingAgent"),
+ *     ...adapter.createActivities("researchAgent"),
+ *     runCodingAgent: createRunAgentActivity(temporalClient, adapter.invoker),
  *     runResearchAgent: createRunAgentActivity(
  *       temporalClient,
  *       adapter.createModelInvoker('gemini-2.5-pro'),
  *     ),
- *     runFastAgent: createRunAgentActivity(
- *       temporalClient,
- *       adapter.createModelInvoker('gemini-2.5-flash'),
- *     ),
  *   };
  * }
  * ```
@@ -114,6 +135,19 @@ export function createGoogleGenAIAdapter(
     },
   };
 
+  function createActivities<S extends string = "">(
+    scope?: S
+  ): GoogleGenAIThreadOps<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);
+    return Object.fromEntries(
+      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
+    ) as GoogleGenAIThreadOps<S>;
+  }
+
   const makeInvoker = (model: string): ModelInvoker<Content> =>
     createGoogleGenAIModelInvoker({ redis, client, model });
 
@@ -127,7 +161,7 @@ export function createGoogleGenAIAdapter(
       }) as unknown as ModelInvoker<Content>);
 
   return {
-    threadOps,
+    createActivities,
     invoker,
     createModelInvoker: makeInvoker,
   };

package/src/adapters/thread/google-genai/index.ts

@@ -22,6 +22,7 @@ export {
   createGoogleGenAIAdapter,
   type GoogleGenAIAdapter,
   type GoogleGenAIAdapterConfig,
+  type GoogleGenAIThreadOps,
 } from "./activities";
 
 // Thread manager

package/src/adapters/thread/google-genai/proxy.ts

@@ -0,0 +1,61 @@
+/**
+ * Workflow-safe proxy for Google GenAI thread operations.
+ *
+ * Import this from `zeitlich/adapters/thread/google-genai/workflow`
+ * in your Temporal workflow files.
+ *
+ * By default the scope is derived from `workflowInfo().workflowType`,
+ * so activities are automatically namespaced per workflow.
+ *
+ * @example
+ * ```typescript
+ * import { proxyGoogleGenAIThreadOps } from 'zeitlich/adapters/thread/google-genai/workflow';
+ *
+ * // Auto-scoped to the current workflow name
+ * const threadOps = proxyGoogleGenAIThreadOps();
+ *
+ * // Explicit scope override
+ * const threadOps = proxyGoogleGenAIThreadOps("customScope");
+ * ```
+ */
+import {
+  proxyActivities,
+  workflowInfo,
+  type ActivityInterfaceFor,
+} from "@temporalio/workflow";
+import type { ThreadOps } from "../../../lib/session/types";
+
+const ADAPTER_PREFIX = "googleGenAI";
+
+export function proxyGoogleGenAIThreadOps(
+  scope?: string,
+  options?: Parameters<typeof proxyActivities>[0]
+): ActivityInterfaceFor<ThreadOps> {
+  const resolvedScope = scope ?? workflowInfo().workflowType;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const acts = proxyActivities<Record<string, (...args: any[]) => any>>(
+    options ?? {
+      startToCloseTimeout: "10s",
+      retry: {
+        maximumAttempts: 6,
+        initialInterval: "5s",
+        maximumInterval: "15m",
+        backoffCoefficient: 4,
+      },
+    }
+  );
+
+  const prefix =
+    `${ADAPTER_PREFIX}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
+  const p = (key: string): string =>
+    `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+
+  return {
+    initializeThread: acts[p("initializeThread")],
+    appendHumanMessage: acts[p("appendHumanMessage")],
+    appendToolResult: acts[p("appendToolResult")],
+    appendSystemMessage: acts[p("appendSystemMessage")],
+    forkThread: acts[p("forkThread")],
+  } as ActivityInterfaceFor<ThreadOps>;
+}

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

@@ -1,13 +1,22 @@
 import type Redis from "ioredis";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { MessageContent } from "@langchain/core/messages";
-import type { ThreadOps } from "../../../lib/session/types";
+import type {
+  ThreadOps,
+  PrefixedThreadOps,
+  ScopedPrefix,
+} from "../../../lib/session/types";
 import type { ModelInvoker } from "../../../lib/model";
 import type { StoredMessage } from "@langchain/core/messages";
 import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { createLangChainThreadManager } from "./thread-manager";
 import { createLangChainModelInvoker } from "./model-invoker";
 
+const ADAPTER_PREFIX = "langChain" as const;
+
+export type LangChainThreadOps<TScope extends string = ""> =
+  PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_PREFIX>>;
+
 export interface LangChainAdapterConfig {
   redis: Redis;
   /** Optional default model — if omitted, use `createModelInvoker()` to create invokers later */
@@ -16,22 +25,34 @@ export interface LangChainAdapterConfig {
 }
 
 export interface LangChainAdapter {
-  /** Thread operations (register these as Temporal activities on the worker) */
-  threadOps: ThreadOps;
   /** Model invoker using the default model (only available when `model` was provided) */
   invoker: ModelInvoker<StoredMessage>;
   /** Create an invoker for a specific model (for multi-model setups) */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   createModelInvoker(model: BaseChatModel<any>): ModelInvoker<StoredMessage>;
+  /**
+   * Create prefixed thread activities for registration on the worker.
+   *
+   * @param scope - Workflow name appended to the adapter prefix.
+   *
+   * @example
+   * ```typescript
+   * adapter.createActivities("codingAgent")
+   * // → { langChainCodingAgentInitializeThread, langChainCodingAgentAppendHumanMessage, … }
+   * ```
+   */
+  createActivities<S extends string = "">(
+    scope?: S
+  ): LangChainThreadOps<S>;
 }
 
 /**
  * Creates a LangChain adapter that bundles thread operations and model
  * invocation using a consistent message format (StoredMessage).
  *
- * The returned `threadOps` should be registered as Temporal activities on
- * the worker. The `invoker` (or invokers created via `createModelInvoker`)
- * should be wrapped with `createRunAgentActivity` for per-agent activities.
+ * Use `createActivities(scope)` to register scoped thread operations as
+ * Temporal activities on the worker. The `invoker` (or invokers created via
+ * `createModelInvoker`) should be wrapped with `createRunAgentActivity`.
  *
  * @example
  * ```typescript
@@ -42,21 +63,20 @@ export interface LangChainAdapter {
  *
  * export function createActivities(client: WorkflowClient) {
  *   return {
- *     ...adapter.threadOps,
- *     runAgent: createRunAgentActivity(client, adapter.invoker),
+ *     ...adapter.createActivities("codingAgent"),
+ *     runCodingAgent: createRunAgentActivity(client, adapter.invoker),
  *   };
  * }
  * ```
  *
- * @example Multi-model setup
+ * @example Multi-agent worker
  * ```typescript
- * const adapter = createLangChainAdapter({ redis });
- *
  * export function createActivities(client: WorkflowClient) {
  *   return {
- *     ...adapter.threadOps,
+ *     ...adapter.createActivities("codingAgent"),
+ *     ...adapter.createActivities("researchAgent"),
+ *     runCodingAgent: createRunAgentActivity(client, adapter.invoker),
  *     runResearchAgent: createRunAgentActivity(client, adapter.createModelInvoker(claude)),
- *     runWriterAgent: createRunAgentActivity(client, adapter.createModelInvoker(gpt4)),
  *   };
  * }
  * ```
@@ -108,6 +128,19 @@ export function createLangChainAdapter(
     },
   };
 
+  function createActivities<S extends string = "">(
+    scope?: S
+  ): LangChainThreadOps<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);
+    return Object.fromEntries(
+      Object.entries(threadOps).map(([k, v]) => [`${prefix}${cap(k)}`, v])
+    ) as LangChainThreadOps<S>;
+  }
+
   const makeInvoker = (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     model: BaseChatModel<any>
@@ -124,7 +157,7 @@ export function createLangChainAdapter(
       };
 
   return {
-    threadOps,
+    createActivities,
     invoker,
     createModelInvoker: makeInvoker,
   };

package/src/adapters/thread/langchain/index.ts

@@ -20,6 +20,7 @@ export {
   createLangChainAdapter,
   type LangChainAdapter,
   type LangChainAdapterConfig,
+  type LangChainThreadOps,
 } from "./activities";
 
 // Thread manager

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

@@ -0,0 +1,61 @@
+/**
+ * Workflow-safe proxy for LangChain thread operations.
+ *
+ * Import this from `zeitlich/adapters/thread/langchain/workflow`
+ * in your Temporal workflow files.
+ *
+ * By default the scope is derived from `workflowInfo().workflowType`,
+ * so activities are automatically namespaced per workflow.
+ *
+ * @example
+ * ```typescript
+ * import { proxyLangChainThreadOps } from 'zeitlich/adapters/thread/langchain/workflow';
+ *
+ * // Auto-scoped to the current workflow name
+ * const threadOps = proxyLangChainThreadOps();
+ *
+ * // Explicit scope override
+ * const threadOps = proxyLangChainThreadOps("customScope");
+ * ```
+ */
+import {
+  proxyActivities,
+  workflowInfo,
+  type ActivityInterfaceFor,
+} from "@temporalio/workflow";
+import type { ThreadOps } from "../../../lib/session/types";
+
+const ADAPTER_PREFIX = "langChain";
+
+export function proxyLangChainThreadOps(
+  scope?: string,
+  options?: Parameters<typeof proxyActivities>[0]
+): ActivityInterfaceFor<ThreadOps> {
+  const resolvedScope = scope ?? workflowInfo().workflowType;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const acts = proxyActivities<Record<string, (...args: any[]) => any>>(
+    options ?? {
+      startToCloseTimeout: "10s",
+      retry: {
+        maximumAttempts: 6,
+        initialInterval: "5s",
+        maximumInterval: "15m",
+        backoffCoefficient: 4,
+      },
+    }
+  );
+
+  const prefix =
+    `${ADAPTER_PREFIX}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
+  const p = (key: string): string =>
+    `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+
+  return {
+    initializeThread: acts[p("initializeThread")],
+    appendHumanMessage: acts[p("appendHumanMessage")],
+    appendToolResult: acts[p("appendToolResult")],
+    appendSystemMessage: acts[p("appendSystemMessage")],
+    forkThread: acts[p("forkThread")],
+  } as ActivityInterfaceFor<ThreadOps>;
+}