@core-ai/google-genai 0.19.0 → 0.20.0

package/dist/index.d.ts

@@ -9,6 +9,11 @@ type GoogleModelCapabilities = Omit<ModelCapabilities, 'reasoning'> & {
 };
 declare function getGoogleModelCapabilities(modelId: string): GoogleModelCapabilities;
 
+/**
+ * Thought signature Google attaches under the `google` provider metadata key.
+ * Used on reasoning parts today, and on tool-call parts so Gemini 3 function
+ * calls can be replayed without a missing-`thought_signature` 400.
+ */
 type GoogleReasoningMetadata = {
     thoughtSignature?: string;
 };

package/dist/index.js

@@ -180,12 +180,17 @@ function convertMessages(messages) {
         }
         if (part.type === "tool-call") {
           toolCallNameById.set(part.toolCall.id, part.toolCall.name);
+          const toolCallSignature = getProviderMetadata(
+            part.providerMetadata,
+            "google"
+          )?.thoughtSignature;
           assistantParts.push({
             functionCall: {
               id: part.toolCall.id,
               name: part.toolCall.name,
               args: part.toolCall.arguments
-            }
+            },
+            ...typeof toolCallSignature === "string" ? { thoughtSignature: toolCallSignature } : {}
           });
           continue;
         }
@@ -453,6 +458,7 @@ function mapFinishReason(reason) {
 }
 async function* transformStream(stream) {
   const bufferedToolCalls = /* @__PURE__ */ new Map();
+  const toolCallSignatures = /* @__PURE__ */ new Map();
   let finishReason = "unknown";
   let sawToolCalls = false;
   let textOpen = false;
@@ -508,18 +514,21 @@ async function* transformStream(stream) {
         };
       }
     }
-    if (chunk.text) {
+    const textDeltas = extractTextDeltas(chunk);
+    if (textDeltas.length > 0) {
       const reasoningEnd2 = closeReasoning();
       if (reasoningEnd2) {
         yield reasoningEnd2;
       }
       yield* startText();
-      yield {
-        type: "text-delta",
-        text: chunk.text
-      };
+      for (const text of textDeltas) {
+        yield {
+          type: "text-delta",
+          text
+        };
+      }
     }
-    const functionCalls = chunk.functionCalls ?? [];
+    const functionCalls = extractStreamedFunctionCalls(chunk);
     if (functionCalls.length > 0) {
       yield* closeText();
       const reasoningEnd2 = closeReasoning();
@@ -527,8 +536,13 @@ async function* transformStream(stream) {
         yield reasoningEnd2;
       }
       sawToolCalls = true;
-      for (const [index, functionCall] of functionCalls.entries()) {
-        const mappedCall = mapFunctionCall(functionCall, index);
+      for (const {
+        toolCall: mappedCall,
+        thoughtSignature
+      } of functionCalls) {
+        if (thoughtSignature) {
+          toolCallSignatures.set(mappedCall.id, thoughtSignature);
+        }
         const existing = bufferedToolCalls.get(mappedCall.id);
         if (!existing) {
           bufferedToolCalls.set(mappedCall.id, mappedCall);
@@ -574,9 +588,11 @@ async function* transformStream(stream) {
   }
   yield* closeText();
   for (const toolCall of bufferedToolCalls.values()) {
+    const thoughtSignature = toolCallSignatures.get(toolCall.id);
     yield {
       type: "tool-call-end",
-      toolCall
+      toolCall,
+      ...thoughtSignature ? { providerMetadata: { google: { thoughtSignature } } } : {}
     };
   }
   if (sawToolCalls && finishReason !== "content-filter") {
@@ -617,7 +633,7 @@ function extractAssistantParts(response) {
       if (thoughtText.length === 0) {
         continue;
       }
-      const thoughtSignature = typeof part.thoughtSignature === "string" ? part.thoughtSignature : void 0;
+      const thoughtSignature = readThoughtSignature(part);
       parts.push({
         type: "reasoning",
         text: thoughtText,
@@ -634,9 +650,15 @@ function extractAssistantParts(response) {
       const key = `${toolCall.id}:${toolCall.name}`;
       if (!seenToolCalls.has(key)) {
         seenToolCalls.add(key);
+        const thoughtSignature = readThoughtSignature(part);
         parts.push({
           type: "tool-call",
-          toolCall
+          toolCall,
+          ...thoughtSignature ? {
+            providerMetadata: {
+              google: { thoughtSignature }
+            }
+          } : {}
         });
       }
       continue;
@@ -660,14 +682,57 @@ function extractAssistantParts(response) {
       toolCall
     });
   }
-  if (parts.length === 0 && response.text) {
-    parts.push({
-      type: "text",
-      text: response.text
-    });
+  if (parts.length === 0) {
+    for (const text of extractTextDeltas(response)) {
+      parts.push({
+        type: "text",
+        text
+      });
+    }
   }
   return parts;
 }
+function extractTextDeltas(response) {
+  const candidateParts = response.candidates?.[0]?.content?.parts ?? [];
+  if (candidateParts.length > 0) {
+    return candidateParts.flatMap((part) => {
+      if (part.thought || part.functionCall) {
+        return [];
+      }
+      if (typeof part.text === "string" && part.text.length > 0) {
+        return [part.text];
+      }
+      return [];
+    });
+  }
+  return typeof response.text === "string" && response.text.length > 0 ? [response.text] : [];
+}
+function extractStreamedFunctionCalls(chunk) {
+  const candidateParts = chunk.candidates?.[0]?.content?.parts ?? [];
+  const fromCandidateParts = [];
+  for (const part of candidateParts) {
+    if (!part.functionCall) {
+      continue;
+    }
+    const thoughtSignature = readThoughtSignature(part);
+    fromCandidateParts.push({
+      toolCall: mapFunctionCall(
+        part.functionCall,
+        fromCandidateParts.length
+      ),
+      ...thoughtSignature ? { thoughtSignature } : {}
+    });
+  }
+  if (fromCandidateParts.length > 0) {
+    return fromCandidateParts;
+  }
+  return (chunk.functionCalls ?? []).map((functionCall, index) => ({
+    toolCall: mapFunctionCall(functionCall, index)
+  }));
+}
+function readThoughtSignature(part) {
+  return typeof part.thoughtSignature === "string" && part.thoughtSignature.length > 0 ? part.thoughtSignature : void 0;
+}
 function extractReasoningDeltas(response) {
   const candidateParts = response.candidates?.[0]?.content?.parts ?? [];
   return candidateParts.flatMap((part) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/google-genai",
-    "version": "0.19.0",
+    "version": "0.20.0",
     "description": "Google GenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -45,7 +45,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.19.0",
+        "@core-ai/core-ai": "^0.20.0",
         "@google/genai": "^1.42.0"
     },
     "peerDependencies": {