@tanstack/ai-gemini 0.10.3 → 0.10.4

package/src/adapters/text.ts

@@ -1,4 +1,5 @@
 import { FinishReason } from '@google/genai'
+import { EventType } from '@tanstack/ai'
 import { BaseTextAdapter } from '@tanstack/ai/adapters'
 import { convertToolsToProviderFormat } from '../tools/tool-converter'
 import {
@@ -39,11 +40,6 @@ import type {
 } 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
  */
@@ -136,15 +132,14 @@ export class GeminiTextAdapter<
 
       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',
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
-        timestamp,
+        timestamp: Date.now(),
         message:
           error instanceof Error
             ? error.message
@@ -155,7 +150,7 @@ export class GeminiTextAdapter<
               ? error.message
               : 'An unknown error occurred during the chat stream.',
         },
-      })
+      }
     }
   }
 
@@ -240,7 +235,6 @@ export class GeminiTextAdapter<
     logger: InternalLogger,
   ): AsyncIterable<StreamChunk> {
     const model = options.model
-    const timestamp = Date.now()
     let accumulatedContent = ''
     let accumulatedThinking = ''
     const toolCallMap = new Map<
@@ -271,13 +265,13 @@ export class GeminiTextAdapter<
       // Emit RUN_STARTED on first chunk
       if (!hasEmittedRunStarted) {
         hasEmittedRunStarted = true
-        yield asChunk({
-          type: 'RUN_STARTED',
+        yield {
+          type: EventType.RUN_STARTED,
           runId,
           threadId,
           model,
-          timestamp,
-        })
+          timestamp: Date.now(),
+        }
       }
 
       if (chunk.candidates?.[0]?.content?.parts) {
@@ -293,92 +287,92 @@ export class GeminiTextAdapter<
                 reasoningMessageId = generateId(this.name)
 
                 // Spec REASONING events
-                yield asChunk({
-                  type: 'REASONING_START',
+                yield {
+                  type: EventType.REASONING_START,
                   messageId: reasoningMessageId,
                   model,
-                  timestamp,
-                })
-                yield asChunk({
-                  type: 'REASONING_MESSAGE_START',
+                  timestamp: Date.now(),
+                }
+                yield {
+                  type: EventType.REASONING_MESSAGE_START,
                   messageId: reasoningMessageId,
                   role: 'reasoning' as const,
                   model,
-                  timestamp,
-                })
+                  timestamp: Date.now(),
+                }
 
                 // Legacy STEP events (kept during transition)
-                yield asChunk({
-                  type: 'STEP_STARTED',
+                yield {
+                  type: EventType.STEP_STARTED,
                   stepName: stepId,
                   stepId,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   stepType: 'thinking',
-                })
+                }
               }
 
               accumulatedThinking += part.text
 
               // Spec REASONING content event
-              yield asChunk({
-                type: 'REASONING_MESSAGE_CONTENT',
+              yield {
+                type: EventType.REASONING_MESSAGE_CONTENT,
                 messageId: reasoningMessageId!,
                 delta: part.text,
                 model,
-                timestamp,
-              })
+                timestamp: Date.now(),
+              }
 
               // Legacy STEP event
-              yield asChunk({
-                type: 'STEP_FINISHED',
+              yield {
+                type: EventType.STEP_FINISHED,
                 stepName: stepId || generateId(this.name),
                 stepId: stepId || generateId(this.name),
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 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',
+                yield {
+                  type: EventType.REASONING_MESSAGE_END,
                   messageId: reasoningMessageId,
                   model,
-                  timestamp,
-                })
-                yield asChunk({
-                  type: 'REASONING_END',
+                  timestamp: Date.now(),
+                }
+                yield {
+                  type: EventType.REASONING_END,
                   messageId: reasoningMessageId,
                   model,
-                  timestamp,
-                })
+                  timestamp: Date.now(),
+                }
               }
 
               // Skip whitespace-only text parts (e.g. "\n" during auto-continuation)
               // Emit TEXT_MESSAGE_START on first text content
               if (!hasEmittedTextMessageStart) {
                 hasEmittedTextMessageStart = true
-                yield asChunk({
-                  type: 'TEXT_MESSAGE_START',
+                yield {
+                  type: EventType.TEXT_MESSAGE_START,
                   messageId,
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   role: 'assistant',
-                })
+                }
               }
 
               accumulatedContent += part.text
-              yield asChunk({
-                type: 'TEXT_MESSAGE_CONTENT',
+              yield {
+                type: EventType.TEXT_MESSAGE_CONTENT,
                 messageId,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 delta: part.text,
                 content: accumulatedContent,
-              })
+              }
             }
           }
 
@@ -430,31 +424,31 @@ export class GeminiTextAdapter<
             // Emit TOOL_CALL_START if not already started
             if (!toolCallData.started) {
               toolCallData.started = true
-              yield asChunk({
-                type: 'TOOL_CALL_START',
+              yield {
+                type: EventType.TOOL_CALL_START,
                 toolCallId,
                 toolCallName: toolCallData.name,
                 toolName: toolCallData.name,
                 model,
-                timestamp,
+                timestamp: Date.now(),
                 index: toolCallData.index,
                 ...(toolCallData.thoughtSignature && {
                   metadata: {
                     thoughtSignature: toolCallData.thoughtSignature,
                   } satisfies GeminiToolCallMetadata,
                 }),
-              })
+              }
             }
 
             // Emit TOOL_CALL_ARGS
-            yield asChunk({
-              type: 'TOOL_CALL_ARGS',
+            yield {
+              type: EventType.TOOL_CALL_ARGS,
               toolCallId,
               model,
-              timestamp,
+              timestamp: Date.now(),
               delta: toolCallData.args,
               args: toolCallData.args,
-            })
+            }
           }
         }
       } else if (chunk.data && chunk.data.trim()) {
@@ -462,24 +456,24 @@ export class GeminiTextAdapter<
         // Emit TEXT_MESSAGE_START on first text content
         if (!hasEmittedTextMessageStart) {
           hasEmittedTextMessageStart = true
-          yield asChunk({
-            type: 'TEXT_MESSAGE_START',
+          yield {
+            type: EventType.TEXT_MESSAGE_START,
             messageId,
             model,
-            timestamp,
+            timestamp: Date.now(),
             role: 'assistant',
-          })
+          }
         }
 
         accumulatedContent += chunk.data
-        yield asChunk({
-          type: 'TEXT_MESSAGE_CONTENT',
+        yield {
+          type: EventType.TEXT_MESSAGE_CONTENT,
           messageId,
           model,
-          timestamp,
+          timestamp: Date.now(),
           delta: chunk.data,
           content: accumulatedContent,
-        })
+        }
       }
 
       if (chunk.candidates?.[0]?.finishReason) {
@@ -508,15 +502,15 @@ export class GeminiTextAdapter<
                 })
 
                 // Emit TOOL_CALL_START
-                yield asChunk({
-                  type: 'TOOL_CALL_START',
+                yield {
+                  type: EventType.TOOL_CALL_START,
                   toolCallId,
                   toolCallName: functionCall.name || '',
                   toolName: functionCall.name || '',
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   index: nextToolIndex - 1,
-                })
+                }
 
                 // Emit TOOL_CALL_END with parsed input
                 let parsedInput: unknown = {}
@@ -531,15 +525,15 @@ export class GeminiTextAdapter<
                   parsedInput = {}
                 }
 
-                yield asChunk({
-                  type: 'TOOL_CALL_END',
+                yield {
+                  type: EventType.TOOL_CALL_END,
                   toolCallId,
                   toolCallName: functionCall.name || '',
                   toolName: functionCall.name || '',
                   model,
-                  timestamp,
+                  timestamp: Date.now(),
                   input: parsedInput,
-                })
+                }
               }
             }
           }
@@ -555,15 +549,15 @@ export class GeminiTextAdapter<
             parsedInput = {}
           }
 
-          yield asChunk({
-            type: 'TOOL_CALL_END',
+          yield {
+            type: EventType.TOOL_CALL_END,
             toolCallId,
             toolCallName: toolCallData.name,
             toolName: toolCallData.name,
             model,
-            timestamp,
+            timestamp: Date.now(),
             input: parsedInput,
-          })
+          }
         }
 
         // Reset so a new TEXT_MESSAGE_START is emitted if text follows tool calls
@@ -572,11 +566,11 @@ export class GeminiTextAdapter<
         }
 
         if (finishReason === FinishReason.MAX_TOKENS) {
-          yield asChunk({
-            type: 'RUN_ERROR',
+          yield {
+            type: EventType.RUN_ERROR,
             runId,
             model,
-            timestamp,
+            timestamp: Date.now(),
             message:
               'The response was cut off because the maximum token limit was reached.',
             code: 'max_tokens',
@@ -585,42 +579,42 @@ export class GeminiTextAdapter<
                 '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',
+          yield {
+            type: EventType.REASONING_MESSAGE_END,
             messageId: reasoningMessageId,
             model,
-            timestamp,
-          })
-          yield asChunk({
-            type: 'REASONING_END',
+            timestamp: Date.now(),
+          }
+          yield {
+            type: EventType.REASONING_END,
             messageId: reasoningMessageId,
             model,
-            timestamp,
-          })
+            timestamp: Date.now(),
+          }
         }
 
         // Emit TEXT_MESSAGE_END if we had text content
         if (hasEmittedTextMessageStart) {
-          yield asChunk({
-            type: 'TEXT_MESSAGE_END',
+          yield {
+            type: EventType.TEXT_MESSAGE_END,
             messageId,
             model,
-            timestamp,
-          })
+            timestamp: Date.now(),
+          }
         }
 
-        yield asChunk({
-          type: 'RUN_FINISHED',
+        yield {
+          type: EventType.RUN_FINISHED,
           runId,
           threadId,
           model,
-          timestamp,
+          timestamp: Date.now(),
           finishReason: toolCallMap.size > 0 ? 'tool_calls' : 'stop',
           usage: chunk.usageMetadata
             ? {
@@ -629,7 +623,7 @@ export class GeminiTextAdapter<
                 totalTokens: chunk.usageMetadata.totalTokenCount ?? 0,
               }
             : undefined,
-        })
+        }
       }
     }
   }

package/src/index.ts

@@ -11,15 +11,12 @@ export {
   type GeminiTextProviderOptions,
 } from './adapters/text'
 
-// Summarize adapter
+// Summarize - thin factory functions over @tanstack/ai's ChatStreamSummarizeAdapter
 export {
-  GeminiSummarizeAdapter,
-  GeminiSummarizeModels,
   createGeminiSummarize,
   geminiSummarize,
-  type GeminiSummarizeAdapterOptions,
+  type GeminiSummarizeConfig,
   type GeminiSummarizeModel,
-  type GeminiSummarizeProviderOptions,
 } from './adapters/summarize'
 
 // Image adapter