zeitlich 0.2.50 → 0.2.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.50",
+  "version": "0.2.53",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -181,7 +181,7 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.100.1",
+    "@anthropic-ai/sdk": "^0.102.0",
     "@aws-sdk/client-s3": "^3.1000.0",
     "@aws-sdk/lib-storage": "^3.1000.0",
     "@daytonaio/sdk": "^0.184.0",

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

@@ -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/model-invoker.test.ts

@@ -2,6 +2,7 @@ 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 {
@@ -109,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

@@ -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.ts

@@ -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;
 }

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

@@ -0,0 +1,162 @@
+import { describe, expect, it, vi } from "vitest";
+import type { GenerateContentResponse, Part } from "@google/genai";
+import { createGoogleGenAIAdapter } from "./activities";
+import type { StoredContent } from "./thread-manager";
+import { THREAD_TTL_SECONDS } from "../../../lib/thread/keys";
+
+function createMockRedis(stored: StoredContent[]) {
+  return {
+    exists: vi.fn().mockResolvedValue(1),
+    lRange: vi.fn().mockResolvedValue(stored.map((m) => JSON.stringify(m))),
+    lTrim: vi.fn().mockResolvedValue("OK"),
+    get: vi.fn().mockResolvedValue(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[] = [{ text: "ok" }]) {
+  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" }),
+    },
+  };
+}
+
+// Tail stored under the `assistantMessageId`, so the invoker's
+// `truncateFromId` trims it and re-stamps the surviving list key's TTL.
+const retriedThread: StoredContent[] = [
+  { id: "msg-1", content: { role: "user", parts: [{ text: "hi" }] } },
+  { id: "assistant-1", content: { role: "model", parts: [{ text: "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("createGoogleGenAIAdapter — TTL propagation", () => {
+  it("forwards adapter ttlSeconds to a created invoker's writes", async () => {
+    const redis = createMockRedis(retriedThread);
+    const client = createMockClient();
+    const adapter = createGoogleGenAIAdapter({
+      redis: redis as never,
+      ttlSeconds: 3600,
+    });
+
+    await adapter.createModelInvoker(
+      "gemini-2.5-flash",
+      client as never
+    )(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+    expect(redis.expire).not.toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+
+  it("forwards adapter ttlSeconds to the default invoker", async () => {
+    const redis = createMockRedis(retriedThread);
+    const client = createMockClient();
+    const adapter = createGoogleGenAIAdapter({
+      redis: redis as never,
+      client: client as never,
+      model: "gemini-2.5-flash",
+      ttlSeconds: 3600,
+    });
+
+    await adapter.invoker(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, 3600);
+  });
+
+  it("forwards adapter ttlSeconds to thread-op writes", async () => {
+    const redis = createMockRedis([]);
+    const adapter = createGoogleGenAIAdapter({
+      redis: redis 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 = createGoogleGenAIAdapter({ redis: redis as never });
+
+    await adapter.createModelInvoker(
+      "gemini-2.5-flash",
+      client as never
+    )(invokerCall);
+
+    expect(redis.expire).toHaveBeenCalledWith(listKey, THREAD_TTL_SECONDS);
+  });
+});
+
+describe("createGoogleGenAIAdapter — cache/config forwarding", () => {
+  it("forwards adapter cache config to the invoker", async () => {
+    const multiThread: StoredContent[] = [
+      { id: "m1", content: { role: "user", parts: [{ text: "a" }] } },
+      { id: "m2", content: { role: "model", parts: [{ text: "b" }] } },
+      { id: "m3", content: { role: "user", parts: [{ text: "c" }] } },
+    ];
+    const redis = createMockRedis(multiThread);
+    const client = createMockClient();
+    const adapter = createGoogleGenAIAdapter({
+      redis: redis as never,
+      cache: { splitIndex: 1 },
+    });
+
+    await adapter.createModelInvoker(
+      "gemini-2.5-flash",
+      client as never
+    )(invokerCall);
+
+    expect(client.caches.create).toHaveBeenCalledOnce();
+  });
+
+  it("forwards adapter generationConfig to generateContentStream", async () => {
+    const redis = createMockRedis([
+      { id: "m1", content: { role: "user", parts: [{ text: "a" }] } },
+    ]);
+    const client = createMockClient();
+    const adapter = createGoogleGenAIAdapter({
+      redis: redis as never,
+      generationConfig: { temperature: 0.5 },
+    });
+
+    await adapter.createModelInvoker(
+      "gemini-2.5-flash",
+      client as never
+    )(invokerCall);
+
+    const streamCall = client.models.generateContentStream.mock.calls[0]?.[0];
+    expect(streamCall.config.temperature).toBe(0.5);
+  });
+});

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

@@ -1,5 +1,10 @@
 import type { RedisClientType as Redis } from "redis";
-import type { GoogleGenAI, Content, Part } from "@google/genai";
+import type {
+  GoogleGenAI,
+  Content,
+  Part,
+  GenerateContentConfig,
+} from "@google/genai";
 import type { ToolResultConfig } from "../../../lib/types";
 import type { PersistedThreadState } from "../../../lib/state/types";
 import type {
@@ -23,7 +28,10 @@ import {
   type GoogleGenAIThreadManagerHooks,
   type StoredContent,
 } from "./thread-manager";
-import { createGoogleGenAIModelInvoker } from "./model-invoker";
+import {
+  createGoogleGenAIModelInvoker,
+  type GoogleGenAIModelInvokerConfig,
+} from "./model-invoker";
 import { ADAPTER_ID } from "./adapter-id";
 
 export type GoogleGenAIThreadOps<TScope extends string = ""> =
@@ -46,11 +54,22 @@ export interface GoogleGenAIAdapterConfig {
    */
   coldStore?: ColdThreadStore;
   /**
-   * Override the default Redis TTL (90 days). 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;
+  /**
+   * Default generation config forwarded to every invoker the adapter
+   * builds (`invoker` and `createModelInvoker`). `systemInstruction`,
+   * `tools`, and `abortSignal` are managed by the invoker and override
+   * any values set here.
+   */
+  generationConfig?: GenerateContentConfig;
+  /**
+   * Default server-side context caching config forwarded to every
+   * invoker the adapter builds. See {@link createGoogleGenAIModelInvoker}.
+   */
+  cache?: GoogleGenAIModelInvokerConfig["cache"];
 }
 
 /**
@@ -145,7 +164,7 @@ export interface GoogleGenAIAdapter {
  *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
  *     ...createRunAgentActivity(
  *       temporalClient,
- *       adapter.createModelInvoker('gemini-2.5-pro'),
+ *       adapter.createModelInvoker('gemini-2.5-pro', client),
  *       "researchAgent",
  *     ),
  *   };
@@ -157,25 +176,26 @@ export function createGoogleGenAIAdapter(
 ): GoogleGenAIAdapter {
   const { redis } = config;
 
-  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) =>
     createGoogleGenAIThreadManager({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
-      ...baseExtras,
     });
 
   const makeTieredBase = (threadId: string, threadKey?: string) =>
     createTieredThreadManager<StoredContent>({
-      redis,
+      ...base,
       threadId,
       key: threadKey,
       idOf: storedContentId,
-      ...baseExtras,
       ...(config.coldStore && { coldStore: config.coldStore }),
     });
 
@@ -235,11 +255,10 @@ export function createGoogleGenAIAdapter(
       threadKey?: string
     ): Promise<void> {
       const thread = createGoogleGenAIThreadManager({
-        redis,
+        ...base,
         threadId: sourceThreadId,
         key: threadKey,
         hooks: config.hooks,
-        ...baseExtras,
       });
       await thread.fork(targetThreadId);
     },
@@ -304,10 +323,14 @@ export function createGoogleGenAIAdapter(
     client: GoogleGenAI
   ): ModelInvoker<Content> =>
     createGoogleGenAIModelInvoker({
-      redis,
+      ...base,
       client,
       model,
       hooks: config.hooks,
+      ...(config.generationConfig !== undefined && {
+        config: config.generationConfig,
+      }),
+      ...(config.cache !== undefined && { cache: config.cache }),
     });
 
   const invoker: ModelInvoker<Content> =