fix(core): preserve functionCall thoughtSignature when stripping thought parts

Fixes #28604

Root cause: PR #28509 added stripThoughts() to getHistoryTurns() for
Gemini 2.x/modern models when context management is disabled. It
unconditionally drops every history part with thought:true. For turns
where the API attached the required thoughtSignature to that thought
part rather than to the sibling functionCall part, stripping it left
the functionCall with no signature at all. The existing repair
(ensureActiveLoopHasThoughtSignatures) only patches the current active
loop, not older completed turns already sitting in history (e.g. a
prior activate_skill call), so those turns replay on every subsequent
request with a signature-less functionCall and the API rejects them
with 400 INVALID_ARGUMENT "Function call is missing a
thought_signature in functionCall parts."

Fix: stripThoughts() now injects the existing SYNTHETIC_THOUGHT_SIGNATURE
onto a model turn's first functionCall part if stripping removed its
only source of a signature and it doesn't already have one. This
mirrors the equivalent repair pairToolsAndEnforceSignatures() already
performs for the context-management-enabled path in
historyHardening.ts, so both code paths now uphold the same invariant.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: sarbojitrana

packages/core/src/core/geminiChat.test.ts

@@ -2387,6 +2387,75 @@ describe('GeminiChat', () => {
       expect(turns[0].content.parts![0].text).toBe('Question 1');
       expect(turns[0].content.parts![1].text).toBe('Question 2');
     });
+
+    it('should inject a synthetic thoughtSignature onto a functionCall left signature-less after stripping a thought part that carried it (regression test for #28604)', () => {
+      vi.mocked(mockConfig.isContextManagementEnabled).mockReturnValue(false);
+      vi.mocked(mockConfig.getModel).mockReturnValue('gemini-2.5-pro');
+
+      chat.setHistory([
+        { role: 'user', parts: [{ text: 'activate the skill' }] },
+        {
+          role: 'model',
+          parts: [
+            {
+              text: 'internal monologue',
+              thought: true,
+              thoughtSignature: 'real-sig-from-api',
+            } as unknown as Part,
+            {
+              functionCall: { name: 'activate_skill', args: {} },
+            },
+          ],
+        },
+        {
+          role: 'user',
+          parts: [
+            { functionResponse: { name: 'activate_skill', response: {} } },
+          ],
+        },
+      ]);
+
+      const turns = chat.getHistoryTurns(true);
+
+      const modelTurn = turns[1];
+      expect(modelTurn.content.parts).toHaveLength(1);
+      expect(modelTurn.content.parts![0].functionCall?.name).toBe(
+        'activate_skill',
+      );
+      expect(modelTurn.content.parts![0].thoughtSignature).toBe(
+        SYNTHETIC_THOUGHT_SIGNATURE,
+      );
+    });
+
+    it('should leave an existing thoughtSignature on a functionCall untouched when stripping thoughts', () => {
+      vi.mocked(mockConfig.isContextManagementEnabled).mockReturnValue(false);
+      vi.mocked(mockConfig.getModel).mockReturnValue('gemini-2.5-pro');
+
+      chat.setHistory([
+        { role: 'user', parts: [{ text: 'activate the skill' }] },
+        {
+          role: 'model',
+          parts: [
+            {
+              text: 'internal monologue',
+              thought: true,
+              thoughtSignature: 'real-sig-from-api',
+            } as unknown as Part,
+            {
+              functionCall: { name: 'activate_skill', args: {} },
+              thoughtSignature: 'existing-sig-on-call',
+            },
+          ],
+        },
+      ]);
+
+      const turns = chat.getHistoryTurns(true);
+
+      const modelTurn = turns[1];
+      expect(modelTurn.content.parts![0].thoughtSignature).toBe(
+        'existing-sig-on-call',
+      );
+    });
   });
 
   describe('ensureActiveLoopHasThoughtSignatures', () => {

packages/core/src/core/geminiChat.ts

@@ -1533,11 +1533,34 @@ export function stripThoughts(history: HistoryTurn[]): HistoryTurn[] {
       if (!hasThought) return turn;
 
       const nonThoughtParts = turn.content.parts.filter((p) => p && !p.thought);
+
+      // The thoughtSignature the API requires on the first functionCall of a
+      // model turn is sometimes only carried by the thought part we just
+      // removed, not by the functionCall part itself. Without it, replaying
+      // this turn in a later request gets rejected with a 400 "missing
+      // thought_signature" error, so inject a synthetic one if needed.
+      let patchedFirstCall = false;
+      const finalParts =
+        turn.content.role === 'model'
+          ? nonThoughtParts.map((p) => {
+              if (!patchedFirstCall && p.functionCall) {
+                patchedFirstCall = true;
+                if (!p.thoughtSignature) {
+                  return {
+                    ...p,
+                    thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE,
+                  };
+                }
+              }
+              return p;
+            })
+          : nonThoughtParts;
+
       return {
         ...turn,
         content: {
           ...turn.content,
-          parts: nonThoughtParts,
+          parts: finalParts,
         },
       };
     })