zeitlich 0.2.50 → 0.2.51

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

@@ -1,23 +1,67 @@
-export { A as ADAPTER_ID, a as AdapterId } from '../../../adapter-id-BB-mmrts.cjs';
-import { G as GoogleGenAIThreadManagerHooks } from '../../../activities-cIlq1y1y.cjs';
-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-cIlq1y1y.cjs';
+import { A as ADAPTER_ID } from '../../../adapter-id-BB-mmrts.cjs';
+export { a as AdapterId } from '../../../adapter-id-BB-mmrts.cjs';
 import { RedisClientType } from 'redis';
-import { GoogleGenAI, GenerateContentConfig, Content } from '@google/genai';
-import { M as ModelInvokerConfig, A as AgentResponse } from '../../../types-DZnUqCAP.cjs';
-import '../../../cold-store-C0uvYTSi.cjs';
-import '@aws-sdk/client-s3';
-import '../../../types-d2RvEP6v.cjs';
+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-BjdqxKYp.cjs';
+import { C as ColdThreadStore } from '../../../cold-store-YOx9nmgR.cjs';
+import { T as ThreadManagerHooks, P as ProviderThreadManager } from '../../../types-N_LTWe4b.cjs';
 import '@temporalio/workflow';
 import '@temporalio/common/lib/interfaces';
 import 'zod';
 import '../../../types-D8W5TnSa.cjs';
 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: 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. */
@@ -50,15 +94,141 @@ interface GoogleGenAIModelInvokerConfig {
  * return { ...createRunAgentActivity(client, invoker, "myAgent") };
  * ```
  */
-declare function createGoogleGenAIModelInvoker({ redis, client, model, hooks, config: generationConfig, cache: cacheConfig, }: GoogleGenAIModelInvokerConfig): (config: ModelInvokerConfig) => Promise<AgentResponse<Content>>;
-declare function invokeGoogleGenAIModel({ redis, client, model, hooks, config, generationConfig, cache, }: {
+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.d.ts

@@ -1,23 +1,67 @@
-export { A as ADAPTER_ID, a as AdapterId } from '../../../adapter-id-BB-mmrts.js';
-import { G as GoogleGenAIThreadManagerHooks } from '../../../activities-IuOIvPHO.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-IuOIvPHO.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 { GoogleGenAI, GenerateContentConfig, Content } from '@google/genai';
-import { M as ModelInvokerConfig, A as AgentResponse } from '../../../types-YNesmGKV.js';
-import '../../../cold-store-CCnZYWjx.js';
-import '@aws-sdk/client-s3';
-import '../../../types-CbPnU4RM.js';
+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-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: 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. */
@@ -50,15 +94,141 @@ interface GoogleGenAIModelInvokerConfig {
  * return { ...createRunAgentActivity(client, invoker, "myAgent") };
  * ```
  */
-declare function createGoogleGenAIModelInvoker({ redis, client, model, hooks, config: generationConfig, cache: cacheConfig, }: GoogleGenAIModelInvokerConfig): (config: ModelInvokerConfig) => Promise<AgentResponse<Content>>;
-declare function invokeGoogleGenAIModel({ redis, client, model, hooks, config, generationConfig, cache, }: {
+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

@@ -434,6 +434,7 @@ function createGoogleGenAIModelInvoker({
   client,
   model,
   hooks,
+  ttlSeconds,
   config: generationConfig,
   cache: cacheConfig
 }) {
@@ -444,7 +445,8 @@ function createGoogleGenAIModelInvoker({
       redis,
       threadId,
       key: threadKey,
-      hooks
+      hooks,
+      ...ttlSeconds !== void 0 && { ttlSeconds }
     });
     await thread.truncateFromId(assistantMessageId);
     const { contents, systemInstruction } = await thread.prepareForInvocation();
@@ -544,6 +546,7 @@ async function invokeGoogleGenAIModel({
   client,
   model,
   hooks,
+  ttlSeconds,
   config,
   generationConfig,
   cache
@@ -553,6 +556,7 @@ async function invokeGoogleGenAIModel({
     client,
     model,
     hooks,
+    ...ttlSeconds !== void 0 && { ttlSeconds },
     config: generationConfig,
     cache
   });
@@ -562,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 = {
@@ -608,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);
     },
@@ -645,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(