zeitlich 0.2.19 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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/google-genai/activities.ts

@@ -68,7 +68,7 @@ export interface GoogleGenAIAdapter {
  * ```
  */
 export function createGoogleGenAIAdapter(
-  config: GoogleGenAIAdapterConfig,
+  config: GoogleGenAIAdapterConfig
 ): GoogleGenAIAdapter {
   const { redis, client } = config;
 
@@ -80,29 +80,31 @@ export function createGoogleGenAIAdapter(
 
     async appendHumanMessage(
       threadId: string,
-      content: string | MessageContent,
+      id: string,
+      content: string | MessageContent
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({ redis, threadId });
-      await thread.appendUserMessage(content);
+      await thread.appendUserMessage(id, content);
     },
 
     async appendSystemMessage(
       threadId: string,
-      content: string,
+      id: string,
+      content: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({ redis, threadId });
-      await thread.appendSystemMessage(content);
+      await thread.appendSystemMessage(id, content);
     },
 
-    async appendToolResult(cfg: ToolResultConfig): Promise<void> {
+    async appendToolResult(id: string, cfg: ToolResultConfig): Promise<void> {
       const { threadId, toolCallId, toolName, content } = cfg;
       const thread = createGoogleGenAIThreadManager({ redis, threadId });
-      await thread.appendToolResult(toolCallId, toolName, content);
+      await thread.appendToolResult(id, toolCallId, toolName, content);
     },
 
     async forkThread(
       sourceThreadId: string,
-      targetThreadId: string,
+      targetThreadId: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({
         redis,
@@ -120,7 +122,7 @@ export function createGoogleGenAIAdapter(
     : ((() => {
         throw new Error(
           "No default model provided to createGoogleGenAIAdapter. " +
-            "Either pass `model` in the config or use `createModelInvoker(model)` instead.",
+            "Either pass `model` in the config or use `createModelInvoker(model)` instead."
         );
       }) as unknown as ModelInvoker<Content>);
 

package/src/adapters/thread/google-genai/model-invoker.ts

@@ -1,13 +1,10 @@
 import type Redis from "ioredis";
-import type {
-  GoogleGenAI,
-  Content,
-  FunctionDeclaration,
-} from "@google/genai";
+import type { GoogleGenAI, Content, FunctionDeclaration } from "@google/genai";
 import type { SerializableToolDefinition } from "../../../lib/types";
 import type { AgentResponse } from "../../../lib/model";
 import type { ModelInvokerConfig } from "../../../lib/model";
 import { createGoogleGenAIThreadManager } from "./thread-manager";
+import { v4 as uuidv4 } from "uuid";
 
 export interface GoogleGenAIModelInvokerConfig {
   redis: Redis;
@@ -16,7 +13,7 @@ export interface GoogleGenAIModelInvokerConfig {
 }
 
 function toFunctionDeclarations(
-  tools: SerializableToolDefinition[],
+  tools: SerializableToolDefinition[]
 ): FunctionDeclaration[] {
   return tools.map((t) => ({
     name: t.name,
@@ -73,7 +70,7 @@ export function createGoogleGenAIModelInvoker({
   model,
 }: GoogleGenAIModelInvokerConfig) {
   return async function invokeGoogleGenAIModel(
-    config: ModelInvokerConfig,
+    config: ModelInvokerConfig
   ): Promise<AgentResponse<Content>> {
     const { threadId, state } = config;
 
@@ -97,9 +94,7 @@ export function createGoogleGenAIModelInvoker({
 
     const functionDeclarations = toFunctionDeclarations(state.tools);
     const tools =
-      functionDeclarations.length > 0
-        ? [{ functionDeclarations }]
-        : undefined;
+      functionDeclarations.length > 0 ? [{ functionDeclarations }] : undefined;
 
     const response = await client.models.generateContent({
       model,
@@ -113,7 +108,7 @@ export function createGoogleGenAIModelInvoker({
     const responseParts = response.candidates?.[0]?.content?.parts ?? [];
     const modelContent: Content = { role: "model", parts: responseParts };
 
-    await thread.appendModelContent(responseParts);
+    await thread.appendModelContent(uuidv4(), responseParts);
 
     const functionCalls = response.functionCalls ?? [];
 

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

@@ -21,23 +21,30 @@ export interface GoogleGenAIThreadManagerConfig {
 }
 
 /** Thread manager with Google GenAI Content convenience helpers */
-export interface GoogleGenAIThreadManager
-  extends BaseThreadManager<StoredContent> {
-  createUserContent(content: string | MessageContent): StoredContent;
-  createSystemContent(content: string): StoredContent;
-  createModelContent(parts: Part[]): StoredContent;
+export interface GoogleGenAIThreadManager extends BaseThreadManager<StoredContent> {
+  createUserContent(
+    id: string,
+    content: string | MessageContent
+  ): StoredContent;
+  createSystemContent(id: string, content: string): StoredContent;
+  createModelContent(id: string, parts: Part[]): StoredContent;
   createToolResponseContent(
+    id: string,
     toolCallId: string,
     toolName: string,
-    content: ToolMessageContent,
+    content: ToolMessageContent
   ): StoredContent;
-  appendUserMessage(content: string | MessageContent): Promise<void>;
-  appendSystemMessage(content: string): Promise<void>;
-  appendModelContent(parts: Part[]): Promise<void>;
+  appendUserMessage(
+    id: string,
+    content: string | MessageContent
+  ): Promise<void>;
+  appendSystemMessage(id: string, content: string): Promise<void>;
+  appendModelContent(id: string, parts: Part[]): Promise<void>;
   appendToolResult(
+    id: string,
     toolCallId: string,
     toolName: string,
-    content: ToolMessageContent,
+    content: ToolMessageContent
   ): Promise<void>;
 }
 
@@ -47,7 +54,7 @@ function storedContentId(msg: StoredContent): string {
 
 /** Convert zeitlich MessageContent to Google GenAI Part[] */
 export function messageContentToParts(
-  content: string | MessageContent,
+  content: string | MessageContent
 ): Part[] {
   if (typeof content === "string") {
     return [{ text: content }];
@@ -65,7 +72,7 @@ export function messageContentToParts(
 
 /** Parse ToolMessageContent into a Record suitable for functionResponse */
 function parseToolResponse(
-  content: ToolMessageContent,
+  content: ToolMessageContent
 ): Record<string, unknown> {
   if (typeof content === "string") {
     try {
@@ -86,7 +93,7 @@ function parseToolResponse(
  * appending typed Content messages.
  */
 export function createGoogleGenAIThreadManager(
-  config: GoogleGenAIThreadManagerConfig,
+  config: GoogleGenAIThreadManagerConfig
 ): GoogleGenAIThreadManager {
   const baseConfig: ThreadManagerConfig<StoredContent> = {
     redis: config.redis,
@@ -98,34 +105,38 @@ export function createGoogleGenAIThreadManager(
   const base = createThreadManager(baseConfig);
 
   const helpers = {
-    createUserContent(content: string | MessageContent): StoredContent {
+    createUserContent(
+      id: string,
+      content: string | MessageContent
+    ): StoredContent {
       return {
-        id: crypto.randomUUID(),
+        id,
         content: { role: "user", parts: messageContentToParts(content) },
       };
     },
 
-    createSystemContent(content: string): StoredContent {
+    createSystemContent(id: string, content: string): StoredContent {
       return {
-        id: crypto.randomUUID(),
+        id,
         content: { role: "system", parts: [{ text: content }] },
       };
     },
 
-    createModelContent(parts: Part[]): StoredContent {
+    createModelContent(id: string, parts: Part[]): StoredContent {
       return {
-        id: crypto.randomUUID(),
+        id,
         content: { role: "model", parts },
       };
     },
 
     createToolResponseContent(
+      id: string,
       toolCallId: string,
       toolName: string,
-      content: ToolMessageContent,
+      content: ToolMessageContent
     ): StoredContent {
       return {
-        id: crypto.randomUUID(),
+        id,
         content: {
           role: "user",
           parts: [
@@ -141,26 +152,30 @@ export function createGoogleGenAIThreadManager(
       };
     },
 
-    async appendUserMessage(content: string | MessageContent): Promise<void> {
-      await base.append([helpers.createUserContent(content)]);
+    async appendUserMessage(
+      id: string,
+      content: string | MessageContent
+    ): Promise<void> {
+      await base.append([helpers.createUserContent(id, content)]);
     },
 
-    async appendSystemMessage(content: string): Promise<void> {
+    async appendSystemMessage(id: string, content: string): Promise<void> {
       await base.initialize();
-      await base.append([helpers.createSystemContent(content)]);
+      await base.append([helpers.createSystemContent(id, content)]);
     },
 
-    async appendModelContent(parts: Part[]): Promise<void> {
-      await base.append([helpers.createModelContent(parts)]);
+    async appendModelContent(id: string, parts: Part[]): Promise<void> {
+      await base.append([helpers.createModelContent(id, parts)]);
     },
 
     async appendToolResult(
+      id: string,
       toolCallId: string,
       toolName: string,
-      content: ToolMessageContent,
+      content: ToolMessageContent
     ): Promise<void> {
       await base.append([
-        helpers.createToolResponseContent(toolCallId, toolName, content),
+        helpers.createToolResponseContent(id, toolCallId, toolName, content),
       ]);
     },
   };

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

@@ -74,24 +74,26 @@ export function createLangChainAdapter(
 
     async appendHumanMessage(
       threadId: string,
+      id: string,
       content: string | MessageContent
     ): Promise<void> {
       const thread = createLangChainThreadManager({ redis, threadId });
-      await thread.appendHumanMessage(content);
+      await thread.appendHumanMessage(id, content);
     },
 
     async appendSystemMessage(
       threadId: string,
+      id: string,
       content: string
     ): Promise<void> {
       const thread = createLangChainThreadManager({ redis, threadId });
-      await thread.appendSystemMessage(content);
+      await thread.appendSystemMessage(id, content);
     },
 
-    async appendToolResult(cfg: ToolResultConfig): Promise<void> {
+    async appendToolResult(id: string, cfg: ToolResultConfig): Promise<void> {
       const { threadId, toolCallId, content } = cfg;
       const thread = createLangChainThreadManager({ redis, threadId });
-      await thread.appendToolMessage(content, toolCallId);
+      await thread.appendToolMessage(id, content, toolCallId);
     },
 
     async forkThread(

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

@@ -9,7 +9,6 @@ import {
   SystemMessage,
   ToolMessage,
 } from "@langchain/core/messages";
-import { v4 as uuidv4 } from "uuid";
 import {
   createThreadManager,
   type BaseThreadManager,
@@ -30,27 +29,44 @@ export interface LangChainThreadManagerConfig {
 
 /** Thread manager with LangChain StoredMessage convenience helpers */
 export interface LangChainThreadManager extends BaseThreadManager<StoredMessage> {
-  createHumanMessage(content: string | MessageContent): StoredMessage;
-  createSystemMessage(content: string): StoredMessage;
+  createHumanMessage(
+    id: string,
+    content: string | MessageContent
+  ): StoredMessage;
+  createSystemMessage(id: string, content: string): StoredMessage;
   createAIMessage(
+    id: string,
     content: string | MessageContent,
-    kwargs?: { header?: string; options?: string[]; multiSelect?: boolean },
+    kwargs?: { header?: string; options?: string[]; multiSelect?: boolean }
   ): StoredMessage;
   createToolMessage(
+    id: string,
     content: LangChainToolMessageContent,
-    toolCallId: string,
+    toolCallId: string
   ): StoredMessage;
-  appendHumanMessage(content: string | MessageContent): Promise<void>;
-  appendSystemMessage(content: string): Promise<void>;
+  appendHumanMessage(
+    id: string,
+    content: string | MessageContent
+  ): Promise<void>;
+  appendSystemMessage(id: string, content: string): Promise<void>;
   appendToolMessage(
+    id: string,
     content: LangChainToolMessageContent,
-    toolCallId: string,
+    toolCallId: string
   ): Promise<void>;
-  appendAIMessage(content: string | MessageContent): Promise<void>;
+  appendAIMessage(id: string, content: string | MessageContent): Promise<void>;
 }
 
 function storedMessageId(msg: StoredMessage): string {
-  return msg.data.id ?? "";
+  if (msg.type === "tool" && msg.data.tool_call_id) {
+    return msg.data.tool_call_id;
+  }
+
+  if (msg.data.id) {
+    return msg.data.id;
+  }
+
+  throw new Error("No id found for message");
 }
 
 /**
@@ -59,7 +75,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,
@@ -71,26 +87,30 @@ export function createLangChainThreadManager(
   const base = createThreadManager(baseConfig);
 
   const helpers = {
-    createHumanMessage(content: string | MessageContent): StoredMessage {
+    createHumanMessage(
+      id: string,
+      content: string | MessageContent
+    ): StoredMessage {
       return new HumanMessage({
-        id: uuidv4(),
+        id,
         content: content as string,
       }).toDict();
     },
 
-    createSystemMessage(content: string): StoredMessage {
+    createSystemMessage(id: string, content: string): StoredMessage {
       return new SystemMessage({
-        id: uuidv4(),
+        id,
         content: content as string,
       }).toDict();
     },
 
     createAIMessage(
+      id: string,
       content: string,
-      kwargs?: { header?: string; options?: string[]; multiSelect?: boolean },
+      kwargs?: { header?: string; options?: string[]; multiSelect?: boolean }
     ): StoredMessage {
       return new AIMessage({
-        id: uuidv4(),
+        id,
         content,
         additional_kwargs: kwargs
           ? {
@@ -103,36 +123,44 @@ export function createLangChainThreadManager(
     },
 
     createToolMessage(
+      id: string,
       content: LangChainToolMessageContent,
-      toolCallId: string,
+      toolCallId: string
     ): StoredMessage {
       return new ToolMessage({
-        id: uuidv4(),
+        id,
         content: content as MessageContent,
         tool_call_id: toolCallId,
       }).toDict();
     },
 
-    async appendHumanMessage(content: string | MessageContent): Promise<void> {
-      const message = helpers.createHumanMessage(content);
+    async appendHumanMessage(
+      id: string,
+      content: string | MessageContent
+    ): Promise<void> {
+      const message = helpers.createHumanMessage(id, content);
       await base.append([message]);
     },
 
     async appendToolMessage(
+      id: string,
       content: LangChainToolMessageContent,
-      toolCallId: string,
+      toolCallId: string
     ): Promise<void> {
-      const message = helpers.createToolMessage(content, toolCallId);
+      const message = helpers.createToolMessage(id, content, toolCallId);
       await base.append([message]);
     },
 
-    async appendAIMessage(content: string | MessageContent): Promise<void> {
-      const message = helpers.createAIMessage(content as string);
+    async appendAIMessage(
+      id: string,
+      content: string | MessageContent
+    ): Promise<void> {
+      const message = helpers.createAIMessage(id, content as string);
       await base.append([message]);
     },
 
-    async appendSystemMessage(content: string): Promise<void> {
-      const message = helpers.createSystemMessage(content);
+    async appendSystemMessage(id: string, content: string): Promise<void> {
+      const message = helpers.createSystemMessage(id, content);
       await base.initialize();
       await base.append([message]);
     },