zeitlich 0.2.49 → 0.2.51

package/dist/adapters/thread/google-genai/index.d.ts

@@ -1,31 +1,82 @@
-export { A as ADAPTER_ID, a as AdapterId } from '../../../adapter-id-BB-mmrts.js';
-import { G as GoogleGenAIThreadManagerHooks } from '../../../activities-zG_FBoY2.js';
-export { a as GoogleGenAIAdapter, b as GoogleGenAIAdapterConfig, c as GoogleGenAIContent, d as GoogleGenAIInvocationPayload, e as GoogleGenAIThreadManager, f as GoogleGenAIThreadManagerConfig, g as GoogleGenAIThreadOps, h as GoogleGenAIToolResponse, S as StoredContent, i as createGoogleGenAIAdapter, j as createGoogleGenAIThreadManager } from '../../../activities-zG_FBoY2.js';
-import Redis from 'ioredis';
-import { GoogleGenAI, Content } from '@google/genai';
-import { M as ModelInvokerConfig, A as AgentResponse } from '../../../types-DeVNWqlb.js';
-import '../../../cold-store-DKMAO1Dd.js';
-import '@aws-sdk/client-s3';
-import '../../../types-DO4Tkwxo.js';
+import { A as ADAPTER_ID } from '../../../adapter-id-BB-mmrts.js';
+export { a as AdapterId } from '../../../adapter-id-BB-mmrts.js';
+import { RedisClientType } from 'redis';
+import { Part, Content, GoogleGenAI, GenerateContentConfig } from '@google/genai';
+import { c as ModelInvokerConfig, d as AgentResponse, M as ModelInvoker, a as PrefixedThreadOps, S as ScopedPrefix, R as RouterContext, b as ToolHandlerResponse, A as ActivityToolHandler } from '../../../types-DiI7mZhI.js';
+import { C as ColdThreadStore } from '../../../cold-store-DyHodfAB.js';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from '../../../types-DEbkLA06.js';
 import '@temporalio/workflow';
 import '@temporalio/common/lib/interfaces';
 import 'zod';
-import '../../../types-CJ7tCdl6.js';
+import '../../../types-D8W5TnSa.js';
 import '@temporalio/common';
+import '@aws-sdk/client-s3';
+
+/** SDK-native content type for Google GenAI human messages */
+type GoogleGenAIContent = string | Part[];
+/** SDK-native content type for Google GenAI system instructions */
+type GoogleGenAISystemContent = string | Part[];
+/** A Content with a unique ID for idempotent Redis storage */
+interface StoredContent {
+    id: string;
+    content: Content;
+}
+type GoogleGenAIThreadManagerHooks = ThreadManagerHooks<StoredContent, Content>;
+interface GoogleGenAIThreadManagerConfig {
+    redis: RedisClientType;
+    threadId: string;
+    /** Thread key, defaults to 'messages' */
+    key?: string;
+    hooks?: GoogleGenAIThreadManagerHooks;
+    /**
+     * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+     * value (hours) with a cold tier.
+     */
+    ttlSeconds?: number;
+}
+/** Prepared payload ready to send to the Google GenAI API */
+interface GoogleGenAIInvocationPayload {
+    contents: Content[];
+    systemInstruction?: Part[];
+}
+/** Thread manager with Google GenAI Content convenience helpers */
+interface GoogleGenAIThreadManager extends ProviderThreadManager<StoredContent, GoogleGenAIContent, GoogleGenAIToolResponse, GoogleGenAISystemContent> {
+    appendModelContent(id: string, parts: Part[]): Promise<void>;
+    prepareForInvocation(): Promise<GoogleGenAIInvocationPayload>;
+}
+/**
+ * Creates a Google GenAI-specific thread manager that stores StoredContent
+ * instances in Redis and provides convenience helpers for creating and
+ * appending typed Content messages.
+ */
+declare function createGoogleGenAIThreadManager(config: GoogleGenAIThreadManagerConfig): GoogleGenAIThreadManager;
 
 interface GoogleGenAIModelInvokerConfig {
-    redis: Redis;
+    redis: RedisClientType;
     client: GoogleGenAI;
     model: string;
     hooks?: GoogleGenAIThreadManagerHooks;
+    /**
+     * Redis TTL for the thread's keys; defaults to 90 days. Use a shorter
+     * value (hours) with a cold tier. Distinct from `cache.ttlSeconds`
+     * (server-side context caching).
+     */
+    ttlSeconds?: number;
+    /** Passed through to `generateContentStream().config`.
+     *  `systemInstruction`, `tools`, and `abortSignal` are managed by the
+     *  invoker and will override any values set here. */
+    config?: GenerateContentConfig;
+    /** Caches the first `splitIndex` messages server-side (with
+     *  `systemInstruction`, `tools`, and `toolConfig`). Skipped when
+     *  `contents.length <= splitIndex`. */
+    cache?: {
+        splitIndex: number;
+        /** Default: 300. */
+        ttlSeconds?: number;
+    };
 }
 /**
- * Creates a Google GenAI model invoker that satisfies the generic
- * `ModelInvoker<Content>` contract.
- *
- * Internally streams the response and emits Temporal heartbeats on each
- * chunk so that long-running LLM calls remain visible to the scheduler.
- * The caller is responsible for appending the response to the thread.
+ * The caller is responsible for appending the returned response to the thread.
  *
  * @example
  * ```typescript
@@ -43,18 +94,141 @@ interface GoogleGenAIModelInvokerConfig {
  * return { ...createRunAgentActivity(client, invoker, "myAgent") };
  * ```
  */
-declare function createGoogleGenAIModelInvoker({ redis, client, model, hooks, }: GoogleGenAIModelInvokerConfig): (config: ModelInvokerConfig) => Promise<AgentResponse<Content>>;
-/**
- * Standalone function for one-shot Google GenAI model invocation.
- * Convenience wrapper around createGoogleGenAIModelInvoker for cases
- * where you don't need to reuse the invoker.
- */
-declare function invokeGoogleGenAIModel({ redis, client, model, hooks, config, }: {
-    redis: Redis;
+declare function createGoogleGenAIModelInvoker({ redis, client, model, hooks, ttlSeconds, config: generationConfig, cache: cacheConfig, }: GoogleGenAIModelInvokerConfig): (config: ModelInvokerConfig) => Promise<AgentResponse<Content>>;
+declare function invokeGoogleGenAIModel({ redis, client, model, hooks, ttlSeconds, config, generationConfig, cache, }: {
+    redis: RedisClientType;
     client: GoogleGenAI;
     model: string;
     hooks?: GoogleGenAIThreadManagerHooks;
+    ttlSeconds?: number;
     config: ModelInvokerConfig;
+    generationConfig?: GenerateContentConfig;
+    cache?: GoogleGenAIModelInvokerConfig["cache"];
 }): Promise<AgentResponse<Content>>;
 
-export { type GoogleGenAIModelInvokerConfig, createGoogleGenAIModelInvoker, invokeGoogleGenAIModel };
+type GoogleGenAIThreadOps<TScope extends string = ""> = PrefixedThreadOps<ScopedPrefix<TScope, typeof ADAPTER_ID>, GoogleGenAIContent>;
+interface GoogleGenAIAdapterConfig {
+    redis: RedisClientType;
+    client?: GoogleGenAI;
+    /** Default model name (e.g. 'gemini-2.5-flash'). If omitted, use `createModelInvoker()` */
+    model?: string;
+    hooks?: GoogleGenAIThreadManagerHooks;
+    /**
+     * Optional durable cold tier (e.g. S3, R2, GCS). When provided,
+     * the session hydrates the thread on entry (`continue`/`fork`) and
+     * flushes it on every exit path. When omitted, the adapter is
+     * Redis-only and `hydrateThread`/`flushThread` activities are no-ops.
+     */
+    coldStore?: ColdThreadStore;
+    /**
+     * 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"];
+}
+/**
+ * Tool response type accepted by the Google GenAI adapter.
+ *
+ * Handlers can return:
+ * - **`string`** — plain text, wrapped in a `functionResponse` part.
+ * - **`Record<string, unknown>`** — structured object used as `functionResponse.response`.
+ * - **`Part[]`** — pre-built parts used directly as `Content.parts`.
+ *   The handler is responsible for building correct Part objects (e.g. `functionResponse`,
+ *   `inlineData`, `text`). Use `context.toolCallId` and `context.toolName` to construct
+ *   `functionResponse` parts.
+ *
+ * @example
+ * ```typescript
+ * adapter.wrapHandler(async (args, ctx) => ({
+ *   toolResponse: [
+ *     { functionResponse: { id: ctx.toolCallId, name: ctx.toolName, response: { result: "done" } } },
+ *     { inlineData: { data: base64, mimeType: "image/png" } },
+ *   ],
+ *   data: null,
+ * }));
+ * ```
+ */
+type GoogleGenAIToolResponse = string | Record<string, unknown> | Part[];
+interface GoogleGenAIAdapter {
+    /** Model invoker using the default model (only available when `model` was provided) */
+    invoker: ModelInvoker<Content>;
+    /** Create an invoker for a specific model name (for multi-model setups) */
+    createModelInvoker(model: string, client: GoogleGenAI): ModelInvoker<Content>;
+    /**
+     * Create prefixed thread activities for registration on the worker.
+     *
+     * @param scope - Workflow name appended to the adapter prefix.
+     *   Use different scopes for the main agent vs subagents to avoid collisions.
+     *
+     * @example
+     * ```typescript
+     * adapter.createActivities("codingAgent")
+     * // → { googleGenAICodingAgentInitializeThread, googleGenAICodingAgentAppendHumanMessage, … }
+     *
+     * adapter.createActivities("researchAgent")
+     * // → { googleGenAIResearchAgentInitializeThread, … }
+     * ```
+     */
+    createActivities<S extends string = "">(scope?: S): GoogleGenAIThreadOps<S>;
+    /**
+     * Identity wrapper that types a tool handler for this adapter.
+     * Constrains `toolResponse` to {@link GoogleGenAIToolResponse}.
+     */
+    wrapHandler<TArgs, TResult, TContext extends RouterContext = RouterContext>(handler: (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult, GoogleGenAIToolResponse>>): ActivityToolHandler<TArgs, TResult, TContext, GoogleGenAIToolResponse>;
+}
+/**
+ * Creates a Google GenAI adapter that bundles thread operations and model
+ * invocation using the `@google/genai` SDK.
+ *
+ * Use `createActivities(scope)` to register scoped thread operations as
+ * Temporal activities on the worker. The `invoker` (or invokers created via
+ * `createModelInvoker`) should be wrapped with `createRunAgentActivity`.
+ *
+ * @example
+ * ```typescript
+ * import { createGoogleGenAIAdapter } from 'zeitlich/adapters/thread/google-genai';
+ * import { createRunAgentActivity } from 'zeitlich';
+ * import { GoogleGenAI } from '@google/genai';
+ *
+ * const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+ * const adapter = createGoogleGenAIAdapter({ redis, client, model: 'gemini-2.5-flash' });
+ *
+ * export function createActivities(temporalClient: WorkflowClient) {
+ *   return {
+ *     ...adapter.createActivities("codingAgent"),
+ *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
+ *   };
+ * }
+ * ```
+ *
+ * @example Multi-agent worker (main + subagent share the adapter)
+ * ```typescript
+ * export function createActivities(temporalClient: WorkflowClient) {
+ *   return {
+ *     ...adapter.createActivities("codingAgent"),
+ *     ...adapter.createActivities("researchAgent"),
+ *     ...createRunAgentActivity(temporalClient, adapter.invoker, "codingAgent"),
+ *     ...createRunAgentActivity(
+ *       temporalClient,
+ *       adapter.createModelInvoker('gemini-2.5-pro', client),
+ *       "researchAgent",
+ *     ),
+ *   };
+ * }
+ * ```
+ */
+declare function createGoogleGenAIAdapter(config: GoogleGenAIAdapterConfig): GoogleGenAIAdapter;
+
+export { ADAPTER_ID, type GoogleGenAIAdapter, type GoogleGenAIAdapterConfig, type GoogleGenAIContent, type GoogleGenAIInvocationPayload, type GoogleGenAIModelInvokerConfig, type GoogleGenAIThreadManager, type GoogleGenAIThreadManagerConfig, type GoogleGenAIThreadOps, type GoogleGenAIToolResponse, type StoredContent, createGoogleGenAIAdapter, createGoogleGenAIModelInvoker, createGoogleGenAIThreadManager, invokeGoogleGenAIModel };

package/dist/adapters/thread/google-genai/index.js

@@ -1,3 +1,4 @@
+import { randomBytes } from 'crypto';
 import { Context } from '@temporalio/activity';
 
 // src/adapters/thread/google-genai/adapter-id.ts
@@ -53,11 +54,11 @@ function createThreadManager(config) {
   return {
     async initialize() {
       await redis.del(redisKey);
-      await redis.set(metaKey, "1", "EX", ttlSeconds);
+      await redis.set(metaKey, "1", { EX: ttlSeconds });
     },
     async load() {
       await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       return data.map(deserialize);
     },
     async append(messages) {
@@ -65,22 +66,18 @@ function createThreadManager(config) {
       await assertThreadExists();
       if (idOf) {
         const dedupId = messages.map(idOf).join(":");
-        await redis.eval(
-          APPEND_IDEMPOTENT_SCRIPT,
-          2,
-          dedupKey(dedupId),
-          redisKey,
-          String(ttlSeconds),
-          ...messages.map(serialize)
-        );
+        await redis.eval(APPEND_IDEMPOTENT_SCRIPT, {
+          keys: [dedupKey(dedupId), redisKey],
+          arguments: [String(ttlSeconds), ...messages.map(serialize)]
+        });
       } else {
-        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.rPush(redisKey, messages.map(serialize));
         await redis.expire(redisKey, ttlSeconds);
       }
     },
     async fork(newThreadId) {
       await assertThreadExists();
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       const stateRaw = await redis.get(stateKey);
       const forked = createThreadManager({
         ...config,
@@ -89,12 +86,12 @@ function createThreadManager(config) {
       await forked.initialize();
       if (data.length > 0) {
         const newKey = getThreadListKey(key, newThreadId);
-        await redis.rpush(newKey, ...data);
+        await redis.rPush(newKey, data);
         await redis.expire(newKey, ttlSeconds);
       }
       if (stateRaw != null) {
         const newStateKey = getThreadStateKey(key, newThreadId);
-        await redis.set(newStateKey, stateRaw, "EX", ttlSeconds);
+        await redis.set(newStateKey, stateRaw, { EX: ttlSeconds });
       }
       return forked;
     },
@@ -105,20 +102,20 @@ function createThreadManager(config) {
           "replaceAll requires the thread manager to be configured with `idOf`"
         );
       }
-      const existing = await redis.lrange(redisKey, 0, -1);
+      const existing = await redis.lRange(redisKey, 0, -1);
       const existingIds = existing.map((raw) => idOf(deserialize(raw))).filter((id) => typeof id === "string");
       await redis.del(redisKey);
       if (existingIds.length > 0) {
-        await redis.del(...existingIds.map(dedupKey));
+        await redis.del(existingIds.map(dedupKey));
       }
       if (messages.length > 0) {
-        await redis.rpush(redisKey, ...messages.map(serialize));
+        await redis.rPush(redisKey, messages.map(serialize));
         await redis.expire(redisKey, ttlSeconds);
       }
       await redis.expire(metaKey, ttlSeconds);
     },
     async delete() {
-      await redis.del(redisKey, metaKey, stateKey);
+      await redis.del([redisKey, metaKey, stateKey]);
     },
     async loadState() {
       const raw = await redis.get(stateKey);
@@ -127,14 +124,14 @@ function createThreadManager(config) {
     },
     async saveState(state) {
       await assertThreadExists();
-      await redis.set(stateKey, JSON.stringify(state), "EX", ttlSeconds);
+      await redis.set(stateKey, JSON.stringify(state), { EX: ttlSeconds });
     },
     async deleteState() {
       await redis.del(stateKey);
     },
     async length() {
       await assertThreadExists();
-      return redis.llen(redisKey);
+      return redis.lLen(redisKey);
     },
     async truncateFromId(messageId) {
       await assertThreadExists();
@@ -143,7 +140,7 @@ function createThreadManager(config) {
           "truncateFromId requires the thread manager to be configured with `idOf`"
         );
       }
-      const data = await redis.lrange(redisKey, 0, -1);
+      const data = await redis.lRange(redisKey, 0, -1);
       let idx = -1;
       const removedIds = [];
       for (let i = 0; i < data.length; i++) {
@@ -158,11 +155,11 @@ function createThreadManager(config) {
         await redis.del(redisKey);
         await redis.expire(metaKey, ttlSeconds);
       } else {
-        await redis.ltrim(redisKey, 0, idx - 1);
+        await redis.lTrim(redisKey, 0, idx - 1);
         await redis.expire(redisKey, ttlSeconds);
       }
       if (removedIds.length > 0) {
-        await redis.del(...removedIds.map(dedupKey));
+        await redis.del(removedIds.map(dedupKey));
       }
     }
   };
@@ -177,7 +174,7 @@ async function encodeSnapshot(config) {
   }
   const listKey = getThreadListKey(threadKey, threadId);
   const stateKey = getThreadStateKey(threadKey, threadId);
-  const messages = await redis.lrange(listKey, 0, -1);
+  const messages = await redis.lRange(listKey, 0, -1);
   const stateRaw = await redis.get(stateKey);
   const state = stateRaw == null ? null : JSON.parse(stateRaw);
   const dedupIds = idOf ? messages.map(idOf) : [];
@@ -197,31 +194,38 @@ async function applySnapshot(config) {
   }
   const listKey = getThreadListKey(threadKey, threadId);
   const stateKey = getThreadStateKey(threadKey, threadId);
-  await redis.del(listKey, stateKey);
-  const pipeline = redis.pipeline();
+  await redis.del([listKey, stateKey]);
+  const pipeline = redis.multi();
   if (snapshot.messages.length > 0) {
-    pipeline.rpush(listKey, ...snapshot.messages);
+    pipeline.rPush(listKey, snapshot.messages);
     pipeline.expire(listKey, ttlSeconds);
   }
   if (snapshot.state != null) {
-    pipeline.set(stateKey, JSON.stringify(snapshot.state), "EX", ttlSeconds);
+    pipeline.set(stateKey, JSON.stringify(snapshot.state), { EX: ttlSeconds });
   }
   for (const id of snapshot.dedupIds) {
-    pipeline.set(getThreadDedupKey(threadId, id), "1", "EX", ttlSeconds);
+    pipeline.set(getThreadDedupKey(threadId, id), "1", { EX: ttlSeconds });
   }
-  const results = await pipeline.exec();
-  if (results) {
-    const firstErr = results.find(([err]) => err)?.[0] ?? null;
-    if (firstErr) {
-      await redis.del(
-        listKey,
-        stateKey,
-        ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
-      ).catch(() => void 0);
-      throw firstErr;
-    }
+  try {
+    await pipeline.execAsPipeline();
+  } catch (err) {
+    await redis.del([
+      listKey,
+      stateKey,
+      ...snapshot.dedupIds.map((id) => getThreadDedupKey(threadId, id))
+    ]).catch(() => void 0);
+    throw firstPipelineError(err);
+  }
+  await redis.set(metaKey, "1", { EX: ttlSeconds });
+}
+function firstPipelineError(err) {
+  if (err != null && typeof err === "object" && "replies" in err && Array.isArray(err.replies)) {
+    const firstErr = err.replies.find(
+      (r) => r instanceof Error
+    );
+    if (firstErr) return firstErr;
   }
-  await redis.set(metaKey, "1", "EX", ttlSeconds);
+  return err;
 }
 async function clearHotTier(config) {
   const { redis, threadKey, threadId, dedupIds = [] } = config;
@@ -231,7 +235,7 @@ async function clearHotTier(config) {
     getThreadStateKey(threadKey, threadId),
     ...dedupIds.map((id) => getThreadDedupKey(threadId, id))
   ];
-  await redis.del(...keys);
+  await redis.del(keys);
 }
 
 // src/lib/thread/tiered.ts
@@ -429,7 +433,10 @@ function createGoogleGenAIModelInvoker({
   redis,
   client,
   model,
-  hooks
+  hooks,
+  ttlSeconds,
+  config: generationConfig,
+  cache: cacheConfig
 }) {
   return async function invokeGoogleGenAIModel2(config) {
     const { threadId, threadKey, state, assistantMessageId } = config;
@@ -438,18 +445,64 @@ function createGoogleGenAIModelInvoker({
       redis,
       threadId,
       key: threadKey,
-      hooks
+      hooks,
+      ...ttlSeconds !== void 0 && { ttlSeconds }
     });
     await thread.truncateFromId(assistantMessageId);
     const { contents, systemInstruction } = await thread.prepareForInvocation();
     const functionDeclarations = toFunctionDeclarations(state.tools);
     const tools = functionDeclarations.length > 0 ? [{ functionDeclarations }] : void 0;
+    const {
+      systemInstruction: _si,
+      tools: _t,
+      abortSignal: _as,
+      cachedContent: callerCachedContent,
+      toolConfig: callerToolConfig,
+      ...callerConfig
+    } = generationConfig ?? {};
+    let liveContents = contents;
+    let cachedContentName;
+    let cachedWriteTokens;
+    if (cacheConfig && cacheConfig.splitIndex > 0 && contents.length > cacheConfig.splitIndex) {
+      liveContents = contents.slice(cacheConfig.splitIndex);
+      const ttl = cacheConfig.ttlSeconds ?? 300;
+      const cacheRedisKey = `${threadKey ?? "messages"}:gemini-cache:${model}:${cacheConfig.splitIndex}:thread:${threadId}`;
+      cachedContentName = await redis.get(cacheRedisKey) ?? void 0;
+      if (!cachedContentName) {
+        const cacheInstance = await client.caches.create({
+          model,
+          config: {
+            contents: contents.slice(0, cacheConfig.splitIndex),
+            ...systemInstruction ? { systemInstruction } : {},
+            ...tools ? { tools } : {},
+            ...callerToolConfig ? { toolConfig: callerToolConfig } : {},
+            ttl: `${ttl}s`,
+            abortSignal: signal
+          }
+        });
+        if (!cacheInstance?.name) {
+          throw new Error("Gemini cache creation did not return a cache name");
+        }
+        cachedContentName = cacheInstance.name;
+        cachedWriteTokens = cacheInstance.usageMetadata?.totalTokenCount ?? void 0;
+        const redisTtl = ttl - 5;
+        if (redisTtl > 0) {
+          await redis.set(cacheRedisKey, cachedContentName, { EX: redisTtl });
+        }
+      }
+    }
     const stream = await client.models.generateContentStream({
       model,
-      contents,
+      contents: liveContents,
       config: {
-        ...systemInstruction ? { systemInstruction } : {},
-        ...tools ? { tools } : {},
+        ...callerConfig,
+        ...cachedContentName ? { cachedContent: cachedContentName } : {
+          ...callerCachedContent ? { cachedContent: callerCachedContent } : {
+            ...systemInstruction ? { systemInstruction } : {},
+            ...tools ? { tools } : {}
+          },
+          ...callerToolConfig ? { toolConfig: callerToolConfig } : {}
+        },
         abortSignal: signal
       }
     });
@@ -463,19 +516,27 @@ function createGoogleGenAIModelInvoker({
     if (!lastChunk) {
       throw new Error("Google GenAI stream ended without producing any chunks");
     }
+    for (const part of allParts) {
+      if (part.functionCall && !part.functionCall.id) {
+        part.functionCall.id = randomBytes(8).toString("hex");
+      }
+    }
     const modelContent = { role: "model", parts: allParts };
-    const functionCalls = lastChunk.functionCalls ?? [];
     return {
       message: modelContent,
-      rawToolCalls: functionCalls.map((fc) => ({
-        id: fc.id,
-        name: fc.name ?? "",
-        args: fc.args ?? {}
+      rawToolCalls: allParts.filter(
+        (p) => !!p.functionCall
+      ).map((p) => ({
+        id: p.functionCall.id,
+        name: p.functionCall.name ?? "",
+        args: p.functionCall.args ?? {}
       })),
       usage: {
         inputTokens: lastChunk.usageMetadata?.promptTokenCount,
         outputTokens: lastChunk.usageMetadata?.candidatesTokenCount,
-        cachedReadTokens: lastChunk.usageMetadata?.cachedContentTokenCount
+        cachedWriteTokens,
+        cachedReadTokens: lastChunk.usageMetadata?.cachedContentTokenCount,
+        reasonTokens: lastChunk.usageMetadata?.thoughtsTokenCount
       }
     };
   };
@@ -485,13 +546,19 @@ async function invokeGoogleGenAIModel({
   client,
   model,
   hooks,
-  config
+  ttlSeconds,
+  config,
+  generationConfig,
+  cache
 }) {
   const invoker = createGoogleGenAIModelInvoker({
     redis,
     client,
     model,
-    hooks
+    hooks,
+    ...ttlSeconds !== void 0 && { ttlSeconds },
+    config: generationConfig,
+    cache
   });
   return invoker(config);
 }
@@ -499,21 +566,20 @@ async function invokeGoogleGenAIModel({
 // src/adapters/thread/google-genai/activities.ts
 function createGoogleGenAIAdapter(config) {
   const { redis } = config;
-  const baseExtras = {
+  const base = {
+    redis,
     ...config.ttlSeconds !== void 0 && { ttlSeconds: config.ttlSeconds }
   };
   const makeProviderThread = (threadId, threadKey) => createGoogleGenAIThreadManager({
-    redis,
+    ...base,
     threadId,
-    key: threadKey,
-    ...baseExtras
+    key: threadKey
   });
   const makeTieredBase = (threadId, threadKey) => createTieredThreadManager({
-    redis,
+    ...base,
     threadId,
     key: threadKey,
     idOf: storedContentId,
-    ...baseExtras,
     ...config.coldStore && { coldStore: config.coldStore }
   });
   const threadOps = {
@@ -545,11 +611,10 @@ function createGoogleGenAIAdapter(config) {
     },
     async forkThread(sourceThreadId, targetThreadId, threadKey) {
       const thread = createGoogleGenAIThreadManager({
-        redis,
+        ...base,
         threadId: sourceThreadId,
         key: threadKey,
-        hooks: config.hooks,
-        ...baseExtras
+        hooks: config.hooks
       });
       await thread.fork(targetThreadId);
     },
@@ -582,10 +647,14 @@ function createGoogleGenAIAdapter(config) {
     );
   }
   const makeInvoker = (model, client) => createGoogleGenAIModelInvoker({
-    redis,
+    ...base,
     client,
     model,
-    hooks: config.hooks
+    hooks: config.hooks,
+    ...config.generationConfig !== void 0 && {
+      config: config.generationConfig
+    },
+    ...config.cache !== void 0 && { cache: config.cache }
   });
   const invoker = config.model && config.client ? makeInvoker(config.model, config.client) : (() => {
     throw new Error(