zeitlich 0.2.21 → 0.2.22

package/src/lib/session/session-edge-cases.integration.test.ts

@@ -56,12 +56,11 @@ type TurnScript = {
  * Wraps every method on a ThreadOps object so it also has `.executeWithOptions()`,
  * matching Temporal's `ActivityInterfaceFor<ThreadOps>` shape.
  */
-function toActivityInterface(
-  raw: ThreadOps,
-): ActivityInterfaceFor<ThreadOps> {
+function toActivityInterface(raw: ThreadOps): ActivityInterfaceFor<ThreadOps> {
   const result = {} as Record<string, unknown>;
   for (const [key, fn] of Object.entries(raw)) {
-    const wrapped = (...args: unknown[]) => (fn as (...a: unknown[]) => unknown)(...args);
+    const wrapped = (...args: unknown[]) =>
+      (fn as (...a: unknown[]) => unknown)(...args);
     wrapped.executeWithOptions = (_opts: unknown, args: unknown[]) =>
       (fn as (...a: unknown[]) => unknown)(...args);
     result[key] = wrapped;
@@ -75,14 +74,14 @@ function createMockThreadOps() {
     initializeThread: async (threadId) => {
       log.push({ op: "initializeThread", args: [threadId] });
     },
-    appendHumanMessage: async (threadId, content) => {
-      log.push({ op: "appendHumanMessage", args: [threadId, content] });
+    appendHumanMessage: async (threadId, id, content) => {
+      log.push({ op: "appendHumanMessage", args: [threadId, id, content] });
     },
-    appendToolResult: async (config) => {
-      log.push({ op: "appendToolResult", args: [config] });
+    appendToolResult: async (id, config) => {
+      log.push({ op: "appendToolResult", args: [id, config] });
     },
-    appendSystemMessage: async (threadId, content) => {
-      log.push({ op: "appendSystemMessage", args: [threadId, content] });
+    appendSystemMessage: async (threadId, id, content) => {
+      log.push({ op: "appendSystemMessage", args: [threadId, id, content] });
     },
     forkThread: async (source, target) => {
       log.push({ op: "forkThread", args: [source, target] });
@@ -91,7 +90,9 @@ function createMockThreadOps() {
   return { ops, log };
 }
 
-function createScriptedRunAgent(turns: TurnScript[]): RunAgentActivity<unknown> {
+function createScriptedRunAgent(
+  turns: TurnScript[]
+): RunAgentActivity<unknown> {
   let call = 0;
   return async () => {
     const turn = turns[call++];
@@ -113,7 +114,7 @@ function createEchoTool() {
     schema: z.object({ text: z.string() }),
     handler: async (
       args: { text: string },
-      _ctx: RouterContext,
+      _ctx: RouterContext
     ): Promise<ToolHandlerResponse<{ echoed: string }>> => ({
       toolResponse: `Echo: ${args.text}`,
       data: { echoed: args.text },
@@ -216,8 +217,11 @@ describe("createSession edge cases", () => {
 
     const errorResults = log.filter((l) => {
       if (l.op !== "appendToolResult") return false;
-      const config = l.args[0] as ToolResultConfig;
-      return typeof config.content === "string" && config.content.includes("Invalid tool call");
+      const config = l.args[1] as ToolResultConfig;
+      return (
+        typeof config.content === "string" &&
+        config.content.includes("Invalid tool call")
+      );
     });
     expect(errorResults).toHaveLength(2);
   });
@@ -365,7 +369,7 @@ describe("createSession edge cases", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "unrecoverable tool",
+      "unrecoverable tool"
     );
     expect(endReason).toBe("failed");
   });
@@ -381,9 +385,7 @@ describe("createSession edge cases", () => {
       agentName: "TestAgent",
       threadId: "thread-1",
       metadata: { env: "test", version: 42 },
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
       hooks: {
@@ -422,6 +424,7 @@ describe("createSession edge cases", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({
@@ -438,7 +441,7 @@ describe("createSession edge cases", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "sandbox creation failed",
+      "sandbox creation failed"
     );
   });
 
@@ -462,6 +465,7 @@ describe("createSession edge cases", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({
@@ -480,7 +484,7 @@ describe("createSession edge cases", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "LLM crash",
+      "LLM crash"
     );
 
     expect(sandboxLog).toContain("create");
@@ -505,7 +509,7 @@ describe("createSession edge cases", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "No system prompt in state",
+      "No system prompt in state"
     );
   });
 
@@ -700,24 +704,27 @@ describe("createSession edge cases", () => {
 
     const toolResults = log.filter((l) => l.op === "appendToolResult");
     const echoResult = toolResults.find((l) => {
-      const config = l.args[0] as ToolResultConfig;
+      const config = l.args[1] as ToolResultConfig;
       return config.toolName === "Echo";
     });
     expect(echoResult).toBeDefined();
     if (echoResult) {
-      expect((echoResult.args[0] as ToolResultConfig).content).toBe("Echo: valid");
+      expect((echoResult.args[1] as ToolResultConfig).content).toBe(
+        "Echo: valid"
+      );
     }
 
     const unknownResult = toolResults.find((l) => {
-      const config = l.args[0] as ToolResultConfig;
+      const config = l.args[1] as ToolResultConfig;
       return config.toolName === "Unknown";
     });
     expect(unknownResult).toBeDefined();
     const unknownContent = unknownResult
-      ? (unknownResult.args[0] as ToolResultConfig).content
+      ? (unknownResult.args[1] as ToolResultConfig).content
       : undefined;
     expect(
-      typeof unknownContent === "string" && unknownContent.includes("Invalid tool call"),
+      typeof unknownContent === "string" &&
+        unknownContent.includes("Invalid tool call")
     ).toBe(true);
   });
 
@@ -729,9 +736,7 @@ describe("createSession edge cases", () => {
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => [
         { type: "text", text: "Hello" },
@@ -749,7 +754,7 @@ describe("createSession edge cases", () => {
     expect(humanOps).toHaveLength(1);
     const humanOp = humanOps[0];
     if (!humanOp) throw new Error("expected human op");
-    const content = humanOp.args[1];
+    const content = humanOp.args[2];
     expect(Array.isArray(content)).toBe(true);
     const firstContent = (content as { type: string }[])[0];
     if (!firstContent) throw new Error("expected content item");
@@ -834,7 +839,7 @@ describe("createSession edge cases", () => {
 
     const toolResults = log.filter((l) => {
       if (l.op !== "appendToolResult") return false;
-      const config = l.args[0] as ToolResultConfig;
+      const config = l.args[1] as ToolResultConfig;
       return config.toolName === "SelfAppend";
     });
     expect(toolResults).toHaveLength(0);
@@ -860,7 +865,10 @@ describe("createSession edge cases", () => {
       buildContextMessage: () => "go",
       hooks: {
         onPreToolUse: async ({ toolCall }) => {
-          if (toolCall.args && (toolCall.args as { text: string }).text === "skip-me") {
+          if (
+            toolCall.args &&
+            (toolCall.args as { text: string }).text === "skip-me"
+          ) {
             return { skip: true };
           }
           return {};
@@ -878,8 +886,10 @@ describe("createSession edge cases", () => {
     expect(toolResults).toHaveLength(1);
     const toolResult = toolResults[0];
     if (!toolResult) throw new Error("expected tool result");
-    const content = (toolResult.args[0] as ToolResultConfig).content;
-    expect(typeof content === "string" && content.includes("Skipped")).toBe(true);
+    const content = (toolResult.args[1] as ToolResultConfig).content;
+    expect(typeof content === "string" && content.includes("Skipped")).toBe(
+      true
+    );
   });
 
   // --- Sandbox snapshot is not called on normal flow ---
@@ -897,6 +907,7 @@ describe("createSession edge cases", () => {
       createSandbox: async () => ({ sandboxId: "sb-test" }),
       destroySandbox: async () => {},
       snapshotSandbox: snapshotSpy,
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({

package/src/lib/session/session.integration.test.ts

@@ -39,7 +39,8 @@ vi.mock("@temporalio/workflow", () => {
     defineUpdate: (name: string) => ({ __type: "update", name }),
     defineQuery: (name: string) => ({ __type: "query", name }),
     setHandler: (_def: unknown, _handler: unknown) => {},
-    uuid4: () => `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
+    uuid4: () =>
+      `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
     ApplicationFailure: MockApplicationFailure,
   };
 });
@@ -59,12 +60,11 @@ function at<T>(arr: T[], index: number): T {
   return val;
 }
 
-function toActivityInterface(
-  raw: ThreadOps,
-): ActivityInterfaceFor<ThreadOps> {
+function toActivityInterface(raw: ThreadOps): ActivityInterfaceFor<ThreadOps> {
   const result = {} as Record<string, unknown>;
   for (const [key, fn] of Object.entries(raw)) {
-    const wrapped = (...args: unknown[]) => (fn as (...a: unknown[]) => unknown)(...args);
+    const wrapped = (...args: unknown[]) =>
+      (fn as (...a: unknown[]) => unknown)(...args);
     wrapped.executeWithOptions = (_opts: unknown, args: unknown[]) =>
       (fn as (...a: unknown[]) => unknown)(...args);
     result[key] = wrapped;
@@ -79,14 +79,14 @@ function createMockThreadOps() {
     initializeThread: async (threadId) => {
       log.push({ op: "initializeThread", args: [threadId] });
     },
-    appendHumanMessage: async (threadId, content) => {
-      log.push({ op: "appendHumanMessage", args: [threadId, content] });
+    appendHumanMessage: async (threadId, id, content) => {
+      log.push({ op: "appendHumanMessage", args: [threadId, id, content] });
     },
-    appendToolResult: async (config) => {
-      log.push({ op: "appendToolResult", args: [config] });
+    appendToolResult: async (id, config) => {
+      log.push({ op: "appendToolResult", args: [id, config] });
     },
-    appendSystemMessage: async (threadId, content) => {
-      log.push({ op: "appendSystemMessage", args: [threadId, content] });
+    appendSystemMessage: async (threadId, id, content) => {
+      log.push({ op: "appendSystemMessage", args: [threadId, id, content] });
     },
     forkThread: async (source, target) => {
       log.push({ op: "forkThread", args: [source, target] });
@@ -102,7 +102,9 @@ type TurnScript = {
   usage?: TokenUsage;
 };
 
-function createScriptedRunAgent(turns: TurnScript[]): RunAgentActivity<unknown> {
+function createScriptedRunAgent(
+  turns: TurnScript[]
+): RunAgentActivity<unknown> {
   let call = 0;
   return async () => {
     const turn = turns[call++];
@@ -124,7 +126,7 @@ function createEchoTool() {
     schema: z.object({ text: z.string() }),
     handler: async (
       args: { text: string },
-      _ctx: RouterContext,
+      _ctx: RouterContext
     ): Promise<ToolHandlerResponse<{ echoed: string }>> => ({
       toolResponse: `Echo: ${args.text}`,
       data: { echoed: args.text },
@@ -149,9 +151,7 @@ describe("createSession integration", () => {
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "Hello!", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "Hello!", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "What is 2+2?",
     });
@@ -168,11 +168,11 @@ describe("createSession integration", () => {
 
     const systemOps = log.filter((l) => l.op === "appendSystemMessage");
     expect(systemOps).toHaveLength(1);
-    expect(at(systemOps, 0).args[1]).toBe("You are a test assistant.");
+    expect(at(systemOps, 0).args[2]).toBe("You are a test assistant.");
 
     const humanOps = log.filter((l) => l.op === "appendHumanMessage");
     expect(humanOps).toHaveLength(1);
-    expect(at(humanOps, 0).args[1]).toBe("What is 2+2?");
+    expect(at(humanOps, 0).args[2]).toBe("What is 2+2?");
   });
 
   // --- Tool execution ---
@@ -209,7 +209,7 @@ describe("createSession integration", () => {
 
     const toolResults = log.filter((l) => l.op === "appendToolResult");
     expect(toolResults).toHaveLength(1);
-    const resultConfig = at(toolResults, 0).args[0] as ToolResultConfig;
+    const resultConfig = at(toolResults, 0).args[1] as ToolResultConfig;
     expect(resultConfig.toolName).toBe("Echo");
     expect(resultConfig.content).toBe("Echo: hello");
   });
@@ -265,7 +265,7 @@ describe("createSession integration", () => {
       Array.from({ length: 10 }, (_, i) => ({
         message: `turn ${i + 1}`,
         toolCalls: [{ id: `tc-${i}`, name: "Echo", args: { text: `${i}` } }],
-      })),
+      }))
     );
 
     const session = await createSession({
@@ -298,9 +298,7 @@ describe("createSession integration", () => {
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "hi",
       hooks: {
@@ -343,7 +341,7 @@ describe("createSession integration", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "No system prompt in state",
+      "No system prompt in state"
     );
   });
 
@@ -354,9 +352,7 @@ describe("createSession integration", () => {
       agentName: "TestAgent",
       threadId: "thread-1",
       appendSystemPrompt: false,
-      runAgent: createScriptedRunAgent([
-        { message: "ok", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "ok", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "hi",
     });
@@ -447,11 +443,11 @@ describe("createSession integration", () => {
     // One error result for bad call + one success result for good call
     expect(toolResults.length).toBeGreaterThanOrEqual(2);
     const errorResult = toolResults.find((l) => {
-      const config = l.args[0] as ToolResultConfig;
+      const config = l.args[1] as ToolResultConfig;
       return config.toolCallId === "tc-bad";
     });
     expect(errorResult).toBeDefined();
-    const errorConfig = errorResult?.args[0] as ToolResultConfig | undefined;
+    const errorConfig = errorResult?.args[1] as ToolResultConfig | undefined;
     expect(errorConfig?.content).toContain("Invalid tool call");
   });
 
@@ -507,14 +503,13 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
       sandbox: sandboxOps,
@@ -548,14 +543,13 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
       sandbox: sandboxOps,
@@ -638,7 +632,7 @@ describe("createSession integration", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "LLM went down",
+      "LLM went down"
     );
 
     expect(endReason).toBe("failed");
@@ -690,9 +684,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
     });
@@ -761,9 +753,7 @@ describe("createSession integration", () => {
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: async () => {
         await new Promise((r) => setTimeout(r, 5));
@@ -778,7 +768,7 @@ describe("createSession integration", () => {
     await session.runSession({ stateManager });
 
     const humanOps = log.filter((l) => l.op === "appendHumanMessage");
-    expect(at(humanOps, 0).args[1]).toBe("async context");
+    expect(at(humanOps, 0).args[2]).toBe("async context");
   });
 
   // --- Sandbox stateUpdate merge ---
@@ -798,14 +788,13 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
     };
 
     const session = await createSession({
       agentName: "TestAgent",
       threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
       sandbox: sandboxOps,
@@ -845,7 +834,11 @@ describe("createSession integration", () => {
           toolCalls: [{ id: "tc-1", name: "UsageTool", args: {} }],
           usage: { inputTokens: 100, outputTokens: 50 },
         },
-        { message: "done", toolCalls: [], usage: { inputTokens: 80, outputTokens: 40 } },
+        {
+          message: "done",
+          toolCalls: [],
+          usage: { inputTokens: 80, outputTokens: 40 },
+        },
       ]),
       threadOps: ops,
       tools: { UsageTool: usageTool },
@@ -864,4 +857,3 @@ describe("createSession integration", () => {
     expect(result.usage.totalOutputTokens).toBe(90);
   });
 });
-

package/src/lib/session/session.ts

@@ -1,14 +1,11 @@
 import {
-  proxyActivities,
   condition,
   defineUpdate,
   setHandler,
   ApplicationFailure,
-  type ActivityInterfaceFor,
 } from "@temporalio/workflow";
 import type { SessionExitReason, MessageContent } from "../types";
-import type { ThreadOps, SessionConfig, ZeitlichSession } from "./types";
-import type { SandboxOps } from "../sandbox/types";
+import type { SessionConfig, ZeitlichSession } from "./types";
 import { type AgentStateManager, type JsonSerializable } from "../state/types";
 import { createToolRouter } from "../tool-router/router";
 import type { ParsedToolCallUnion, ToolMap } from "../tool-router/types";
@@ -27,16 +24,13 @@ import { uuid4 } from "@temporalio/workflow";
  * @example
  * ```typescript
  * import { createSession, createAgentStateManager, defineTool, bashTool } from 'zeitlich/workflow';
- *
- * const stateManager = createAgentStateManager({
- *   initialState: { systemPrompt: "You are a helpful assistant." },
- *   agentName: "my-agent",
- * });
+ * import { proxyGoogleGenAIThreadOps } from 'zeitlich/adapters/thread/google-genai/workflow';
  *
  * const session = await createSession({
  *   agentName: "my-agent",
  *   maxTurns: 20,
  *   threadId: runId,
+ *   threadOps: proxyGoogleGenAIThreadOps(), // auto-scoped to current workflow
  *   runAgent: runAgentActivity,
  *   buildContextMessage: () => [{ type: "text", text: prompt }],
  *   subagents: [researcherSubagent],
@@ -79,7 +73,7 @@ export const createSession = async <T extends ToolMap, M = unknown>({
     initializeThread,
     appendSystemMessage,
     forkThread,
-  } = threadOps ?? proxyDefaultThreadOps();
+  } = threadOps;
 
   const plugins: ToolMap[string][] = [];
   if (subagents) {
@@ -286,59 +280,3 @@ export const createSession = async <T extends ToolMap, M = unknown>({
   };
 };
 
-/**
- * Proxy the adapter's thread operations as Temporal activities.
- * Call this in workflow code to delegate thread operations to the
- * adapter-provided activities registered on the worker.
- *
- * @example
- * ```typescript
- * const session = await createSession({
- *   threadOps: proxyDefaultThreadOps(),
- *   // ...
- * });
- * ```
- */
-export function proxyDefaultThreadOps(
-  options?: Parameters<typeof proxyActivities>[0]
-): ActivityInterfaceFor<ThreadOps> {
-  return proxyActivities<ThreadOps>(
-    options ?? {
-      startToCloseTimeout: "10s",
-      retry: {
-        maximumAttempts: 6,
-        initialInterval: "5s",
-        maximumInterval: "15m",
-        backoffCoefficient: 4,
-      },
-    }
-  );
-}
-
-/**
- * Proxy sandbox lifecycle operations as Temporal activities.
- * Call this in workflow code when the agent needs a sandbox.
- *
- * @example
- * ```typescript
- * const session = await createSession({
- *   sandbox: proxySandboxOps(),
- *   // ...
- * });
- * ```
- */
-export function proxySandboxOps(
-  options?: Parameters<typeof proxyActivities>[0]
-): SandboxOps {
-  return proxyActivities<SandboxOps>(
-    options ?? {
-      startToCloseTimeout: "30s",
-      retry: {
-        maximumAttempts: 3,
-        initialInterval: "2s",
-        maximumInterval: "30s",
-        backoffCoefficient: 2,
-      },
-    }
-  );
-}

package/src/lib/session/types.ts

@@ -42,6 +42,37 @@ export interface ThreadOps {
   forkThread(sourceThreadId: string, targetThreadId: string): Promise<void>;
 }
 
+/**
+ * Composes an adapter prefix + workflow scope for activity naming.
+ *
+ * The adapter prefix stays first (camelCase); the workflow scope is
+ * capitalised and appended. When `TScope` is empty the adapter prefix
+ * is used as-is.
+ *
+ * @example
+ * ```typescript
+ * ScopedPrefix<"codingAgent", "googleGenAI"> // "googleGenAICodingAgent"
+ * ScopedPrefix<"", "googleGenAI">            // "googleGenAI"
+ * ```
+ */
+export type ScopedPrefix<
+  TScope extends string,
+  TAdapter extends string,
+> = TScope extends "" ? TAdapter : `${TAdapter}${Capitalize<TScope>}`;
+
+/**
+ * Maps generic {@link ThreadOps} method names to adapter-prefixed names.
+ *
+ * @example
+ * ```typescript
+ * type GoogleOps = PrefixedThreadOps<"googleGenAI">;
+ * // → { googleGenAIInitializeThread, googleGenAIAppendHumanMessage, … }
+ * ```
+ */
+export type PrefixedThreadOps<TPrefix extends string> = {
+  [K in keyof ThreadOps as `${TPrefix}${Capitalize<K & string>}`]: ThreadOps[K];
+};
+
 /**
  * Configuration for a Zeitlich agent session
  */
@@ -59,7 +90,7 @@ export interface SessionConfig<T extends ToolMap, M = unknown> {
   /** Workflow-specific runAgent activity (with tools pre-bound) */
   runAgent: RunAgentActivity<M>;
   /** Thread operations (initialize, append messages, parse tool calls) */
-  threadOps?: ActivityInterfaceFor<ThreadOps>;
+  threadOps: ActivityInterfaceFor<ThreadOps>;
   /** Tool router for processing tool calls (optional if agent has no tools) */
   tools?: T;
   /** Subagent configurations */

package/src/lib/subagent/define.ts

@@ -38,7 +38,7 @@ export function defineSubagent<
 >(
   definition: SubagentDefinition<TResult, TContext>,
   overrides?: {
-    context?: TContext;
+    context?: TContext | (() => TContext);
     hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
     enabled?: boolean | (() => boolean);
     taskQueue?: string;

package/src/lib/subagent/handler.ts

@@ -47,12 +47,19 @@ export function createSubagentHandler<
       ...(inheritSandbox && { sandboxId: parentSandboxId }),
     };
 
+    const resolvedContext =
+      config.context === undefined
+        ? undefined
+        : typeof config.context === "function"
+          ? config.context()
+          : config.context;
+
     const childOpts = {
       workflowId: childWorkflowId,
       args:
-        config.context === undefined
+        resolvedContext === undefined
           ? ([args.prompt, workflowInput] as const)
-          : ([args.prompt, workflowInput, config.context] as const),
+          : ([args.prompt, workflowInput, resolvedContext] as const),
       taskQueue: config.taskQueue ?? parentTaskQueue,
     };
 

package/src/lib/subagent/index.ts

@@ -1,5 +1,6 @@
 export type {
   SubagentConfig,
+  SubagentContext,
   SubagentDefinition,
   SubagentHooks,
   SubagentHandlerResponse,