@tanstack/ai-gemini 0.10.2 → 0.10.4

package/dist/esm/message-types.d.ts

@@ -89,3 +89,16 @@ export interface GeminiMessageMetadataByModality {
     video: GeminiVideoMetadata;
     document: GeminiDocumentMetadata;
 }
+/**
+ * Provider-specific metadata that round-trips with each Gemini tool call.
+ *
+ * `thoughtSignature` is emitted by Gemini 3.x (and 2.5 thinking) models on
+ * the Part containing the `functionCall`. The same signature must be echoed
+ * back at the Part level on the next turn or the API rejects the request
+ * with `400 INVALID_ARGUMENT: "Function call is missing a thought_signature"`.
+ *
+ * @see https://ai.google.dev/gemini-api/docs/thinking
+ */
+export interface GeminiToolCallMetadata {
+    thoughtSignature?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-gemini",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Google Gemini adapter for TanStack AI",
   "author": "",
   "license": "MIT",
@@ -38,13 +38,13 @@
     "@tanstack/ai-utils": "0.2.0"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.15.0"
+    "@tanstack/ai": "^0.17.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "vite": "^7.2.7",
     "zod": "^4.2.0",
-    "@tanstack/ai": "0.15.0"
+    "@tanstack/ai": "0.17.0"
   },
   "scripts": {
     "build": "vite build",

package/src/adapters/summarize.ts

@@ -1,274 +1,59 @@
-import { FinishReason } from '@google/genai'
-import {
-  createGeminiClient,
-  generateId,
-  getGeminiApiKeyFromEnv,
-} from '../utils'
-import type { GoogleGenAI } from '@google/genai'
+import { ChatStreamSummarizeAdapter } from '@tanstack/ai/adapters'
+import { getGeminiApiKeyFromEnv } from '../utils'
+import { GeminiTextAdapter } from './text'
+import type { InferTextProviderOptions } from '@tanstack/ai/adapters'
+import type { GEMINI_MODELS } from '../model-meta'
 import type { GeminiClientConfig } from '../utils'
-import type { SummarizeAdapter } from '@tanstack/ai/adapters'
-import type {
-  StreamChunk,
-  SummarizationOptions,
-  SummarizationResult,
-} from '@tanstack/ai'
-
-/** Cast an event object to StreamChunk. */
-const asChunk = (chunk: Record<string, unknown>) =>
-  chunk as unknown as StreamChunk
 
 /**
  * Configuration for Gemini summarize adapter
  */
 export interface GeminiSummarizeConfig extends GeminiClientConfig {}
-/**
- * Available Gemini models for summarization
- */
-export const GeminiSummarizeModels = [
-  'gemini-3.1-flash-lite-preview',
-  'gemini-2.0-flash',
-  'gemini-1.5-flash',
-  'gemini-1.5-pro',
-  'gemini-2.0-flash-lite',
-] as const
-
-export type GeminiSummarizeModel = (typeof GeminiSummarizeModels)[number]
-
-/**
- * Provider-specific options for Gemini summarization
- */
-export interface GeminiSummarizeProviderOptions {
-  /** Generation configuration */
-  generationConfig?: {
-    temperature?: number
-    topP?: number
-    topK?: number
-    maxOutputTokens?: number
-    stopSequences?: Array<string>
-  }
-  /** Safety settings */
-  safetySettings?: Array<{
-    category: string
-    threshold: string
-  }>
-}
-
-export interface GeminiSummarizeAdapterOptions {
-  // Additional adapter options can be added here
-}
-
-/**
- * Gemini Summarize Adapter
- * A tree-shakeable summarization adapter for Google Gemini
- */
-export class GeminiSummarizeAdapter<
-  TModel extends GeminiSummarizeModel,
-> implements SummarizeAdapter<TModel, GeminiSummarizeProviderOptions> {
-  readonly kind = 'summarize' as const
-  readonly name = 'gemini' as const
-  readonly model: TModel
-
-  // Type-only property - never assigned at runtime
-  declare '~types': {
-    providerOptions: GeminiSummarizeProviderOptions
-  }
-
-  private client: GoogleGenAI
-
-  constructor(config: GeminiSummarizeConfig, model: TModel) {
-    this.client = createGeminiClient(config)
-    this.model = model
-  }
 
-  async summarize(options: SummarizationOptions): Promise<SummarizationResult> {
-    const { logger } = options
-    const model = options.model
-
-    logger.request(`activity=summarize provider=gemini`, {
-      provider: 'gemini',
-      model,
-    })
-
-    // Build the system prompt based on format
-    const formatInstructions = this.getFormatInstructions(options.style)
-    const lengthInstructions = options.maxLength
-      ? ` Keep the summary under ${options.maxLength} tokens.`
-      : ''
-
-    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`
-
-    try {
-      const response = await this.client.models.generateContent({
-        model,
-        contents: [
-          {
-            role: 'user',
-            parts: [
-              { text: `Please summarize the following:\n\n${options.text}` },
-            ],
-          },
-        ],
-        config: {
-          systemInstruction: systemPrompt,
-        },
-      })
-
-      const summary = response.text ?? ''
-      const inputTokens = response.usageMetadata?.promptTokenCount ?? 0
-      const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0
-
-      return {
-        id: generateId('sum'),
-        model,
-        summary,
-        usage: {
-          promptTokens: inputTokens,
-          completionTokens: outputTokens,
-          totalTokens: inputTokens + outputTokens,
-        },
-      }
-    } catch (error) {
-      logger.errors('gemini.summarize fatal', {
-        error,
-        source: 'gemini.summarize',
-      })
-      throw error
-    }
-  }
-
-  async *summarizeStream(
-    options: SummarizationOptions,
-  ): AsyncIterable<StreamChunk> {
-    const { logger } = options
-    const model = options.model
-    const id = generateId('sum')
-    let accumulatedContent = ''
-    let inputTokens = 0
-    let outputTokens = 0
-
-    // Build the system prompt based on format
-    const formatInstructions = this.getFormatInstructions(options.style)
-    const lengthInstructions = options.maxLength
-      ? ` Keep the summary under ${options.maxLength} words.`
-      : ''
-
-    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`
-
-    logger.request(`activity=summarize provider=gemini`, {
-      provider: 'gemini',
-      model,
-      stream: true,
-    })
-
-    try {
-      const result = await this.client.models.generateContentStream({
-        model,
-        contents: [
-          {
-            role: 'user',
-            parts: [
-              { text: `Please summarize the following:\n\n${options.text}` },
-            ],
-          },
-        ],
-        config: {
-          systemInstruction: systemPrompt,
-        },
-      })
-
-      for await (const chunk of result) {
-        logger.provider(`provider=gemini`, { chunk })
-        // Track usage metadata
-        if (chunk.usageMetadata) {
-          inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens
-          outputTokens =
-            chunk.usageMetadata.candidatesTokenCount ?? outputTokens
-        }
-
-        if (chunk.candidates?.[0]?.content?.parts) {
-          for (const part of chunk.candidates[0].content.parts) {
-            if (part.text) {
-              accumulatedContent += part.text
-              yield asChunk({
-                type: 'TEXT_MESSAGE_CONTENT',
-                messageId: id,
-                model,
-                timestamp: Date.now(),
-                delta: part.text,
-                content: accumulatedContent,
-              })
-            }
-          }
-        }
-
-        // Check for finish reason
-        const finishReason = chunk.candidates?.[0]?.finishReason
-        if (
-          finishReason === FinishReason.STOP ||
-          finishReason === FinishReason.MAX_TOKENS ||
-          finishReason === FinishReason.SAFETY
-        ) {
-          yield asChunk({
-            type: 'RUN_FINISHED',
-            runId: id,
-            model,
-            timestamp: Date.now(),
-            finishReason:
-              finishReason === FinishReason.STOP
-                ? 'stop'
-                : finishReason === FinishReason.MAX_TOKENS
-                  ? 'length'
-                  : 'content_filter',
-            usage: {
-              promptTokens: inputTokens,
-              completionTokens: outputTokens,
-              totalTokens: inputTokens + outputTokens,
-            },
-          })
-        }
-      }
-    } catch (error) {
-      logger.errors('gemini.summarize fatal', {
-        error,
-        source: 'gemini.summarize',
-      })
-      throw error
-    }
-  }
-
-  private getFormatInstructions(
-    style?: 'paragraph' | 'bullet-points' | 'concise',
-  ): string {
-    switch (style) {
-      case 'bullet-points':
-        return 'Provide the summary as bullet points.'
-      case 'concise':
-        return 'Provide a very brief one or two sentence summary.'
-      case 'paragraph':
-      default:
-        return 'Provide the summary in paragraph form.'
-    }
-  }
-}
+export type GeminiSummarizeModel = (typeof GEMINI_MODELS)[number]
 
 /**
- * Creates a Gemini summarize adapter with explicit API key and model
+ * Creates a Gemini summarize adapter with explicit API key and model.
+ *
+ * Note: keeps the historical (apiKey, model, config) argument order to
+ * avoid breaking existing callers.
+ *
+ * @example
+ * ```typescript
+ * const adapter = createGeminiSummarize('AIza...', 'gemini-2.0-flash');
+ * ```
  */
 export function createGeminiSummarize<TModel extends GeminiSummarizeModel>(
   apiKey: string,
   model: TModel,
   config?: Omit<GeminiSummarizeConfig, 'apiKey'>,
-): GeminiSummarizeAdapter<TModel> {
-  return new GeminiSummarizeAdapter({ ...config, apiKey }, model)
+): ChatStreamSummarizeAdapter<
+  TModel,
+  InferTextProviderOptions<GeminiTextAdapter<TModel>>
+> {
+  return new ChatStreamSummarizeAdapter(
+    new GeminiTextAdapter({ ...config, apiKey }, model),
+    model,
+    'gemini',
+  )
 }
 
 /**
- * Creates a Gemini summarize adapter with API key from environment and required model
+ * Creates a Gemini summarize adapter with API key from `GOOGLE_API_KEY` /
+ * `GEMINI_API_KEY` environment variables.
+ *
+ * @example
+ * ```typescript
+ * const adapter = geminiSummarize('gemini-2.0-flash');
+ * await summarize({ adapter, text: 'Long article text...' });
+ * ```
  */
 export function geminiSummarize<TModel extends GeminiSummarizeModel>(
   model: TModel,
   config?: Omit<GeminiSummarizeConfig, 'apiKey'>,
-): GeminiSummarizeAdapter<TModel> {
-  const apiKey = getGeminiApiKeyFromEnv()
-  return new GeminiSummarizeAdapter({ ...config, apiKey }, model)
+): ChatStreamSummarizeAdapter<
+  TModel,
+  InferTextProviderOptions<GeminiTextAdapter<TModel>>
+> {
+  return createGeminiSummarize(getGeminiApiKeyFromEnv(), model, config)
 }