zeitlich 0.2.49 → 0.2.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "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.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it, vi } from "vitest";
+import type Anthropic from "@anthropic-ai/sdk";
+import { createAnthropicAdapter } from "./activities";
+import type { StoredMessage } from "./thread-manager";
+import { THREAD_TTL_SECONDS } from "../../../lib/thread/keys";
+
+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"),
+    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() {
+  const finalMessage: Anthropic.Messages.Message = {
+    id: "msg-response",
+    type: "message",
+    role: "assistant",
+    container: null,
+    model: "claude-test",
+    content: [{ type: "text", text: "ok", citations: null }],
+    stop_details: null,
+    stop_reason: "end_turn",
+    stop_sequence: null,
+    usage: {
+      cache_creation: null,
+      cache_creation_input_tokens: null,
+      cache_read_input_tokens: null,
+      inference_geo: null,
+      input_tokens: 1,
+      output_tokens: 1,
+      server_tool_use: null,
+      service_tier: null,
+      output_tokens_details: null,
+    },
+  };
+  const stream = {
+    async *[Symbol.asyncIterator]() {},
+    finalMessage: vi.fn().mockResolvedValue(finalMessage),
+  };
+  return { messages: { stream: vi.fn().mockReturnValue(stream) } };
+}
+
+// Tail stored under the `assistantMessageId`, so the invoker's
+// `truncateFromId` trims it and re-stamps the surviving list key's TTL.
+const retriedThread: StoredMessage[] = [
+  { id: "msg-1", message: { role: "user", content: "hi" } },
+  { id: "assistant-1", message: { role: "assistant", content: "prior" } },
+];
+const listKey = "messages:thread:thread-1";
+const metaKey = "messages:meta:thread:thread-1";
+const invokerCall = {
+  threadId: "thread-1",
+  assistantMessageId: "assistant-1",
+  state: { tools: [] } as never,
+  agentName: "TestAgent",
+};
+
+describe("createAnthropicAdapter — TTL propagation", () => {
+  it("forwards adapter ttlSeconds to a created invoker's writes", async () => {
+    const redis = createMockRedis(retriedThread);
+    const client = createMockClient();
+    const adapter = createAnthropicAdapter({
+      redis: redis as never,
+      client: client as never,
+      ttlSeconds: 3600,
+    });
+
+    await adapter.createModelInvoker("claude-test")(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+    expect(redis.expire).not.toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+
+  it("forwards adapter ttlSeconds to thread-op writes", async () => {
+    const redis = createMockRedis([]);
+    const client = createMockClient();
+    const adapter = createAnthropicAdapter({
+      redis: redis as never,
+      client: client as never,
+      ttlSeconds: 3600,
+    });
+    const acts = adapter.createActivities() as unknown as Record<
+      string,
+      (threadId: string, threadKey?: string) => Promise<void>
+    >;
+    const initialize = Object.entries(acts).find(([k]) =>
+      k.endsWith("InitializeThread")
+    )?.[1];
+    if (!initialize) throw new Error("initializeThread activity not found");
+
+    await initialize("thread-1");
+
+    expect(redis.set).toHaveBeenCalledWith(metaKey, "1", { EX: 3600 });
+  });
+
+  it("defaults to THREAD_TTL_SECONDS when adapter ttlSeconds is omitted", async () => {
+    const redis = createMockRedis(retriedThread);
+    const client = createMockClient();
+    const adapter = createAnthropicAdapter({
+      redis: redis as never,
+      client: client as never,
+    });
+
+    await adapter.createModelInvoker("claude-test")(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+});

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";
@@ -57,9 +57,8 @@ export interface AnthropicAdapterConfig {
    */
   coldStore?: ColdThreadStore;
   /**
-   * Override the default Redis TTL (90 days) for thread keys. When
-   * pairing the adapter with a `coldStore`, a shorter TTL (hours)
-   * is typically more appropriate.
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
    */
   ttlSeconds?: number;
 }
@@ -160,32 +159,26 @@ export function createAnthropicAdapter(
 ): AnthropicAdapter {
   const { redis, client } = config;
 
-  /**
-   * Common per-call config plumbed into both the provider thread
-   * manager (for message I/O) and the tiered base manager (for
-   * hot↔cold lifecycle ops). Keeping them in lockstep means a single
-   * `coldStore` / `ttlSeconds` configuration controls every Redis
-   * write the adapter does.
-   */
-  const baseExtras = {
+  // Single source for the adapter's `redis` handle and configured TTL, spread
+  // into every internal thread manager so all of them share one configuration.
+  const base = {
+    redis,
     ...(config.ttlSeconds !== undefined && { ttlSeconds: config.ttlSeconds }),
   };
 
   const makeProviderThread = (threadId: string, threadKey?: string) =>
     createAnthropicThreadManager({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
-      ...baseExtras,
     });
 
   const makeTieredBase = (threadId: string, threadKey?: string) =>
     createTieredThreadManager<StoredMessage>({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
       idOf: storedMessageId,
-      ...baseExtras,
       ...(config.coldStore && { coldStore: config.coldStore }),
     });
 
@@ -240,11 +233,10 @@ export function createAnthropicAdapter(
       threadKey?: string
     ): Promise<void> {
       const thread = createAnthropicThreadManager({
-        redis,
+        ...base,
         threadId: sourceThreadId,
         key: threadKey,
         hooks: config.hooks,
-        ...baseExtras,
       });
       await thread.fork(targetThreadId);
     },
@@ -304,7 +296,7 @@ export function createAnthropicAdapter(
     promptCache?: AnthropicPromptCacheConfig
   ): ModelInvoker<Anthropic.Messages.Message> => {
     const invokerConfig: AnthropicModelInvokerConfig = {
-      redis,
+      ...base,
       client,
       model,
       ...(maxTokens !== undefined ? { maxTokens } : {}),

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

@@ -2,15 +2,16 @@ import { describe, expect, it, vi } from "vitest";
 import type Anthropic from "@anthropic-ai/sdk";
 import { createAnthropicModelInvoker } from "./model-invoker";
 import type { StoredMessage } from "./thread-manager";
+import { THREAD_TTL_SECONDS } from "../../../lib/thread/keys";
 
 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 +37,7 @@ function createMockClient() {
       output_tokens: 1,
       server_tool_use: null,
       service_tier: null,
+      output_tokens_details: null,
     },
   };
   const stream = {
@@ -108,3 +110,52 @@ describe("createAnthropicModelInvoker prompt caching", () => {
     expect(params?.messages[0]?.content).toBe("hello");
   });
 });
+
+describe("createAnthropicModelInvoker thread TTL", () => {
+  // The tail message is stored under `assistant-1`, so the invoker's
+  // `truncateFromId(assistant-1)` trims it and re-stamps the surviving
+  // list key's TTL.
+  const retriedThread: StoredMessage[] = [
+    { id: "msg-1", message: { role: "user", content: "hi" } },
+    { id: "assistant-1", message: { role: "assistant", content: "prior" } },
+  ];
+  const listKey = "messages:thread:thread-1";
+  const invokerConfig = {
+    threadId: "thread-1",
+    assistantMessageId: "assistant-1",
+    state: { tools: [] } as never,
+    agentName: "Agent",
+  };
+
+  it("re-stamps trimmed hot keys at the configured ttlSeconds", async () => {
+    const redis = createMockRedis(retriedThread);
+    const { client } = createMockClient();
+    const invoker = createAnthropicModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "claude-test",
+      ttlSeconds: 3600,
+    });
+
+    await invoker(invokerConfig);
+
+    expect(redis.lTrim).toHaveBeenCalledWith(listKey, 0, 0);
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+    expect(redis.expire).not.toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+
+  it("defaults to THREAD_TTL_SECONDS when ttlSeconds is omitted", async () => {
+    const redis = createMockRedis(retriedThread);
+    const { client } = createMockClient();
+    const invoker = createAnthropicModelInvoker({
+      redis: redis as never,
+      client: client as never,
+      model: "claude-test",
+    });
+
+    await invoker(invokerConfig);
+
+    expect(redis.lTrim).toHaveBeenCalledWith(listKey, 0, 0);
+    expect(redis.expire).toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+});

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";
@@ -25,6 +25,11 @@ export interface AnthropicModelInvokerConfig {
    */
   promptCache?: AnthropicPromptCacheConfig;
   hooks?: AnthropicThreadManagerHooks;
+  /**
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
+   */
+  ttlSeconds?: number;
 }
 
 function toAnthropicTools(
@@ -68,6 +73,7 @@ export function createAnthropicModelInvoker({
   maxTokens = 16384,
   promptCache,
   hooks,
+  ttlSeconds,
 }: AnthropicModelInvokerConfig) {
   return async function invokeAnthropicModel(
     config: ModelInvokerConfig
@@ -80,6 +86,7 @@ export function createAnthropicModelInvoker({
       threadId,
       key: threadKey,
       hooks,
+      ...(ttlSeconds !== undefined && { ttlSeconds }),
     });
     // Truncate the thread starting at the id the assistant message
     // will be stored under. On the happy path this is a no-op; on a
@@ -150,6 +157,7 @@ export async function invokeAnthropicModel({
   maxTokens,
   promptCache,
   hooks,
+  ttlSeconds,
   config,
 }: {
   redis: Redis;
@@ -158,6 +166,7 @@ export async function invokeAnthropicModel({
   maxTokens?: number;
   promptCache?: AnthropicPromptCacheConfig;
   hooks?: AnthropicThreadManagerHooks;
+  ttlSeconds?: number;
   config: ModelInvokerConfig;
 }): Promise<AgentResponse<Anthropic.Messages.Message>> {
   const invoker = createAnthropicModelInvoker({
@@ -167,6 +176,7 @@ export async function invokeAnthropicModel({
     maxTokens,
     promptCache,
     hooks,
+    ...(ttlSeconds !== undefined && { ttlSeconds }),
   });
   return invoker(config);
 }

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";
@@ -36,9 +36,8 @@ export interface AnthropicThreadManagerConfig {
   key?: string;
   hooks?: AnthropicThreadManagerHooks;
   /**
-   * Override the default thread TTL (90 days). When pairing the
-   * adapter with a durable cold tier, a shorter TTL (hours) is
-   * typically more appropriate.
+   * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+   * value (hours) with a cold tier.
    */
   ttlSeconds?: number;
 }