zeitlich 0.2.48 → 0.2.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -97,26 +97,6 @@
         "default": "./dist/adapters/thread/anthropic/workflow.js"
       }
     },
-    "./adapters/sandbox/inmemory": {
-      "import": {
-        "types": "./dist/adapters/sandbox/inmemory/index.d.ts",
-        "default": "./dist/adapters/sandbox/inmemory/index.js"
-      },
-      "require": {
-        "types": "./dist/adapters/sandbox/inmemory/index.d.ts",
-        "default": "./dist/adapters/sandbox/inmemory/index.js"
-      }
-    },
-    "./adapters/sandbox/inmemory/workflow": {
-      "import": {
-        "types": "./dist/adapters/sandbox/inmemory/workflow.d.ts",
-        "default": "./dist/adapters/sandbox/inmemory/workflow.js"
-      },
-      "require": {
-        "types": "./dist/adapters/sandbox/inmemory/workflow.d.ts",
-        "default": "./dist/adapters/sandbox/inmemory/workflow.js"
-      }
-    },
     "./adapters/sandbox/daytona": {
       "import": {
         "types": "./dist/adapters/sandbox/daytona/index.d.ts",
@@ -201,22 +181,22 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.98.0",
+    "@anthropic-ai/sdk": "^0.100.1",
     "@aws-sdk/client-s3": "^3.1000.0",
     "@aws-sdk/lib-storage": "^3.1000.0",
-    "@daytonaio/sdk": "^0.171.0",
+    "@daytonaio/sdk": "^0.184.0",
     "@e2b/code-interpreter": "^2.3.3",
     "@eslint/js": "^10.0.1",
-    "@google/genai": "^1.44.0",
+    "@google/genai": "^2.7.0",
     "@langchain/core": "^1.1.48",
     "@temporalio/common": "^1.17.2",
     "@temporalio/envconfig": "^1.17.2",
     "@temporalio/worker": "^1.17.2",
     "@temporalio/workflow": "^1.17.2",
     "@types/node": "^25.3.3",
-    "eslint": "^10.0.2",
+    "eslint": "^10.4.1",
     "husky": "^9.1.7",
-    "just-bash": "^2.12.8",
+    "just-bash": "^3.0.1",
     "prettier": "^3.8.1",
     "release-please": "^17.3.0",
     "tsup": "^8.5.1",
@@ -225,19 +205,18 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@anthropic-ai/sdk": ">=0.50.0",
+    "@anthropic-ai/sdk": ">=0.100.0",
     "@aws-sdk/client-s3": ">=3.700.0",
     "@aws-sdk/lib-storage": ">=3.700.0",
     "@daytonaio/sdk": ">=0.153.0",
     "@e2b/code-interpreter": "^2.3.3",
-    "@google/genai": "^1.43.0",
+    "@google/genai": ">=2.5.0",
     "@langchain/core": ">=1.0.0",
     "@temporalio/common": ">=1.16.0 <2.0.0",
     "@temporalio/envconfig": ">=1.16.0 <2.0.0",
     "@temporalio/worker": ">=1.16.0 <2.0.0",
     "@temporalio/workflow": ">=1.16.0 <2.0.0",
-    "ioredis": ">=5.0.0",
-    "just-bash": ">=2.0.0"
+    "redis": ">=4.6.0"
   },
   "peerDependenciesMeta": {
     "@daytonaio/sdk": {
@@ -263,17 +242,11 @@
     },
     "@temporalio/worker": {
       "optional": true
-    },
-    "just-bash": {
-      "optional": true
     }
   },
   "type": "module",
   "bugs": {
     "url": "https://github.com/bead-ai/zeitlich/issues"
   },
-  "homepage": "https://github.com/bead-ai/zeitlich#readme",
-  "dependencies": {
-    "zod": "^4.3.6"
-  }
+  "homepage": "https://github.com/bead-ai/zeitlich#readme"
 }

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

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { PersistedThreadState } from "../../../lib/state/types";

package/src/adapters/thread/anthropic/fork-transform.test.ts

@@ -12,32 +12,32 @@ function createStatefulRedis() {
   const strings = new Map<string, string>();
 
   return {
-    exists: vi.fn(async (...keys: string[]) =>
-      keys.reduce(
+    exists: vi.fn(async (keys: string | string[]) =>
+      (Array.isArray(keys) ? keys : [keys]).reduce(
         (acc, k) => acc + (lists.has(k) || strings.has(k) ? 1 : 0),
         0
       )
     ),
-    lrange: vi.fn(async (key: string, start: number, stop: number) => {
+    lRange: vi.fn(async (key: string, start: number, stop: number) => {
       const list = lists.get(key) ?? [];
       const end = stop === -1 ? list.length : stop + 1;
       return list.slice(start, end);
     }),
-    rpush: vi.fn(async (key: string, ...values: string[]) => {
+    rPush: vi.fn(async (key: string, element: string | string[]) => {
       const list = lists.get(key) ?? [];
-      list.push(...values);
+      list.push(...(Array.isArray(element) ? element : [element]));
       lists.set(key, list);
       return list.length;
     }),
-    ltrim: vi.fn(async (key: string, start: number, stop: number) => {
+    lTrim: vi.fn(async (key: string, start: number, stop: number) => {
       const list = lists.get(key) ?? [];
       const end = stop === -1 ? list.length : stop + 1;
       lists.set(key, list.slice(start, end));
       return "OK";
     }),
-    del: vi.fn(async (...keys: string[]) => {
+    del: vi.fn(async (keys: string | string[]) => {
       let removed = 0;
-      for (const k of keys) {
+      for (const k of Array.isArray(keys) ? keys : [keys]) {
         if (lists.delete(k)) removed++;
         if (strings.delete(k)) removed++;
       }
@@ -49,10 +49,16 @@ function createStatefulRedis() {
     }),
     get: vi.fn(async (key: string) => strings.get(key) ?? null),
     expire: vi.fn(async (_key: string, _ttl: number) => 1),
-    llen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
+    lLen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
     eval: vi.fn(
-      async (_script: string, _numKeys: number, ...args: string[]) => {
-        const [dedupKey, listKey, , ...serialised] = args;
+      async (
+        _script: string,
+        options: { keys?: string[]; arguments?: string[] }
+      ) => {
+        const keys = options.keys ?? [];
+        const argv = options.arguments ?? [];
+        const [dedupKey, listKey] = keys;
+        const serialised = argv.slice(1);
         if (!dedupKey || !listKey) return 0;
         if (strings.has(dedupKey)) return 0;
         const list = lists.get(listKey) ?? [];

package/src/adapters/thread/anthropic/model-invoker.test.ts

@@ -6,11 +6,11 @@ import type { StoredMessage } from "./thread-manager";
 function createMockRedis(stored: StoredMessage[]) {
   return {
     exists: vi.fn().mockResolvedValue(1),
-    lrange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
-    ltrim: vi.fn().mockResolvedValue("OK"),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lTrim: vi.fn().mockResolvedValue("OK"),
     del: vi.fn().mockResolvedValue(1),
     set: vi.fn().mockResolvedValue("OK"),
-    rpush: vi.fn().mockResolvedValue(1),
+    rPush: vi.fn().mockResolvedValue(1),
     expire: vi.fn().mockResolvedValue(1),
     eval: vi.fn().mockResolvedValue(1),
   };
@@ -36,6 +36,7 @@ function createMockClient() {
       output_tokens: 1,
       server_tool_use: null,
       service_tier: null,
+      output_tokens_details: null,
     },
   };
   const stream = {

package/src/adapters/thread/anthropic/model-invoker.ts

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { SerializableToolDefinition } from "../../../lib/types";
 import type { AgentResponse, ModelInvokerConfig } from "../../../lib/model";

package/src/adapters/thread/anthropic/thread-manager.test.ts

@@ -5,10 +5,10 @@ import { createAnthropicThreadManager } from "./thread-manager";
 function createMockRedis(stored: StoredMessage[]) {
   return {
     exists: vi.fn().mockResolvedValue(1),
-    lrange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
     del: vi.fn().mockResolvedValue(1),
     set: vi.fn().mockResolvedValue("OK"),
-    rpush: vi.fn().mockResolvedValue(1),
+    rPush: vi.fn().mockResolvedValue(1),
     expire: vi.fn().mockResolvedValue(1),
     eval: vi.fn().mockResolvedValue(1),
   };

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

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type Anthropic from "@anthropic-ai/sdk";
 import type { JsonValue } from "../../../lib/state/types";
 import { createThreadManager } from "../../../lib/thread/manager";

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

@@ -1,4 +1,4 @@
-import type Redis from "ioredis";
+import type { RedisClientType as Redis } from "redis";
 import type { GoogleGenAI, Content, Part } from "@google/genai";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { PersistedThreadState } from "../../../lib/state/types";

package/src/adapters/thread/google-genai/fork-transform.test.ts

@@ -7,27 +7,27 @@ function createStatefulRedis() {
   const strings = new Map<string, string>();
 
   return {
-    exists: vi.fn(async (...keys: string[]) =>
-      keys.reduce(
+    exists: vi.fn(async (keys: string | string[]) =>
+      (Array.isArray(keys) ? keys : [keys]).reduce(
         (acc, k) => acc + (lists.has(k) || strings.has(k) ? 1 : 0),
         0
       )
     ),
-    lrange: vi.fn(async (key: string, start: number, stop: number) => {
+    lRange: vi.fn(async (key: string, start: number, stop: number) => {
       const list = lists.get(key) ?? [];
       const end = stop === -1 ? list.length : stop + 1;
       return list.slice(start, end);
     }),
-    rpush: vi.fn(async (key: string, ...values: string[]) => {
+    rPush: vi.fn(async (key: string, element: string | string[]) => {
       const list = lists.get(key) ?? [];
-      list.push(...values);
+      list.push(...(Array.isArray(element) ? element : [element]));
       lists.set(key, list);
       return list.length;
     }),
-    ltrim: vi.fn(async () => "OK"),
-    del: vi.fn(async (...keys: string[]) => {
+    lTrim: vi.fn(async () => "OK"),
+    del: vi.fn(async (keys: string | string[]) => {
       let removed = 0;
-      for (const k of keys) {
+      for (const k of Array.isArray(keys) ? keys : [keys]) {
         if (lists.delete(k)) removed++;
         if (strings.delete(k)) removed++;
       }
@@ -39,10 +39,16 @@ function createStatefulRedis() {
     }),
     get: vi.fn(async (key: string) => strings.get(key) ?? null),
     expire: vi.fn(async () => 1),
-    llen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
+    lLen: vi.fn(async (key: string) => (lists.get(key) ?? []).length),
     eval: vi.fn(
-      async (_script: string, _numKeys: number, ...args: string[]) => {
-        const [dedupKey, listKey, , ...serialised] = args;
+      async (
+        _script: string,
+        options: { keys?: string[]; arguments?: string[] }
+      ) => {
+        const keys = options.keys ?? [];
+        const argv = options.arguments ?? [];
+        const [dedupKey, listKey] = keys;
+        const serialised = argv.slice(1);
         if (!dedupKey || !listKey) return 0;
         if (strings.has(dedupKey)) return 0;
         const list = lists.get(listKey) ?? [];

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

@@ -0,0 +1,337 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  FunctionCallingConfigMode,
+  type Content,
+  type GenerateContentResponse,
+  type Part,
+} from "@google/genai";
+import { createGoogleGenAIModelInvoker } from "./model-invoker";
+import type { StoredContent } from "./thread-manager";
+import type { AgentResponse } from "../../../lib/model";
+
+const textReply: Part[] = [{ text: "ok" }];
+
+function createMockRedis(
+  stored: StoredContent[],
+  extra?: Record<string, string>
+) {
+  return {
+    exists: vi.fn().mockResolvedValue(1),
+    lrange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    get: vi
+      .fn()
+      .mockImplementation((key: string) =>
+        Promise.resolve(extra?.[key] ?? null)
+      ),
+    del: vi.fn().mockResolvedValue(1),
+    set: vi.fn().mockResolvedValue("OK"),
+    rpush: vi.fn().mockResolvedValue(1),
+    expire: vi.fn().mockResolvedValue(1),
+    eval: vi.fn().mockResolvedValue(1),
+  };
+}
+
+function createMockClient(parts: Part[] = textReply) {
+  const chunk: Partial<GenerateContentResponse> = {
+    candidates: [{ content: { role: "model", parts } }],
+    usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 5 },
+  };
+  return {
+    models: {
+      generateContentStream: vi.fn().mockResolvedValue({
+        async *[Symbol.asyncIterator]() {
+          yield chunk;
+        },
+      }),
+    },
+    caches: {
+      create: vi.fn().mockResolvedValue({ name: "cached-content-ref" }),
+    },
+  };
+}
+
+const defaultStored: StoredContent[] = [
+  {
+    id: "msg-1",
+    content: { role: "user", parts: [{ text: "classify these files" }] },
+  },
+];
+
+const invokerConfig = {
+  threadId: "thread-1",
+  assistantMessageId: "assistant-1",
+  state: { tools: [] } as never,
+  agentName: "TestAgent",
+};
+
+function invoke(parts: Part[]): Promise<AgentResponse<Content>> {
+  const redis = createMockRedis(defaultStored);
+  const client = createMockClient(parts);
+
+  const invoker = createGoogleGenAIModelInvoker({
+    redis: redis as never,
+    client: client as never,
+    model: "gemini-2.5-flash",
+  });
+
+  return invoker(invokerConfig);
+}
+
+describe("Google GenAI model invoker — function call IDs", () => {
+  it("assigns synthetic IDs when Gemini omits them", async () => {
+    const result = await invoke([
+      { functionCall: { name: "classifyFile", args: { index: 0 } } },
+      { functionCall: { name: "classifyFile", args: { index: 1 } } },
+    ]);
+
+    expect(result.rawToolCalls).toHaveLength(2);
+    for (const tc of result.rawToolCalls) {
+      expect(tc.id).toBeDefined();
+      expect(tc.id).not.toBe("");
+    }
+  });
+
+  it("preserves existing IDs from Gemini when present", async () => {
+    const result = await invoke([
+      {
+        functionCall: {
+          id: "gemini-abc123",
+          name: "lookupFile",
+          args: { path: "/a" },
+        },
+      },
+    ]);
+
+    expect(result.rawToolCalls[0]?.id).toBe("gemini-abc123");
+  });
+
+  it("generates unique IDs across multiple function calls", async () => {
+    const parts: Part[] = Array.from({ length: 5 }, (_, i) => ({
+      functionCall: { name: "inspect", args: { index: i } },
+    }));
+
+    const result = await invoke(parts);
+
+    const ids = result.rawToolCalls.map((tc) => tc.id);
+    expect(new Set(ids).size).toBe(5);
+  });
+
+  it("matches IDs between message parts and rawToolCalls", async () => {
+    const result = await invoke([
+      { functionCall: { name: "toolA", args: {} } },
+      { functionCall: { name: "toolB", args: {} } },
+    ]);
+
+    const partIds = result.message.parts
+      ?.filter((p) => p.functionCall)
+      .map((p) => p.functionCall?.id);
+    const rawIds = result.rawToolCalls.map((tc) => tc.id);
+
+    expect(partIds).toEqual(rawIds);
+  });
+
+  it("handles a mix of parts with and without existing IDs", async () => {
+    const result = await invoke([
+      { functionCall: { id: "existing-id", name: "toolA", args: {} } },
+      { functionCall: { name: "toolB", args: {} } },
+      { text: "some reasoning text" },
+    ]);
+
+    expect(result.rawToolCalls).toHaveLength(2);
+    expect(result.rawToolCalls[0]?.id).toBe("existing-id");
+    expect(result.rawToolCalls[1]?.id).toBeDefined();
+    expect(result.rawToolCalls[1]?.id).not.toBe("");
+    expect(result.rawToolCalls[1]?.id).not.toBe("existing-id");
+  });
+});
+
+describe("Google GenAI model invoker — context caching", () => {
+  const multiMessageThread: StoredContent[] = [
+    {
+      id: "msg-1",
+      content: {
+        role: "user",
+        parts: [{ inlineData: { data: "base64img", mimeType: "image/png" } }],
+      },
+    },
+    {
+      id: "msg-2",
+      content: { role: "model", parts: [{ text: "I see the image" }] },
+    },
+    {
+      id: "msg-3",
+      content: { role: "user", parts: [{ text: "classify it" }] },
+    },
+  ];
+
+  it("creates a cache and sends only live contents when contents exceed splitIndex", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1 },
+    });
+
+    await invoker(invokerConfig);
+
+    expect(client.caches.create).toHaveBeenCalledOnce();
+    const cacheCall = client.caches.create.mock.calls[0]?.[0];
+    expect(cacheCall.model).toBe("gemini-2.5-flash");
+    expect(cacheCall.config.contents).toHaveLength(1);
+    expect(cacheCall.config.ttl).toBe("300s");
+
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.contents).toHaveLength(2);
+    expect(streamCall.config.cachedContent).toBe("cached-content-ref");
+    expect(streamCall.config.systemInstruction).toBeUndefined();
+    expect(streamCall.config.tools).toBeUndefined();
+  });
+
+  it("skips caching when contents.length <= splitIndex", async () => {
+    const redis = createMockRedis(defaultStored);
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1 },
+    });
+
+    await invoker(invokerConfig);
+
+    expect(client.caches.create).not.toHaveBeenCalled();
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.contents).toHaveLength(1);
+    expect(streamCall.config.cachedContent).toBeUndefined();
+  });
+
+  it("uses custom TTL", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1, ttlSeconds: 600 },
+    });
+
+    await invoker(invokerConfig);
+
+    const cacheCall = client.caches.create.mock.calls[0]?.[0];
+    expect(cacheCall.config.ttl).toBe("600s");
+  });
+
+  it("moves toolConfig into cache and clears it from live request", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+
+    const toolConfig = {
+      functionCallingConfig: { mode: FunctionCallingConfigMode.ANY },
+    };
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1 },
+      config: { toolConfig },
+    });
+
+    await invoker(invokerConfig);
+
+    const cacheCall = client.caches.create.mock.calls[0]?.[0];
+    expect(cacheCall.config.toolConfig).toEqual(toolConfig);
+
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.config.toolConfig).toBeUndefined();
+  });
+
+  it("skips caching when splitIndex is 0", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 0 },
+    });
+
+    await invoker(invokerConfig);
+
+    expect(client.caches.create).not.toHaveBeenCalled();
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.config.cachedContent).toBeUndefined();
+  });
+
+  it("reuses cached content name from Redis instead of creating a new cache", async () => {
+    const redis = createMockRedis(multiMessageThread, {
+      "messages:gemini-cache:gemini-2.5-flash:1:thread:thread-1":
+        "cachedContents/existing",
+    });
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1 },
+    });
+
+    await invoker(invokerConfig);
+
+    expect(client.caches.create).not.toHaveBeenCalled();
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.config.cachedContent).toBe("cachedContents/existing");
+    expect(streamCall.contents).toHaveLength(2);
+  });
+
+  it("stores cache name in Redis after creation", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1, ttlSeconds: 600 },
+    });
+
+    await invoker(invokerConfig);
+
+    expect(client.caches.create).toHaveBeenCalledOnce();
+    const setCall = redis.set.mock.calls.find(
+      (c: string[]) =>
+        c[0] === "messages:gemini-cache:gemini-2.5-flash:1:thread:thread-1"
+    );
+    expect(setCall).toBeDefined();
+    expect(setCall?.[1]).toBe("cached-content-ref");
+    expect(setCall?.[2]).toBe("EX");
+    expect(setCall?.[3]).toBe(595);
+  });
+
+  it("reports cachedWriteTokens from cache creation", async () => {
+    const redis = createMockRedis(multiMessageThread);
+    const client = createMockClient();
+    client.caches.create.mockResolvedValue({
+      name: "cached-content-ref",
+      usageMetadata: { totalTokenCount: 4200 },
+    });
+
+    const invoker = createGoogleGenAIModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      cache: { splitIndex: 1 },
+    });
+
+    const result = await invoker(invokerConfig);
+
+    expect(result.usage?.cachedWriteTokens).toBe(4200);
+  });
+});