zeitlich 0.2.18 → 0.2.20

package/package.json

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

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

@@ -19,7 +19,7 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
 
   constructor(
     private sandbox: DaytonaSdkSandbox,
-    workspaceBase = "/home/daytona",
+    workspaceBase = "/home/daytona"
   ) {
     this.workspaceBase = posix.resolve("/", workspaceBase);
   }
@@ -49,10 +49,18 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     await this.sandbox.fs.uploadFile(buf, norm);
   }
 
-  async appendFile(
-    path: string,
-    content: string | Uint8Array,
+  async writeFiles(
+    files: { path: string; content: string | Uint8Array }[]
   ): Promise<void> {
+    await this.sandbox.fs.uploadFiles(
+      files.map((f) => ({
+        source: Buffer.from(f.content),
+        destination: f.path,
+      }))
+    );
+  }
+
+  async appendFile(path: string, content: string | Uint8Array): Promise<void> {
     const norm = this.normalisePath(path);
     let existing: Buffer;
     try {
@@ -89,10 +97,7 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
     };
   }
 
-  async mkdir(
-    path: string,
-    _options?: { recursive?: boolean },
-  ): Promise<void> {
+  async mkdir(path: string, _options?: { recursive?: boolean }): Promise<void> {
     const norm = this.normalisePath(path);
     await this.sandbox.fs.createFolder(norm, "755");
   }
@@ -116,7 +121,7 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
 
   async rm(
     path: string,
-    options?: { recursive?: boolean; force?: boolean },
+    options?: { recursive?: boolean; force?: boolean }
   ): Promise<void> {
     const norm = this.normalisePath(path);
     try {
@@ -129,7 +134,7 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
   async cp(
     src: string,
     dest: string,
-    options?: { recursive?: boolean },
+    options?: { recursive?: boolean }
   ): Promise<void> {
     const normSrc = this.normalisePath(src);
     const normDest = this.normalisePath(dest);
@@ -138,9 +143,13 @@ export class DaytonaSandboxFileSystem implements SandboxFileSystem {
       if (!options?.recursive) {
         throw new Error(`EISDIR: is a directory (use recursive): ${src}`);
       }
-      await this.sandbox.process.executeCommand(`cp -r "${normSrc}" "${normDest}"`);
+      await this.sandbox.process.executeCommand(
+        `cp -r "${normSrc}" "${normDest}"`
+      );
     } else {
-      await this.sandbox.process.executeCommand(`cp "${normSrc}" "${normDest}"`);
+      await this.sandbox.process.executeCommand(
+        `cp "${normSrc}" "${normDest}"`
+      );
     }
   }
 

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

@@ -1,7 +1,4 @@
-import {
-  Daytona,
-  type Sandbox as DaytonaSdkSandbox,
-} from "@daytonaio/sdk";
+import { Daytona, type Sandbox as DaytonaSdkSandbox } from "@daytonaio/sdk";
 import type {
   Sandbox,
   SandboxCapabilities,
@@ -38,7 +35,7 @@ class DaytonaSandboxImpl implements Sandbox {
   constructor(
     readonly id: string,
     private sdkSandbox: DaytonaSdkSandbox,
-    workspaceBase = "/home/daytona",
+    workspaceBase = "/home/daytona"
   ) {
     this.fs = new DaytonaSandboxFileSystem(sdkSandbox, workspaceBase);
   }
@@ -48,7 +45,7 @@ class DaytonaSandboxImpl implements Sandbox {
       command,
       options?.cwd,
       options?.env,
-      options?.timeout,
+      options?.timeout
     );
 
     return {
@@ -67,9 +64,10 @@ class DaytonaSandboxImpl implements Sandbox {
 // DaytonaSandboxProvider
 // ============================================================================
 
-export class DaytonaSandboxProvider
-  implements SandboxProvider<DaytonaSandboxCreateOptions, DaytonaSandbox>
-{
+export class DaytonaSandboxProvider implements SandboxProvider<
+  DaytonaSandboxCreateOptions,
+  DaytonaSandbox
+> {
   readonly id = "daytona";
   readonly capabilities: SandboxCapabilities = {
     filesystem: true,
@@ -79,7 +77,6 @@ export class DaytonaSandboxProvider
 
   private client: Daytona;
   private readonly defaultWorkspaceBase: string;
-  private workspaceBaseById = new Map<string, string>();
 
   constructor(config?: DaytonaSandboxConfig) {
     this.client = new Daytona(config);
@@ -87,7 +84,7 @@ export class DaytonaSandboxProvider
   }
 
   async create(
-    options?: DaytonaSandboxCreateOptions,
+    options?: DaytonaSandboxCreateOptions
   ): Promise<SandboxCreateResult> {
     const sdkSandbox = await this.client.create(
       {
@@ -99,21 +96,24 @@ export class DaytonaSandboxProvider
         autoArchiveInterval: options?.autoArchiveInterval,
         autoDeleteInterval: options?.autoDeleteInterval,
       },
-      { timeout: options?.timeout ?? 60 },
+      { timeout: options?.timeout ?? 60 }
     );
 
     const workspaceBase = options?.workspaceBase ?? this.defaultWorkspaceBase;
-    this.workspaceBaseById.set(sdkSandbox.id, workspaceBase);
+
     const sandbox = new DaytonaSandboxImpl(
       sdkSandbox.id,
       sdkSandbox,
-      workspaceBase,
+      workspaceBase
     );
 
     if (options?.initialFiles) {
-      for (const [path, content] of Object.entries(options.initialFiles)) {
-        await sandbox.fs.writeFile(path, content);
-      }
+      await sandbox.fs.writeFiles(
+        Object.entries(options.initialFiles).map(([path, content]) => ({
+          path,
+          content,
+        }))
+      );
     }
 
     return { sandbox };
@@ -122,9 +122,11 @@ export class DaytonaSandboxProvider
   async get(sandboxId: string): Promise<DaytonaSandbox> {
     try {
       const sdkSandbox = await this.client.get(sandboxId);
-      const workspaceBase =
-        this.workspaceBaseById.get(sandboxId) ?? this.defaultWorkspaceBase;
-      return new DaytonaSandboxImpl(sdkSandbox.id, sdkSandbox, workspaceBase);
+      return new DaytonaSandboxImpl(
+        sdkSandbox.id,
+        sdkSandbox,
+        this.defaultWorkspaceBase
+      );
     } catch {
       throw new SandboxNotFoundError(sandboxId);
     }
@@ -134,7 +136,6 @@ export class DaytonaSandboxProvider
     try {
       const sdkSandbox = await this.client.get(sandboxId);
       await this.client.delete(sdkSandbox);
-      this.workspaceBaseById.delete(sandboxId);
     } catch {
       // Already gone
     }
@@ -142,13 +143,13 @@ export class DaytonaSandboxProvider
 
   async snapshot(_sandboxId: string): Promise<SandboxSnapshot> {
     throw new SandboxNotSupportedError(
-      "snapshot (use Daytona's native snapshot API directly)",
+      "snapshot (use Daytona's native snapshot API directly)"
     );
   }
 
   async restore(_snapshot: SandboxSnapshot): Promise<never> {
     throw new SandboxNotSupportedError(
-      "restore (use Daytona's native snapshot API directly)",
+      "restore (use Daytona's native snapshot API directly)"
     );
   }
 }

package/src/adapters/thread/langchain/thread-manager.ts

@@ -34,22 +34,26 @@ export interface LangChainThreadManager extends BaseThreadManager<StoredMessage>
   createSystemMessage(content: string): StoredMessage;
   createAIMessage(
     content: string | MessageContent,
-    kwargs?: { header?: string; options?: string[]; multiSelect?: boolean },
+    kwargs?: { header?: string; options?: string[]; multiSelect?: boolean }
   ): StoredMessage;
   createToolMessage(
     content: LangChainToolMessageContent,
-    toolCallId: string,
+    toolCallId: string
   ): StoredMessage;
   appendHumanMessage(content: string | MessageContent): Promise<void>;
   appendSystemMessage(content: string): Promise<void>;
   appendToolMessage(
     content: LangChainToolMessageContent,
-    toolCallId: string,
+    toolCallId: string
   ): Promise<void>;
   appendAIMessage(content: string | MessageContent): Promise<void>;
 }
 
 function storedMessageId(msg: StoredMessage): string {
+  if (msg.type === "tool") {
+    return msg.data.tool_call_id ?? "";
+  }
+
   return msg.data.id ?? "";
 }
 
@@ -59,7 +63,7 @@ function storedMessageId(msg: StoredMessage): string {
  * appending typed LangChain messages.
  */
 export function createLangChainThreadManager(
-  config: LangChainThreadManagerConfig,
+  config: LangChainThreadManagerConfig
 ): LangChainThreadManager {
   const baseConfig: ThreadManagerConfig<StoredMessage> = {
     redis: config.redis,
@@ -87,7 +91,7 @@ export function createLangChainThreadManager(
 
     createAIMessage(
       content: string,
-      kwargs?: { header?: string; options?: string[]; multiSelect?: boolean },
+      kwargs?: { header?: string; options?: string[]; multiSelect?: boolean }
     ): StoredMessage {
       return new AIMessage({
         id: uuidv4(),
@@ -104,7 +108,7 @@ export function createLangChainThreadManager(
 
     createToolMessage(
       content: LangChainToolMessageContent,
-      toolCallId: string,
+      toolCallId: string
     ): StoredMessage {
       return new ToolMessage({
         id: uuidv4(),
@@ -120,7 +124,7 @@ export function createLangChainThreadManager(
 
     async appendToolMessage(
       content: LangChainToolMessageContent,
-      toolCallId: string,
+      toolCallId: string
     ): Promise<void> {
       const message = helpers.createToolMessage(content, toolCallId);
       await base.append([message]);

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

@@ -5,6 +5,7 @@ import type { ThreadOps } from "./types";
 import type { RunAgentActivity } from "../model/types";
 import type { RawToolCall } from "../tool-router/types";
 import type { SandboxOps } from "../sandbox/types";
+import type { ActivityInterfaceFor } from "@temporalio/workflow";
 
 let idCounter = 0;
 
@@ -51,9 +52,26 @@ type TurnScript = {
   usage?: TokenUsage;
 };
 
+/**
+ * Wraps every method on a ThreadOps object so it also has `.executeWithOptions()`,
+ * matching Temporal's `ActivityInterfaceFor<ThreadOps>` shape.
+ */
+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);
+    wrapped.executeWithOptions = (_opts: unknown, args: unknown[]) =>
+      (fn as (...a: unknown[]) => unknown)(...args);
+    result[key] = wrapped;
+  }
+  return result as ActivityInterfaceFor<ThreadOps>;
+}
+
 function createMockThreadOps() {
   const log: { op: string; args: unknown[] }[] = [];
-  const ops: ThreadOps = {
+  const ops = toActivityInterface({
     initializeThread: async (threadId) => {
       log.push({ op: "initializeThread", args: [threadId] });
     },
@@ -69,7 +87,7 @@ function createMockThreadOps() {
     forkThread: async (source, target) => {
       log.push({ op: "forkThread", args: [source, target] });
     },
-  };
+  });
   return { ops, log };
 }
 

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

@@ -5,6 +5,7 @@ import type { ThreadOps } from "./types";
 import type { RunAgentActivity } from "../model/types";
 import type { RawToolCall } from "../tool-router/types";
 import type { SandboxOps } from "../sandbox/types";
+import type { ActivityInterfaceFor } from "@temporalio/workflow";
 
 // ---------------------------------------------------------------------------
 // Mock @temporalio/workflow
@@ -58,10 +59,23 @@ function at<T>(arr: T[], index: number): T {
   return val;
 }
 
+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);
+    wrapped.executeWithOptions = (_opts: unknown, args: unknown[]) =>
+      (fn as (...a: unknown[]) => unknown)(...args);
+    result[key] = wrapped;
+  }
+  return result as ActivityInterfaceFor<ThreadOps>;
+}
+
 function createMockThreadOps() {
   const log: { op: string; args: unknown[] }[] = [];
 
-  const ops: ThreadOps = {
+  const ops = toActivityInterface({
     initializeThread: async (threadId) => {
       log.push({ op: "initializeThread", args: [threadId] });
     },
@@ -77,7 +91,7 @@ function createMockThreadOps() {
     forkThread: async (source, target) => {
       log.push({ op: "forkThread", args: [source, target] });
     },
-  };
+  });
 
   return { ops, log };
 }

package/src/lib/session/session.ts

@@ -4,6 +4,7 @@ import {
   defineUpdate,
   setHandler,
   ApplicationFailure,
+  type ActivityInterfaceFor,
 } from "@temporalio/workflow";
 import type { SessionExitReason, MessageContent } from "../types";
 import type { ThreadOps, SessionConfig, ZeitlichSession } from "./types";
@@ -299,7 +300,7 @@ export const createSession = async <T extends ToolMap, M = unknown>({
  */
 export function proxyDefaultThreadOps(
   options?: Parameters<typeof proxyActivities>[0]
-): ThreadOps {
+): ActivityInterfaceFor<ThreadOps> {
   return proxyActivities<ThreadOps>(
     options ?? {
       startToCloseTimeout: "10s",

package/src/lib/session/types.ts

@@ -15,6 +15,7 @@ import type { Skill } from "../skills/types";
 import type { SandboxOps } from "../sandbox/types";
 import type { RunAgentActivity } from "../model/types";
 import type { AgentStateManager, JsonSerializable } from "../state/types";
+import type { ActivityInterfaceFor } from "@temporalio/workflow";
 
 /**
  * Thread operations required by a session.
@@ -53,7 +54,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?: ThreadOps;
+  threadOps?: ActivityInterfaceFor<ThreadOps>;
   /** Tool router for processing tool calls (optional if agent has no tools) */
   tools?: T;
   /** Subagent configurations */

package/src/lib/subagent/handler.ts

@@ -89,7 +89,7 @@ export function createSubagentHandler<
     if (config.allowThreadContinuation && childThreadId) {
       finalToolResponse =
         typeof toolResponse === "string"
-          ? `${toolResponse}\n\n[Thread ID: ${childThreadId}]`
+          ? `${toolResponse}\n\n[${config.agentName} Thread ID: ${childThreadId}]`
           : toolResponse;
     }
 

package/src/lib/subagent/register.ts

@@ -39,15 +39,9 @@ export function buildSubagentRegistration(
 
   return {
     name: SUBAGENT_TOOL_NAME,
-    get enabled(): boolean {
-      return getEnabled().length > 0;
-    },
-    get description(): string {
-      return createSubagentTool(getEnabled()).description;
-    },
-    get schema(): z.ZodObject<z.ZodRawShape> {
-      return createSubagentTool(getEnabled()).schema;
-    },
+    enabled: (): boolean => getEnabled().length > 0,
+    description: (): string => createSubagentTool(getEnabled()).description,
+    schema: (): z.ZodObject<z.ZodRawShape> => createSubagentTool(getEnabled()).schema,
     handler: createSubagentHandler(subagents),
     ...(subagentHooksMap.size > 0 && {
       hooks: {

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

@@ -397,10 +397,10 @@ describe("buildSubagentRegistration", () => {
 
     expect(reg).toBeDefined();
     if (!reg) return;
-    expect(reg.enabled).toBe(true);
+    expect((reg.enabled as () => boolean)()).toBe(true);
 
     flag = false;
-    expect(reg.enabled).toBe(false);
+    expect((reg.enabled as () => boolean)()).toBe(false);
   });
 
   it("disabled when all subagents are disabled", () => {
@@ -415,7 +415,7 @@ describe("buildSubagentRegistration", () => {
 
     expect(reg).toBeDefined();
     if (reg) {
-      expect(reg.enabled).toBe(false);
+      expect((reg.enabled as () => boolean)()).toBe(false);
     }
   });
 
@@ -476,13 +476,14 @@ describe("buildSubagentRegistration", () => {
 
     expect(reg).toBeDefined();
     if (reg) {
-      expect(reg.description).toContain("Agent A");
-      expect(reg.description).toContain("Agent B");
+      const desc = reg.description as () => string;
+      expect(desc()).toContain("Agent A");
+      expect(desc()).toContain("Agent B");
 
       bEnabled = false;
 
-      expect(reg.description).toContain("Agent A");
-      expect(reg.description).not.toContain("Agent B");
+      expect(desc()).toContain("Agent A");
+      expect(desc()).not.toContain("Agent B");
     }
   });
 });
@@ -519,10 +520,10 @@ describe("defineSubagent", () => {
     const reg = buildSubagentRegistration([config]);
     expect(reg).toBeDefined();
     if (!reg) return;
-    expect(reg.enabled).toBe(true);
+    expect((reg.enabled as () => boolean)()).toBe(true);
 
     flag = false;
-    expect(reg.enabled).toBe(false);
+    expect((reg.enabled as () => boolean)()).toBe(false);
   });
 });
 

package/src/lib/subagent/tool.ts

@@ -57,7 +57,7 @@ export function createSubagentTool<T extends SubagentConfig[]>(
           .string()
           .nullable()
           .describe(
-            "Thread ID to continue an existing conversation, or null to start a new one"
+            "Thread ID to continue an existing conversation from the same subagent, or null to start a new one"
           ),
       })
     : z.object(baseFields);

package/src/lib/thread/index.ts

@@ -1,5 +1,4 @@
 export { createThreadManager } from "./manager";
-export { getShortId } from "./id";
 
 export type {
   ThreadManagerConfig,

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

@@ -38,9 +38,14 @@ import type { ToolResultConfig } from "../types";
 
 function createAppendSpy() {
   const calls: ToolResultConfig[] = [];
-  const fn: AppendToolResultFn = async (config) => {
-    calls.push(config);
-  };
+  const fn = Object.assign(
+    async (config: ToolResultConfig) => { calls.push(config); },
+    { executeWithOptions: (_opts: unknown, [config]: [ToolResultConfig]) => {
+        calls.push(config);
+        return Promise.resolve();
+      },
+    },
+  ) as AppendToolResultFn;
   return { fn, calls };
 }
 

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

@@ -86,9 +86,14 @@ function createTools() {
 
 function createAppendSpy() {
   const calls: ToolResultConfig[] = [];
-  const fn: AppendToolResultFn = async (config) => {
-    calls.push(config);
-  };
+  const fn = Object.assign(
+    async (config: ToolResultConfig) => { calls.push(config); },
+    { executeWithOptions: (_opts: unknown, [config]: [ToolResultConfig]) => {
+        calls.push(config);
+        return Promise.resolve();
+      },
+    },
+  ) as AppendToolResultFn;
   return { fn, calls };
 }