@tanstack/ai-gemini 0.8.8 → 0.9.0

package/dist/esm/tools/index.js

@@ -0,0 +1,21 @@
+import { codeExecutionTool } from "./code-execution-tool.js";
+import { computerUseTool } from "./computer-use-tool.js";
+import { fileSearchTool } from "./file-search-tool.js";
+import { functionDeclarationTools } from "./function-declaration-tool.js";
+import { googleMapsTool } from "./google-maps-tool.js";
+import { googleSearchRetrievalTool } from "./google-search-retriveal-tool.js";
+import { googleSearchTool } from "./google-search-tool.js";
+import { urlContextTool } from "./url-context-tool.js";
+import { convertToolsToProviderFormat } from "./tool-converter.js";
+export {
+  codeExecutionTool,
+  computerUseTool,
+  convertToolsToProviderFormat,
+  fileSearchTool,
+  functionDeclarationTools,
+  googleMapsTool,
+  googleSearchRetrievalTool,
+  googleSearchTool,
+  urlContextTool
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/esm/tools/url-context-tool.d.ts

@@ -1,7 +1,10 @@
-import { Tool } from '@tanstack/ai';
-export interface UrlContextTool {
+import { ProviderTool, Tool } from '@tanstack/ai';
+export interface UrlContextToolConfig {
 }
+/** @deprecated Renamed to `UrlContextToolConfig`. Will be removed in a future release. */
+export type UrlContextTool = UrlContextToolConfig;
+export type GeminiUrlContextTool = ProviderTool<'gemini', 'url_context'>;
 export declare function convertUrlContextToolToAdapterFormat(_tool: Tool): {
     urlContext: {};
 };
-export declare function urlContextTool(): Tool;
+export declare function urlContextTool(): GeminiUrlContextTool;

package/dist/esm/tools/url-context-tool.js

@@ -3,7 +3,15 @@ function convertUrlContextToolToAdapterFormat(_tool) {
     urlContext: {}
   };
 }
+function urlContextTool() {
+  return {
+    name: "url_context",
+    description: "",
+    metadata: {}
+  };
+}
 export {
-  convertUrlContextToolToAdapterFormat
+  convertUrlContextToolToAdapterFormat,
+  urlContextTool
 };
 //# sourceMappingURL=url-context-tool.js.map

package/dist/esm/tools/url-context-tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"url-context-tool.js","sources":["../../../src/tools/url-context-tool.ts"],"sourcesContent":["import type { Tool } from '@tanstack/ai'\n\nexport interface UrlContextTool {}\n\nexport function convertUrlContextToolToAdapterFormat(_tool: Tool) {\n  return {\n    urlContext: {},\n  }\n}\n\nexport function urlContextTool(): Tool {\n  return {\n    name: 'url_context',\n    description: '',\n    metadata: {},\n  }\n}\n"],"names":[],"mappings":"AAIO,SAAS,qCAAqC,OAAa;AAChE,SAAO;AAAA,IACL,YAAY,CAAA;AAAA,EAAC;AAEjB;"}
+{"version":3,"file":"url-context-tool.js","sources":["../../../src/tools/url-context-tool.ts"],"sourcesContent":["import type { ProviderTool, Tool } from '@tanstack/ai'\n\nexport interface UrlContextToolConfig {}\n\n/** @deprecated Renamed to `UrlContextToolConfig`. Will be removed in a future release. */\nexport type UrlContextTool = UrlContextToolConfig\n\nexport type GeminiUrlContextTool = ProviderTool<'gemini', 'url_context'>\n\nexport function convertUrlContextToolToAdapterFormat(_tool: Tool) {\n  return {\n    urlContext: {},\n  }\n}\n\nexport function urlContextTool(): GeminiUrlContextTool {\n  // Phantom-brand cast: '~provider'/'~toolKind' are type-only and never assigned at runtime.\n  return {\n    name: 'url_context',\n    description: '',\n    metadata: {},\n  } as unknown as GeminiUrlContextTool\n}\n"],"names":[],"mappings":"AASO,SAAS,qCAAqC,OAAa;AAChE,SAAO;AAAA,IACL,YAAY,CAAA;AAAA,EAAC;AAEjB;AAEO,SAAS,iBAAuC;AAErD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,aAAa;AAAA,IACb,UAAU,CAAA;AAAA,EAAC;AAEf;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/ai-gemini",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "description": "Google Gemini adapter for TanStack AI",
   "author": "",
   "license": "MIT",
@@ -16,6 +16,10 @@
     ".": {
       "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js"
+    },
+    "./tools": {
+      "types": "./dist/esm/tools/index.d.ts",
+      "import": "./dist/esm/tools/index.js"
     }
   },
   "files": [
@@ -33,12 +37,13 @@
     "@google/genai": "^1.43.0"
   },
   "peerDependencies": {
-    "@tanstack/ai": "^0.10.3"
+    "@tanstack/ai": "^0.12.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.14",
     "vite": "^7.2.7",
-    "@tanstack/ai": "0.10.3"
+    "zod": "^4.2.0",
+    "@tanstack/ai": "0.12.0"
   },
   "scripts": {
     "build": "vite build",

package/src/adapters/summarize.ts

@@ -13,6 +13,10 @@ import type {
   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
  */
@@ -161,14 +165,14 @@ export class GeminiSummarizeAdapter<
         for (const part of chunk.candidates[0].content.parts) {
           if (part.text) {
             accumulatedContent += part.text
-            yield {
+            yield asChunk({
               type: 'TEXT_MESSAGE_CONTENT',
               messageId: id,
               model,
               timestamp: Date.now(),
               delta: part.text,
               content: accumulatedContent,
-            }
+            })
           }
         }
       }
@@ -180,7 +184,7 @@ export class GeminiSummarizeAdapter<
         finishReason === FinishReason.MAX_TOKENS ||
         finishReason === FinishReason.SAFETY
       ) {
-        yield {
+        yield asChunk({
           type: 'RUN_FINISHED',
           runId: id,
           model,
@@ -196,7 +200,7 @@ export class GeminiSummarizeAdapter<
             completionTokens: outputTokens,
             totalTokens: inputTokens + outputTokens,
           },
-        }
+        })
       }
     }
   }

package/src/adapters/text.ts

@@ -9,6 +9,7 @@ import {
 import type {
   GEMINI_MODELS,
   GeminiChatModelProviderOptionsByName,
+  GeminiChatModelToolCapabilitiesByName,
   GeminiModelInputModalitiesByName,
 } from '../model-meta'
 import type {
@@ -34,6 +35,11 @@ import type { ExternalTextProviderOptions } from '../text/text-provider-options'
 import type { GeminiMessageMetadataByModality } from '../message-types'
 import type { GeminiClientConfig } from '../utils'
 
+/** Cast an event object to StreamChunk. Adapters construct events with string
+ *  literal types which are structurally compatible with the EventType enum. */
+const asChunk = (chunk: Record<string, unknown>) =>
+  chunk as unknown as StreamChunk
+
 /**
  * Configuration for Gemini text adapter
  */
@@ -66,6 +72,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
 // ===========================
@@ -78,14 +93,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,20 +124,24 @@ export class GeminiTextAdapter<
       const result =
         await this.client.models.generateContentStream(mappedOptions)
 
-      yield* this.processStreamChunks(result, options.model)
+      yield* this.processStreamChunks(result, options)
     } catch (error) {
       const timestamp = Date.now()
-      yield {
+      yield asChunk({
         type: 'RUN_ERROR',
         model: options.model,
         timestamp,
+        message:
+          error instanceof Error
+            ? error.message
+            : 'An unknown error occurred during the chat stream.',
         error: {
           message:
             error instanceof Error
               ? error.message
               : 'An unknown error occurred during the chat stream.',
         },
-      }
+      })
     }
   }
 
@@ -191,8 +213,9 @@ export class GeminiTextAdapter<
 
   private async *processStreamChunks(
     result: AsyncGenerator<GenerateContentResponse, unknown, unknown>,
-    model: string,
+    options: TextOptions<GeminiTextProviderOptions>,
   ): AsyncIterable<StreamChunk> {
+    const model = options.model
     const timestamp = Date.now()
     let accumulatedContent = ''
     let accumulatedThinking = ''
@@ -209,9 +232,12 @@ export class GeminiTextAdapter<
     let nextToolIndex = 0
 
     // AG-UI lifecycle tracking
-    const runId = generateId(this.name)
+    const runId = options.runId ?? generateId(this.name)
+    const threadId = options.threadId ?? generateId(this.name)
     const messageId = generateId(this.name)
     let stepId: string | null = null
+    let reasoningMessageId: string | null = null
+    let hasClosedReasoning = false
     let hasEmittedRunStarted = false
     let hasEmittedTextMessageStart = false
     let hasEmittedStepStarted = false
@@ -220,12 +246,13 @@ export class GeminiTextAdapter<
       // Emit RUN_STARTED on first chunk
       if (!hasEmittedRunStarted) {
         hasEmittedRunStarted = true
-        yield {
+        yield asChunk({
           type: 'RUN_STARTED',
           runId,
+          threadId,
           model,
           timestamp,
-        }
+        })
       }
 
       if (chunk.candidates?.[0]?.content?.parts) {
@@ -234,51 +261,99 @@ export class GeminiTextAdapter<
         for (const part of parts) {
           if (part.text) {
             if (part.thought) {
-              // Emit STEP_STARTED on first thinking content
+              // Emit STEP_STARTED and REASONING events on first thinking content
               if (!hasEmittedStepStarted) {
                 hasEmittedStepStarted = true
                 stepId = generateId(this.name)
-                yield {
+                reasoningMessageId = generateId(this.name)
+
+                // Spec REASONING events
+                yield asChunk({
+                  type: 'REASONING_START',
+                  messageId: reasoningMessageId,
+                  model,
+                  timestamp,
+                })
+                yield asChunk({
+                  type: 'REASONING_MESSAGE_START',
+                  messageId: reasoningMessageId,
+                  role: 'reasoning' as const,
+                  model,
+                  timestamp,
+                })
+
+                // Legacy STEP events (kept during transition)
+                yield asChunk({
                   type: 'STEP_STARTED',
+                  stepName: stepId,
                   stepId,
                   model,
                   timestamp,
                   stepType: 'thinking',
-                }
+                })
               }
 
               accumulatedThinking += part.text
-              yield {
+
+              // Spec REASONING content event
+              yield asChunk({
+                type: 'REASONING_MESSAGE_CONTENT',
+                messageId: reasoningMessageId!,
+                delta: part.text,
+                model,
+                timestamp,
+              })
+
+              // Legacy STEP event
+              yield asChunk({
                 type: 'STEP_FINISHED',
+                stepName: stepId || generateId(this.name),
                 stepId: stepId || generateId(this.name),
                 model,
                 timestamp,
                 delta: part.text,
                 content: accumulatedThinking,
-              }
+              })
             } else if (part.text.trim()) {
+              // Close reasoning before text starts
+              if (reasoningMessageId && !hasClosedReasoning) {
+                hasClosedReasoning = true
+                yield asChunk({
+                  type: 'REASONING_MESSAGE_END',
+                  messageId: reasoningMessageId,
+                  model,
+                  timestamp,
+                })
+                yield asChunk({
+                  type: 'REASONING_END',
+                  messageId: reasoningMessageId,
+                  model,
+                  timestamp,
+                })
+              }
+
               // Skip whitespace-only text parts (e.g. "\n" during auto-continuation)
               // Emit TEXT_MESSAGE_START on first text content
               if (!hasEmittedTextMessageStart) {
                 hasEmittedTextMessageStart = true
-                yield {
+                yield asChunk({
                   type: 'TEXT_MESSAGE_START',
                   messageId,
                   model,
                   timestamp,
                   role: 'assistant',
-                }
+                })
               }
 
               accumulatedContent += part.text
-              yield {
+              yield asChunk({
                 type: 'TEXT_MESSAGE_CONTENT',
                 messageId,
                 model,
                 timestamp,
                 delta: part.text,
                 content: accumulatedContent,
-              }
+              })
             }
           }
 
@@ -323,9 +398,10 @@ export class GeminiTextAdapter<
             // Emit TOOL_CALL_START if not already started
             if (!toolCallData.started) {
               toolCallData.started = true
-              yield {
+              yield asChunk({
                 type: 'TOOL_CALL_START',
                 toolCallId,
+                toolCallName: toolCallData.name,
                 toolName: toolCallData.name,
                 model,
                 timestamp,
@@ -335,18 +411,18 @@ export class GeminiTextAdapter<
                     thoughtSignature: toolCallData.thoughtSignature,
                   },
                 }),
-              }
+              })
             }
 
             // Emit TOOL_CALL_ARGS
-            yield {
+            yield asChunk({
               type: 'TOOL_CALL_ARGS',
               toolCallId,
               model,
               timestamp,
               delta: toolCallData.args,
               args: toolCallData.args,
-            }
+            })
           }
         }
       } else if (chunk.data && chunk.data.trim()) {
@@ -354,24 +430,24 @@ export class GeminiTextAdapter<
         // Emit TEXT_MESSAGE_START on first text content
         if (!hasEmittedTextMessageStart) {
           hasEmittedTextMessageStart = true
-          yield {
+          yield asChunk({
             type: 'TEXT_MESSAGE_START',
             messageId,
             model,
             timestamp,
             role: 'assistant',
-          }
+          })
         }
 
         accumulatedContent += chunk.data
-        yield {
+        yield asChunk({
           type: 'TEXT_MESSAGE_CONTENT',
           messageId,
           model,
           timestamp,
           delta: chunk.data,
           content: accumulatedContent,
-        }
+        })
       }
 
       if (chunk.candidates?.[0]?.finishReason) {
@@ -400,14 +476,15 @@ export class GeminiTextAdapter<
                 })
 
                 // Emit TOOL_CALL_START
-                yield {
+                yield asChunk({
                   type: 'TOOL_CALL_START',
                   toolCallId,
+                  toolCallName: functionCall.name || '',
                   toolName: functionCall.name || '',
                   model,
                   timestamp,
                   index: nextToolIndex - 1,
-                }
+                })
 
                 // Emit TOOL_CALL_END with parsed input
                 let parsedInput: unknown = {}
@@ -422,14 +499,15 @@ export class GeminiTextAdapter<
                   parsedInput = {}
                 }
 
-                yield {
+                yield asChunk({
                   type: 'TOOL_CALL_END',
                   toolCallId,
+                  toolCallName: functionCall.name || '',
                   toolName: functionCall.name || '',
                   model,
                   timestamp,
                   input: parsedInput,
-                }
+                })
               }
             }
           }
@@ -445,14 +523,15 @@ export class GeminiTextAdapter<
             parsedInput = {}
           }
 
-          yield {
+          yield asChunk({
             type: 'TOOL_CALL_END',
             toolCallId,
+            toolCallName: toolCallData.name,
             toolName: toolCallData.name,
             model,
             timestamp,
             input: parsedInput,
-          }
+          })
         }
 
         // Reset so a new TEXT_MESSAGE_START is emitted if text follows tool calls
@@ -461,32 +540,53 @@ export class GeminiTextAdapter<
         }
 
         if (finishReason === FinishReason.MAX_TOKENS) {
-          yield {
+          yield asChunk({
             type: 'RUN_ERROR',
             runId,
             model,
             timestamp,
+            message:
+              'The response was cut off because the maximum token limit was reached.',
+            code: 'max_tokens',
             error: {
               message:
                 'The response was cut off because the maximum token limit was reached.',
               code: 'max_tokens',
             },
-          }
+          })
+        }
+
+        // Close reasoning events if still open
+        if (reasoningMessageId && !hasClosedReasoning) {
+          hasClosedReasoning = true
+          yield asChunk({
+            type: 'REASONING_MESSAGE_END',
+            messageId: reasoningMessageId,
+            model,
+            timestamp,
+          })
+          yield asChunk({
+            type: 'REASONING_END',
+            messageId: reasoningMessageId,
+            model,
+            timestamp,
+          })
         }
 
         // Emit TEXT_MESSAGE_END if we had text content
         if (hasEmittedTextMessageStart) {
-          yield {
+          yield asChunk({
             type: 'TEXT_MESSAGE_END',
             messageId,
             model,
             timestamp,
-          }
+          })
         }
 
-        yield {
+        yield asChunk({
           type: 'RUN_FINISHED',
           runId,
+          threadId,
           model,
           timestamp,
           finishReason: toolCallMap.size > 0 ? 'tool_calls' : 'stop',
@@ -497,7 +597,7 @@ export class GeminiTextAdapter<
                 totalTokens: chunk.usageMetadata.totalTokenCount ?? 0,
               }
             : undefined,
-        }
+        })
       }
     }
   }
@@ -723,7 +823,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)
 }
@@ -738,7 +839,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/index.ts

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