@tanstack/ai-gemini 0.8.9 → 0.9.1

package/src/adapters/image.ts

@@ -81,27 +81,43 @@ export class GeminiImageAdapter<
   async generateImages(
     options: ImageGenerationOptions<GeminiImageProviderOptions>,
   ): Promise<ImageGenerationResult> {
-    const { model, prompt } = options
+    const { model, prompt, logger } = options
 
-    validatePrompt({ prompt, model })
+    logger.request(
+      `activity=generateImage provider=gemini model=${this.model}`,
+      {
+        provider: 'gemini',
+        model: this.model,
+      },
+    )
 
-    if (this.isGeminiImageModel(model)) {
-      return this.generateWithGeminiApi(options)
-    }
+    try {
+      validatePrompt({ prompt, model })
 
-    // Imagen models path (generateImages API)
-    validateImageSize(model, options.size)
-    validateNumberOfImages(model, options.numberOfImages)
+      if (this.isGeminiImageModel(model)) {
+        return await this.generateWithGeminiApi(options)
+      }
 
-    const config = this.buildImagenConfig(options)
+      // Imagen models path (generateImages API)
+      validateImageSize(model, options.size)
+      validateNumberOfImages(model, options.numberOfImages)
 
-    const response = await this.client.models.generateImages({
-      model,
-      prompt,
-      config,
-    })
+      const config = this.buildImagenConfig(options)
 
-    return this.transformImagenResponse(model, response)
+      const response = await this.client.models.generateImages({
+        model,
+        prompt,
+        config,
+      })
+
+      return this.transformImagenResponse(model, response)
+    } catch (error) {
+      logger.errors('gemini.generateImage fatal', {
+        error,
+        source: 'gemini.generateImage',
+      })
+      throw error
+    }
   }
 
   private isGeminiImageModel(model: string): boolean {

package/src/adapters/summarize.ts

@@ -81,8 +81,14 @@ export class GeminiSummarizeAdapter<
   }
 
   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
@@ -91,40 +97,49 @@ export class GeminiSummarizeAdapter<
 
     const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`
 
-    const response = await this.client.models.generateContent({
-      model,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            { text: `Please summarize the following:\n\n${options.text}` },
-          ],
+    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,
         },
-      ],
-      config: {
-        systemInstruction: systemPrompt,
-      },
-    })
+      })
 
-    const summary = response.text ?? ''
-    const inputTokens = response.usageMetadata?.promptTokenCount ?? 0
-    const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0
+      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,
-      },
+      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 = ''
@@ -139,69 +154,85 @@ export class GeminiSummarizeAdapter<
 
     const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`
 
-    const result = await this.client.models.generateContentStream({
+    logger.request(`activity=summarize provider=gemini`, {
+      provider: 'gemini',
       model,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            { text: `Please summarize the following:\n\n${options.text}` },
-          ],
-        },
-      ],
-      config: {
-        systemInstruction: systemPrompt,
-      },
+      stream: true,
     })
 
-    for await (const chunk of result) {
-      // Track usage metadata
-      if (chunk.usageMetadata) {
-        inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens
-        outputTokens = chunk.usageMetadata.candidatesTokenCount ?? outputTokens
-      }
+    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,
+        },
+      })
 
-      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,
-            })
+      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,
-          },
-        })
+        // 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
     }
   }
 

package/src/adapters/text.ts

@@ -9,12 +9,14 @@ import {
 import type {
   GEMINI_MODELS,
   GeminiChatModelProviderOptionsByName,
+  GeminiChatModelToolCapabilitiesByName,
   GeminiModelInputModalitiesByName,
 } from '../model-meta'
 import type {
   StructuredOutputOptions,
   StructuredOutputResult,
 } from '@tanstack/ai/adapters'
+import type { InternalLogger } from '@tanstack/ai/adapter-internals'
 import type {
   Content,
   GenerateContentParameters,
@@ -71,6 +73,15 @@ type ResolveInputModalities<TModel extends string> =
     ? GeminiModelInputModalitiesByName[TModel]
     : readonly ['text', 'image', 'audio', 'video', 'document']
 
+/**
+ * Resolve tool capabilities for a specific model.
+ * If the model has explicit tools in the map, use those; otherwise use empty tuple.
+ */
+type ResolveToolCapabilities<TModel extends string> =
+  TModel extends keyof GeminiChatModelToolCapabilitiesByName
+    ? NonNullable<GeminiChatModelToolCapabilitiesByName[TModel]>
+    : readonly []
+
 // ===========================
 // Adapter Implementation
 // ===========================
@@ -83,14 +94,17 @@ type ResolveInputModalities<TModel extends string> =
  */
 export class GeminiTextAdapter<
   TModel extends (typeof GEMINI_MODELS)[number],
-  TProviderOptions extends object = ResolveProviderOptions<TModel>,
+  TProviderOptions extends Record<string, any> = ResolveProviderOptions<TModel>,
   TInputModalities extends ReadonlyArray<Modality> =
     ResolveInputModalities<TModel>,
+  TToolCapabilities extends ReadonlyArray<string> =
+    ResolveToolCapabilities<TModel>,
 > extends BaseTextAdapter<
   TModel,
   TProviderOptions,
   TInputModalities,
-  GeminiMessageMetadataByModality
+  GeminiMessageMetadataByModality,
+  TToolCapabilities
 > {
   readonly kind = 'text' as const
   readonly name = 'gemini' as const
@@ -106,14 +120,23 @@ export class GeminiTextAdapter<
     options: TextOptions<GeminiTextProviderOptions>,
   ): AsyncIterable<StreamChunk> {
     const mappedOptions = this.mapCommonOptionsToGemini(options)
+    const { logger } = options
 
     try {
+      logger.request(
+        `activity=chat provider=gemini model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
+        { provider: 'gemini', model: this.model },
+      )
       const result =
         await this.client.models.generateContentStream(mappedOptions)
 
-      yield* this.processStreamChunks(result, options)
+      yield* this.processStreamChunks(result, options, logger)
     } catch (error) {
       const timestamp = Date.now()
+      logger.errors('gemini.chatStream fatal', {
+        error,
+        source: 'gemini.chatStream',
+      })
       yield asChunk({
         type: 'RUN_ERROR',
         model: options.model,
@@ -141,10 +164,15 @@ export class GeminiTextAdapter<
     options: StructuredOutputOptions<GeminiTextProviderOptions>,
   ): Promise<StructuredOutputResult<unknown>> {
     const { chatOptions, outputSchema } = options
+    const { logger } = chatOptions
 
     const mappedOptions = this.mapCommonOptionsToGemini(chatOptions)
 
     try {
+      logger.request(
+        `activity=chat provider=gemini model=${this.model} messages=${chatOptions.messages.length} tools=${chatOptions.tools?.length ?? 0} stream=false`,
+        { provider: 'gemini', model: this.model },
+      )
       // Add structured output configuration
       const result = await this.client.models.generateContent({
         ...mappedOptions,
@@ -173,6 +201,10 @@ export class GeminiTextAdapter<
         rawText,
       }
     } catch (error) {
+      logger.errors('gemini.structuredOutput fatal', {
+        error,
+        source: 'gemini.structuredOutput',
+      })
       throw new Error(
         error instanceof Error
           ? error.message
@@ -201,6 +233,7 @@ export class GeminiTextAdapter<
   private async *processStreamChunks(
     result: AsyncGenerator<GenerateContentResponse, unknown, unknown>,
     options: TextOptions<GeminiTextProviderOptions>,
+    logger: InternalLogger,
   ): AsyncIterable<StreamChunk> {
     const model = options.model
     const timestamp = Date.now()
@@ -230,6 +263,7 @@ export class GeminiTextAdapter<
     let hasEmittedStepStarted = false
 
     for await (const chunk of result) {
+      logger.provider(`provider=gemini`, { chunk })
       // Emit RUN_STARTED on first chunk
       if (!hasEmittedRunStarted) {
         hasEmittedRunStarted = true
@@ -810,7 +844,8 @@ export function createGeminiChat<TModel extends (typeof GEMINI_MODELS)[number]>(
 ): GeminiTextAdapter<
   TModel,
   ResolveProviderOptions<TModel>,
-  ResolveInputModalities<TModel>
+  ResolveInputModalities<TModel>,
+  ResolveToolCapabilities<TModel>
 > {
   return new GeminiTextAdapter({ apiKey, ...config }, model)
 }
@@ -825,7 +860,8 @@ export function geminiText<TModel extends (typeof GEMINI_MODELS)[number]>(
 ): GeminiTextAdapter<
   TModel,
   ResolveProviderOptions<TModel>,
-  ResolveInputModalities<TModel>
+  ResolveInputModalities<TModel>,
+  ResolveToolCapabilities<TModel>
 > {
   const apiKey = getGeminiApiKeyFromEnv()
   return createGeminiChat(model, apiKey, config)

package/src/adapters/tts.ts

@@ -98,63 +98,77 @@ export class GeminiTTSAdapter<
   async generateSpeech(
     options: TTSOptions<GeminiTTSProviderOptions>,
   ): Promise<TTSResult> {
+    const { logger } = options
     const { model, text, modelOptions } = options
 
+    logger.request(`activity=generateSpeech provider=gemini model=${model}`, {
+      provider: 'gemini',
+      model,
+    })
+
     const voiceConfig = modelOptions?.voiceConfig || {
       prebuiltVoiceConfig: {
         voiceName: 'Kore',
       },
     }
 
-    const response = await this.client.models.generateContent({
-      model,
-      contents: [
-        {
-          role: 'user',
-          parts: [{ text }],
+    try {
+      const response = await this.client.models.generateContent({
+        model,
+        contents: [
+          {
+            role: 'user',
+            parts: [{ text }],
+          },
+        ],
+        config: {
+          responseModalities: ['AUDIO'],
+          speechConfig: {
+            voiceConfig,
+            ...(modelOptions?.languageCode && {
+              languageCode: modelOptions.languageCode,
+            }),
+          },
         },
-      ],
-      config: {
-        responseModalities: ['AUDIO'],
-        speechConfig: {
-          voiceConfig,
-          ...(modelOptions?.languageCode && {
-            languageCode: modelOptions.languageCode,
-          }),
-        },
-      },
-      ...(modelOptions?.systemInstruction && {
-        systemInstruction: modelOptions.systemInstruction,
-      }),
-    })
-
-    // Extract audio data from response
-    const candidate = response.candidates?.[0]
-    const parts = candidate?.content?.parts
-
-    if (!parts || parts.length === 0) {
-      throw new Error('No audio output received from Gemini TTS')
-    }
-
-    // Look for inline data (audio)
-    const audioPart = parts.find((part: any) =>
-      part.inlineData?.mimeType?.startsWith('audio/'),
-    )
-
-    if (!audioPart || !audioPart.inlineData || !audioPart.inlineData.data) {
-      throw new Error('No audio data in Gemini TTS response')
-    }
-
-    const audioBase64 = audioPart.inlineData.data
-    const mimeType = audioPart.inlineData.mimeType || 'audio/wav'
-    const format = mimeType.split('/')[1] || 'wav'
-
-    return {
-      id: generateId(this.name),
-      model,
-      audio: audioBase64,
-      format,
-      contentType: mimeType,
+        ...(modelOptions?.systemInstruction && {
+          systemInstruction: modelOptions.systemInstruction,
+        }),
+      })
+
+      // Extract audio data from response
+      const candidate = response.candidates?.[0]
+      const parts = candidate?.content?.parts
+
+      if (!parts || parts.length === 0) {
+        throw new Error('No audio output received from Gemini TTS')
+      }
+
+      // Look for inline data (audio)
+      const audioPart = parts.find((part: any) =>
+        part.inlineData?.mimeType?.startsWith('audio/'),
+      )
+
+      if (!audioPart || !audioPart.inlineData || !audioPart.inlineData.data) {
+        throw new Error('No audio data in Gemini TTS response')
+      }
+
+      const audioBase64 = audioPart.inlineData.data
+      const mimeType = audioPart.inlineData.mimeType || 'audio/wav'
+      const format = mimeType.split('/')[1] || 'wav'
+
+      return {
+        id: generateId(this.name),
+        model,
+        audio: audioBase64,
+        format,
+        contentType: mimeType,
+      }
+    } catch (error) {
+      logger.errors('gemini.generateSpeech fatal', {
+        error,
+        source: 'gemini.generateSpeech',
+      })
+      throw error
     }
   }
 }

package/src/index.ts

@@ -67,6 +67,7 @@ export type { GeminiTTSVoice } from './model-meta'
 
 export type {
   GeminiChatModelProviderOptionsByName,
+  GeminiChatModelToolCapabilitiesByName,
   GeminiModelInputModalitiesByName,
 } from './model-meta'
 export type {