refactor: use typed Part interface instead of any casts

Per review feedback: use the @google/genai typed `Part` interface
directly instead of `as any` casts.

- Read side: `part.thoughtSignature` is properly typed on `Part`, so
  the cast is removed entirely. The Gemini 2.x fallback to
  `functionCall.thoughtSignature` is also removed since the SDK has
  never typed it there and Gemini has always emitted it at Part level.
- Write side: construct a typed `Part` and conditionally assign
  `thoughtSignature`, avoiding the `as Part` cast on a spread literal.

The only remaining `as any` in this area is the pre-existing
functionResponse cast, which is unrelated to this fix.

Author: Nathan Young

.changeset/fix-gemini-thought-signature-part-level.md

@@ -2,11 +2,11 @@
 '@tanstack/ai-gemini': patch
 ---
 
-fix(ai-gemini): read/write thoughtSignature at Part level for Gemini 3.x
+fix(ai-gemini): read/write thoughtSignature at Part level
 
-Gemini 3.x models emit `thoughtSignature` as a Part-level sibling of `functionCall` (per the `@google/genai` `Part` type definition), not nested inside `functionCall`. The adapter was reading from `functionCall.thoughtSignature` (which doesn't exist in the SDK types) and writing it back nested inside `functionCall`, causing the Gemini API to reject subsequent tool-call turns with `400 INVALID_ARGUMENT: "Function call is missing a thought_signature"`.
+Gemini emits `thoughtSignature` as a Part-level sibling of `functionCall` (per the `@google/genai` `Part` type definition), not nested inside `functionCall`. The `FunctionCall` type has never had a `thoughtSignature` property. The adapter was reading from `functionCall.thoughtSignature` (which doesn't exist in the SDK types) and writing it back nested inside `functionCall`, causing Gemini 3.x to reject subsequent tool-call turns with `400 INVALID_ARGUMENT: "Function call is missing a thought_signature"`.
 
 This fix:
 
-- **Read side:** reads `part.thoughtSignature` first, falls back to `functionCall.thoughtSignature` for older Gemini 2.x models
-- **Write side:** emits `thoughtSignature` as a Part-level sibling of `functionCall` instead of nesting it inside
+- **Read side:** reads `part.thoughtSignature` directly, using the SDK's typed `Part` interface
+- **Write side:** emits `thoughtSignature` as a Part-level sibling of `functionCall`, using the SDK's typed `Part` interface

packages/typescript/ai-gemini/src/adapters/text.ts

@@ -351,14 +351,10 @@ export class GeminiTextAdapter<
               `${functionCall.name}_${Date.now()}_${nextToolIndex}`
             const functionArgs = functionCall.args || {}
 
-            // Gemini 3.x emits thoughtSignature as a Part-level sibling of
-            // functionCall (see @google/genai Part type), not nested inside
-            // functionCall. Read from the Part first, fall back to
-            // functionCall for older Gemini 2.x models.
-            const partThoughtSignature =
-              (part as any).thoughtSignature ||
-              (functionCall as any).thoughtSignature ||
-              undefined
+            // Gemini emits thoughtSignature as a Part-level sibling of
+            // functionCall (per @google/genai Part type), not nested inside
+            // functionCall itself.
+            const partThoughtSignature = part.thoughtSignature || undefined
 
             let toolCallData = toolCallMap.get(toolCallId)
             if (!toolCallData) {
@@ -686,18 +682,21 @@ export class GeminiTextAdapter<
 
           const thoughtSignature = toolCall.providerMetadata
             ?.thoughtSignature as string | undefined
-          // Gemini 3.x requires thoughtSignature at the Part level (sibling
-          // of functionCall), not nested inside functionCall. Nesting it
-          // causes the API to reject the next turn with
+          // Gemini requires thoughtSignature at the Part level (sibling of
+          // functionCall), not nested inside functionCall. Nesting it causes
+          // the API to reject the next turn with
           // "Function call is missing a thought_signature".
-          parts.push({
+          const part: Part = {
             functionCall: {
               id: toolCall.id,
               name: toolCall.function.name,
               args: parsedArgs,
             },
-            ...(thoughtSignature && { thoughtSignature }),
-          } as Part)
+          }
+          if (thoughtSignature) {
+            part.thoughtSignature = thoughtSignature
+          }
+          parts.push(part)
         }
       }
 

packages/typescript/ai-gemini/tests/gemini-adapter.test.ts

@@ -592,10 +592,9 @@ describe('GeminiAdapter through AI', () => {
     expect(functionCallPart.functionCall.thoughtSignature).toBeUndefined()
   })
 
-  it('falls back to functionCall.thoughtSignature for Gemini 2.x models', async () => {
-    const thoughtSig = 'legacy-thought-signature'
-
-    // Gemini 2.x nests thoughtSignature inside functionCall
+  it('ignores thoughtSignature nested inside functionCall (not part of @google/genai Part type)', async () => {
+    // The @google/genai SDK has never typed thoughtSignature on FunctionCall;
+    // it only exists on Part. A nested value should be ignored.
     const firstStream = [
       {
         candidates: [
@@ -604,10 +603,10 @@ describe('GeminiAdapter through AI', () => {
               parts: [
                 {
                   functionCall: {
-                    id: 'fc_legacy',
+                    id: 'fc_nested',
                     name: 'sum_tool',
                     args: { numbers: [3, 4] },
-                    thoughtSignature: thoughtSig,
+                    thoughtSignature: 'should-be-ignored',
                   },
                 },
               ],
@@ -671,8 +670,8 @@ describe('GeminiAdapter through AI', () => {
 
     const functionCallPart = modelTurn.parts.find((p: any) => p.functionCall)
     expect(functionCallPart).toBeDefined()
-    // Even for legacy input, the write side should emit at Part level
-    expect(functionCallPart.thoughtSignature).toBe(thoughtSig)
+    // No thoughtSignature should be emitted since none was at Part level
+    expect(functionCallPart.thoughtSignature).toBeUndefined()
     expect(functionCallPart.functionCall.thoughtSignature).toBeUndefined()
   })