zeitlich 0.2.21 → 0.2.22

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

@@ -323,6 +323,68 @@ describe("createSubagentHandler", () => {
     expect(workflowInput.sandboxId).toBe("parent-sb");
   });
 
+  it("resolves context function at invocation time", async () => {
+    const { executeChild } = await import("@temporalio/workflow");
+    const execMock = executeChild as ReturnType<typeof vi.fn>;
+    execMock.mockResolvedValueOnce({
+      toolResponse: "ok",
+      data: null,
+      threadId: "child-t",
+    });
+
+    let counter = 0;
+    const dynamicSubagent: SubagentConfig = {
+      agentName: "dynamic-ctx",
+      description: "Dynamic context",
+      workflow: "workflow",
+      context: () => {
+        counter++;
+        return { invocation: counter };
+      },
+    };
+
+    const handler = createSubagentHandler([dynamicSubagent]);
+
+    await handler(
+      { subagent: "dynamic-ctx", description: "test", prompt: "test" },
+      { threadId: "t", toolCallId: "tc", toolName: "Subagent" }
+    );
+
+    const lastCall = execMock.mock.calls[execMock.mock.calls.length - 1];
+    if (!lastCall) throw new Error("expected exec call");
+    const context = lastCall[1].args[2] as Record<string, unknown>;
+    expect(context).toEqual({ invocation: 1 });
+  });
+
+  it("passes static context unchanged", async () => {
+    const { executeChild } = await import("@temporalio/workflow");
+    const execMock = executeChild as ReturnType<typeof vi.fn>;
+    execMock.mockResolvedValueOnce({
+      toolResponse: "ok",
+      data: null,
+      threadId: "child-t",
+    });
+
+    const staticSubagent: SubagentConfig = {
+      agentName: "static-ctx",
+      description: "Static context",
+      workflow: "workflow",
+      context: { key: "value" },
+    };
+
+    const handler = createSubagentHandler([staticSubagent]);
+
+    await handler(
+      { subagent: "static-ctx", description: "test", prompt: "test" },
+      { threadId: "t", toolCallId: "tc", toolName: "Subagent" }
+    );
+
+    const lastCall = execMock.mock.calls[execMock.mock.calls.length - 1];
+    if (!lastCall) throw new Error("expected exec call");
+    const context = lastCall[1].args[2] as Record<string, unknown>;
+    expect(context).toEqual({ key: "value" });
+  });
+
   it("does not pass sandboxId when sandbox is own", async () => {
     const { executeChild } = await import("@temporalio/workflow");
     const execMock = executeChild as ReturnType<typeof vi.fn>;

package/src/lib/subagent/types.ts

@@ -43,6 +43,11 @@ export type SubagentDefinition<
   readonly resultSchema?: TResult;
 };
 
+/** Context value or factory — resolved at invocation time when a function is provided */
+export type SubagentContext =
+  | Record<string, unknown>
+  | (() => Record<string, unknown>);
+
 /** Infer the z.infer'd result type from a SubagentConfig, or null if no schema */
 export type InferSubagentResult<T extends SubagentConfig> =
   T extends SubagentConfig<infer S> ? z.infer<S> : null;
@@ -65,8 +70,8 @@ export interface SubagentConfig<TResult extends z.ZodType = z.ZodType> {
   taskQueue?: string;
   /** Optional Zod schema to validate the child workflow's result. If omitted, result is passed through as-is. */
   resultSchema?: TResult;
-  /** Optional static context passed to the subagent on every invocation */
-  context?: Record<string, unknown>;
+  /** Optional context passed to the subagent — a static object or a function evaluated at invocation time */
+  context?: SubagentContext;
   /** Allow the parent agent to pass a threadId for this subagent to continue (default: false) */
   allowThreadContinuation?: boolean;
   /** Per-subagent lifecycle hooks */

package/src/lib/tool-router/router-edge-cases.integration.test.ts

@@ -22,7 +22,10 @@ vi.mock("@temporalio/workflow", () => {
       return err;
     }
   }
-  return { ApplicationFailure: MockApplicationFailure };
+  return {
+    ApplicationFailure: MockApplicationFailure,
+    uuid4: () => "00000000-0000-0000-0000-000000000000",
+  };
 });
 
 import { createToolRouter, defineTool, hasNoOtherToolCalls } from "./router";

package/src/lib/tool-router/router.integration.test.ts

@@ -22,7 +22,10 @@ vi.mock("@temporalio/workflow", () => {
       return err;
     }
   }
-  return { ApplicationFailure: MockApplicationFailure };
+  return {
+    ApplicationFailure: MockApplicationFailure,
+    uuid4: () => "00000000-0000-0000-0000-000000000000",
+  };
 });
 
 import { createToolRouter, defineTool } from "./router";

package/src/lib/workflow.test.ts

@@ -19,6 +19,7 @@ describe("defineWorkflow", () => {
     await workflow({}, { previousThreadId: "prev-42" });
 
     expect(capturedSession).toEqual({
+      agentName: "test-workflow",
       threadId: "prev-42",
       continueThread: true,
     });
@@ -34,7 +35,10 @@ describe("defineWorkflow", () => {
 
     await workflow({}, { sandboxId: "sb-123" });
 
-    expect(capturedSession).toEqual({ sandboxId: "sb-123" });
+    expect(capturedSession).toEqual({
+      agentName: "test-workflow",
+      sandboxId: "sb-123",
+    });
   });
 
   it("maps both previousThreadId and sandboxId together", async () => {
@@ -48,6 +52,7 @@ describe("defineWorkflow", () => {
     await workflow({}, { previousThreadId: "prev-1", sandboxId: "sb-1" });
 
     expect(capturedSession).toEqual({
+      agentName: "test-workflow",
       threadId: "prev-1",
       continueThread: true,
       sandboxId: "sb-1",
@@ -64,18 +69,21 @@ describe("defineWorkflow", () => {
 
     await workflow({});
 
-    expect(capturedSession).toEqual({});
+    expect(capturedSession).toEqual({ agentName: "test-workflow" });
   });
 
   it("passes full input as first argument", async () => {
     let capturedInput: unknown;
 
-    const workflow = defineWorkflow<{
-      prompt: string;
-      metadata: { key: string };
-      previousThreadId?: string;
-      sandboxId?: string;
-    }, { ok: boolean }>(cfg, async (input, _sessionInput) => {
+    const workflow = defineWorkflow<
+      {
+        prompt: string;
+        metadata: { key: string };
+        previousThreadId?: string;
+        sandboxId?: string;
+      },
+      { ok: boolean }
+    >(cfg, async (input, _sessionInput) => {
       capturedInput = input;
       return { ok: true };
     });
@@ -101,7 +109,7 @@ describe("defineWorkflow", () => {
         capturedInput = input;
         capturedSession = sessionInput;
         return { ok: true };
-      },
+      }
     );
 
     const workflowInput: WorkflowInput = {
@@ -112,6 +120,7 @@ describe("defineWorkflow", () => {
 
     expect(capturedInput).toEqual({ prompt: "go" });
     expect(capturedSession).toEqual({
+      agentName: "test-workflow",
       threadId: "prev",
       continueThread: true,
       sandboxId: "sb",
@@ -135,7 +144,7 @@ describe("defineWorkflow", () => {
   it("sets the function name from config", () => {
     const workflow = defineWorkflow(
       { name: "my-main-workflow" },
-      async () => ({}),
+      async () => ({})
     );
 
     expect(workflow.name).toBe("my-main-workflow");

package/src/lib/workflow.ts

@@ -3,6 +3,8 @@
  * into `createSession`.
  */
 export interface WorkflowSessionInput {
+  /** Agent name — spread directly into `createSession` */
+  agentName: string;
   /** Thread ID to continue (set from `input.previousThreadId`) */
   threadId?: string;
   /** Whether to continue an existing thread (true when `previousThreadId` is present) */
@@ -36,10 +38,11 @@ export interface WorkflowConfig {
  */
 export function defineWorkflow<TInput, TResult>(
   config: WorkflowConfig,
-  fn: (input: TInput, sessionInput: WorkflowSessionInput) => Promise<TResult>,
+  fn: (input: TInput, sessionInput: WorkflowSessionInput) => Promise<TResult>
 ): (input: TInput, workflowInput?: WorkflowInput) => Promise<TResult> {
   const workflow = async (input: TInput, workflowInput: WorkflowInput = {}) => {
     const sessionInput: WorkflowSessionInput = {
+      agentName: config.name,
       ...(workflowInput.previousThreadId && {
         threadId: workflowInput.previousThreadId,
         continueThread: true,

package/src/tools/bash/bash.test.ts

@@ -4,11 +4,17 @@ import { withSandbox } from "../../lib/tool-router/with-sandbox";
 import { SandboxManager } from "../../lib/sandbox/manager";
 import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
 import type { RouterContext } from "../../lib/tool-router/types";
+import type { Sandbox, SandboxCreateOptions } from "../../lib/sandbox";
 
 describe("bash handler with sandbox", () => {
-  let manager: SandboxManager;
+  let manager: SandboxManager<SandboxCreateOptions, Sandbox, "inMemory">;
   let sandboxId: string;
-  let handler: ReturnType<typeof withSandbox<Parameters<typeof bashHandler>[0], Awaited<ReturnType<typeof bashHandler>>["data"]>>;
+  let handler: ReturnType<
+    typeof withSandbox<
+      Parameters<typeof bashHandler>[0],
+      Awaited<ReturnType<typeof bashHandler>>["data"]
+    >
+  >;
 
   beforeEach(async () => {
     manager = new SandboxManager(new InMemorySandboxProvider());
@@ -83,11 +89,14 @@ describe("bash handler with sandbox", () => {
   });
 
   it("returns error when no sandboxId in context", async () => {
-    const { toolResponse, data } = await handler({ command: "echo hi" }, {
-      threadId: "test-thread",
-      toolCallId: "test-call",
-      toolName: "Bash",
-    });
+    const { toolResponse, data } = await handler(
+      { command: "echo hi" },
+      {
+        threadId: "test-thread",
+        toolCallId: "test-call",
+        toolName: "Bash",
+      }
+    );
     expect(toolResponse).toContain("No sandbox configured");
     expect(data).toBeNull();
   });

package/src/workflow.ts

@@ -7,24 +7,15 @@
  * @example
  * ```typescript
  * // In your workflow file
- * import {
- *   createSession,
- *   createAgentStateManager,
- *   askUserQuestionTool,
- *   bashTool,
- *   defineTool,
- *   type SubagentWorkflow,
- * } from 'zeitlich/workflow';
+ * import { createSession, defineWorkflow, defineTool, bashTool } from 'zeitlich/workflow';
+ * import { proxyLangChainThreadOps } from 'zeitlich/adapters/thread/langchain/workflow';
+ * import { proxyVirtualSandboxOps } from 'zeitlich/adapters/sandbox/virtual/workflow';
  * ```
  */
 
 // Session
-export {
-  createSession,
-  proxyDefaultThreadOps,
-  proxySandboxOps,
-} from "./lib/session";
-export type { ZeitlichSession, ThreadOps, SessionConfig } from "./lib/session";
+export { createSession } from "./lib/session";
+export type { ZeitlichSession, ThreadOps, PrefixedThreadOps, ScopedPrefix, SessionConfig } from "./lib/session";
 export { defineWorkflow } from "./lib/workflow";
 export type { WorkflowConfig, WorkflowInput, WorkflowSessionInput } from "./lib/workflow";
 
@@ -147,6 +138,7 @@ export type {
   SandboxCreateResult,
   SandboxFileSystem,
   SandboxOps,
+  PrefixedSandboxOps,
   SandboxProvider,
   SandboxSnapshot,
   ExecOptions,

package/tsup.config.ts

@@ -5,11 +5,17 @@ export default defineConfig({
     index: "src/index.ts",
     workflow: "src/workflow.ts",
     "adapters/thread/langchain/index": "src/adapters/thread/langchain/index.ts",
+    "adapters/thread/langchain/workflow": "src/adapters/thread/langchain/proxy.ts",
     "adapters/thread/google-genai/index":
       "src/adapters/thread/google-genai/index.ts",
+    "adapters/thread/google-genai/workflow":
+      "src/adapters/thread/google-genai/proxy.ts",
     "adapters/sandbox/inmemory/index": "src/adapters/sandbox/inmemory/index.ts",
+    "adapters/sandbox/inmemory/workflow": "src/adapters/sandbox/inmemory/proxy.ts",
     "adapters/sandbox/daytona/index": "src/adapters/sandbox/daytona/index.ts",
+    "adapters/sandbox/daytona/workflow": "src/adapters/sandbox/daytona/proxy.ts",
     "adapters/sandbox/virtual/index": "src/adapters/sandbox/virtual/index.ts",
+    "adapters/sandbox/virtual/workflow": "src/adapters/sandbox/virtual/proxy.ts",
   },
   format: ["esm", "cjs"],
   dts: true,