zeitlich 0.2.49 → 0.2.51

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 Redis from "ioredis";
-import type { GoogleGenAI, Content, Part } from "@google/genai";
+import type { RedisClientType as Redis } from "redis";
+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> =

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) ?? [];