zeitlich 0.2.21 → 0.2.23

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

@@ -38,8 +38,13 @@ vi.mock("@temporalio/workflow", () => {
     condition: async (fn: () => boolean) => fn(),
     defineUpdate: (name: string) => ({ __type: "update", name }),
     defineQuery: (name: string) => ({ __type: "query", name }),
+    defineSignal: (name: string) => ({ __type: "signal", name }),
     setHandler: (_def: unknown, _handler: unknown) => {},
-    uuid4: () => `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
+    startChild: async () => ({ result: () => Promise.resolve(null) }),
+    workflowInfo: () => ({ taskQueue: "default-queue" }),
+    getExternalWorkflowHandle: () => ({ signal: async () => {} }),
+    uuid4: () =>
+      `00000000-0000-0000-0000-${String(++idCounter).padStart(12, "0")}`,
     ApplicationFailure: MockApplicationFailure,
   };
 });
@@ -59,12 +64,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 +83,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 +106,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 +130,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 },
@@ -148,10 +154,8 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "Hello!", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "Hello!", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "What is 2+2?",
     });
@@ -168,11 +172,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 ---
@@ -182,7 +186,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "Let me echo that.",
@@ -209,7 +213,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");
   });
@@ -221,7 +225,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "turn 1",
@@ -265,12 +269,12 @@ 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({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       maxTurns: 3,
       runAgent: infiniteAgent,
       threadOps: ops,
@@ -297,10 +301,8 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "hi",
       hooks: {
@@ -332,7 +334,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([]),
       threadOps: ops,
       buildContextMessage: () => "hi",
@@ -343,7 +345,7 @@ describe("createSession integration", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "No system prompt in state",
+      "No system prompt in state"
     );
   });
 
@@ -352,11 +354,9 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       appendSystemPrompt: false,
-      runAgent: createScriptedRunAgent([
-        { message: "ok", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "ok", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "hi",
     });
@@ -381,7 +381,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "turn 1",
@@ -417,7 +417,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "bad call",
@@ -447,23 +447,22 @@ 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");
   });
 
-  // --- continueThread ---
+  // --- Thread fork mode ---
 
-  it("forks thread when continueThread is set", async () => {
+  it("forks thread when thread mode is fork", async () => {
     const { ops, log } = createMockThreadOps();
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "source-thread",
-      continueThread: true,
+      thread: { mode: "fork", threadId: "source-thread" },
       runAgent: createScriptedRunAgent([
         { message: "continued", toolCalls: [] },
       ]),
@@ -494,9 +493,9 @@ describe("createSession integration", () => {
     const sandboxLog: string[] = [];
 
     const sandboxOps: SandboxOps = {
-      createSandbox: async (options) => {
-        sandboxLog.push(`create:${options?.id ?? "unknown"}`);
-        return { sandboxId: `sb-${options?.id ?? "unknown"}` };
+      createSandbox: async () => {
+        sandboxLog.push("create");
+        return { sandboxId: "sb-1" };
       },
       destroySandbox: async (sandboxId: string) => {
         sandboxLog.push(`destroy:${sandboxId}`);
@@ -507,17 +506,17 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager({
@@ -526,8 +525,8 @@ describe("createSession integration", () => {
 
     await session.runSession({ stateManager });
 
-    expect(sandboxLog).toContain("create:thread-1");
-    expect(sandboxLog).toContain("destroy:sb-thread-1");
+    expect(sandboxLog).toContain("create");
+    expect(sandboxLog).toContain("destroy:sb-1");
   });
 
   it("does not create or destroy sandbox when sandboxId is inherited", async () => {
@@ -548,18 +547,18 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
-      sandboxId: "inherited-sb",
+      sandboxOps,
+      sandbox: { mode: "inherit", sandboxId: "inherited-sb" },
     });
 
     const stateManager = createAgentStateManager({
@@ -587,9 +586,22 @@ describe("createSession integration", () => {
       },
     });
 
+    const sandboxOps: SandboxOps = {
+      createSandbox: async () => ({ sandboxId: "sb" }),
+      destroySandbox: async () => {},
+      pauseSandbox: async () => {},
+      snapshotSandbox: async () => ({
+        sandboxId: "sb",
+        providerId: "test",
+        data: null,
+        createdAt: new Date().toISOString(),
+      }),
+      forkSandbox: async () => "forked-sb",
+    };
+
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "spy",
@@ -600,7 +612,8 @@ describe("createSession integration", () => {
       threadOps: ops,
       tools: { Spy: spyTool },
       buildContextMessage: () => "go",
-      sandboxId: "my-sandbox",
+      sandbox: { mode: "inherit", sandboxId: "my-sandbox" },
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager({
@@ -620,7 +633,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: async () => {
         throw new Error("LLM went down");
       },
@@ -638,7 +651,7 @@ describe("createSession integration", () => {
     });
 
     await expect(session.runSession({ stateManager })).rejects.toThrow(
-      "LLM went down",
+      "LLM went down"
     );
 
     expect(endReason).toBe("failed");
@@ -652,7 +665,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "call echo",
@@ -690,9 +703,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
     });
@@ -724,7 +735,7 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "computing",
@@ -760,10 +771,8 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: async () => {
         await new Promise((r) => setTimeout(r, 5));
@@ -778,7 +787,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,17 +807,17 @@ describe("createSession integration", () => {
         data: null,
         createdAt: new Date().toISOString(),
       }),
+      forkSandbox: async () => "forked-sandbox-id",
+      pauseSandbox: async () => {},
     };
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
-      runAgent: createScriptedRunAgent([
-        { message: "done", toolCalls: [] },
-      ]),
+      thread: { mode: "new", threadId: "thread-1" },
+      runAgent: createScriptedRunAgent([{ message: "done", toolCalls: [] }]),
       threadOps: ops,
       buildContextMessage: () => "go",
-      sandbox: sandboxOps,
+      sandboxOps,
     });
 
     const stateManager = createAgentStateManager<{ customField: string }>({
@@ -838,14 +847,18 @@ describe("createSession integration", () => {
 
     const session = await createSession({
       agentName: "TestAgent",
-      threadId: "thread-1",
+      thread: { mode: "new", threadId: "thread-1" },
       runAgent: createScriptedRunAgent([
         {
           message: "t1",
           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 +877,3 @@ describe("createSession integration", () => {
     expect(result.usage.totalOutputTokens).toBe(90);
   });
 });
-