@core-ai/google-genai 0.18.0 → 0.20.0

package/dist/index.d.ts

@@ -1,7 +1,23 @@
 import { GoogleGenAI } from '@google/genai';
-import { ChatModel, EmbeddingModel, ImageModel, ModelCapabilities } from '@core-ai/core-ai';
+import { ModelCapabilities, ChatModel, EmbeddingModel, ImageModel } from '@core-ai/core-ai';
 import { z } from 'zod';
 
+type GoogleModelCapabilities = Omit<ModelCapabilities, 'reasoning'> & {
+    reasoning: ModelCapabilities['reasoning'] & {
+        thinkingParam: 'thinkingLevel' | 'thinkingBudget';
+    };
+};
+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;
+};
+
 type GoogleGenAIClient = {
     models: GoogleGenAI['models'];
 };
@@ -23,17 +39,6 @@ type GoogleGenAIProvider = {
 declare function createGoogleGenAIProvider(options?: GoogleGenAIProviderBaseOptions, factoryOptions?: GoogleGenAIProviderFactoryOptions): GoogleGenAIProvider;
 declare function createGoogleGenAI(options?: GoogleGenAIProviderOptions): GoogleGenAIProvider;
 
-type GoogleReasoningMetadata = {
-    thoughtSignature?: string;
-};
-
-type GoogleModelCapabilities = {
-    reasoning: ModelCapabilities['reasoning'] & {
-        thinkingParam: 'thinkingLevel' | 'thinkingBudget';
-    };
-};
-declare function getGoogleModelCapabilities(modelId: string): GoogleModelCapabilities;
-
 declare const googleGenerateProviderOptionsSchema: z.ZodObject<{
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     frequencyPenalty: z.ZodOptional<z.ZodNumber>;

package/dist/index.js

@@ -1,20 +1,15 @@
 // src/provider.ts
 import { GoogleGenAI } from "@google/genai";
 
-// src/chat-model.ts
-import {
-  StructuredOutputNoObjectGeneratedError,
-  StructuredOutputParseError,
-  StructuredOutputValidationError,
-  createObjectStream,
-  createChatStream
-} from "@core-ai/core-ai";
-
 // src/chat-adapter.ts
 import {
   FunctionCallingConfigMode
 } from "@google/genai";
-import { getProviderMetadata, zodSchemaToJsonSchema } from "@core-ai/core-ai";
+import {
+  getProviderMetadata,
+  validateInputModalities,
+  zodSchemaToJsonSchema
+} from "@core-ai/core-ai";
 
 // src/model-capabilities.ts
 import {
@@ -27,6 +22,10 @@ var ALL_EFFORTS = [
   "high",
   "max"
 ];
+var GOOGLE_INPUT_MODALITIES = {
+  input: ["text", "image", "file", "audio"],
+  output: ["text"]
+};
 function createCapabilities(config) {
   return {
     reasoning: {
@@ -35,7 +34,8 @@ function createCapabilities(config) {
       restrictsSamplingParams: false,
       supportedToolChoices: ["auto", "none", "required", "tool"],
       thinkingParam: config.thinkingParam
-    }
+    },
+    modalities: GOOGLE_INPUT_MODALITIES
   };
 }
 var DEFAULT_CAPABILITIES = createCapabilities({
@@ -151,6 +151,7 @@ function parseGoogleImageProviderOptions(providerOptions) {
 var googleProviderOptionsSchema = googleGenerateProviderOptionsSchema;
 
 // src/chat-adapter.ts
+var DEFAULT_PROVIDER_ID = "google";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_NAME = "core_ai_generate_object";
 var DEFAULT_STRUCTURED_OUTPUT_TOOL_DESCRIPTION = "Return a JSON object that matches the requested schema.";
 function convertMessages(messages) {
@@ -179,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;
         }
@@ -254,6 +260,14 @@ function convertUserContentPart(part) {
       }
     };
   }
+  if (part.type === "audio") {
+    return {
+      inlineData: {
+        data: part.source.data,
+        mimeType: part.source.mediaType
+      }
+    };
+  }
   return {
     inlineData: {
       data: part.data,
@@ -361,17 +375,24 @@ function inferMimeTypeFromUrl(url) {
   }
   return "application/octet-stream";
 }
-function createGenerateRequest(modelId, options) {
+function createGenerateRequest(modelId, options, provider = DEFAULT_PROVIDER_ID, adapterOptions = {}) {
   const googleOptions = parseGoogleGenerateProviderOptions(
     options.providerOptions
   );
+  const capabilities = adapterOptions.capabilities ?? getGoogleModelCapabilities(modelId);
+  validateInputModalities({
+    messages: options.messages,
+    capabilities,
+    modelId,
+    providerId: provider
+  });
   const convertedMessages = convertMessages(options.messages);
   const requestConfig = {
     ...convertedMessages.systemInstruction ? { systemInstruction: convertedMessages.systemInstruction } : {},
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { toolConfig: convertToolChoice(options.toolChoice) } : {},
     ...mapSamplingToConfig(options),
-    ...mapReasoningToConfig(modelId, options),
+    ...mapReasoningToConfig(options, capabilities),
     ...mapGoogleProviderOptionsToConfig(googleOptions),
     ...options.signal ? { abortSignal: options.signal } : {}
   };
@@ -437,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;
@@ -492,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();
@@ -511,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);
@@ -558,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") {
@@ -572,11 +604,10 @@ async function* transformStream(stream) {
     usage
   };
 }
-function mapReasoningToConfig(modelId, options) {
+function mapReasoningToConfig(options, capabilities) {
   if (!options.reasoning) {
     return {};
   }
-  const capabilities = getGoogleModelCapabilities(modelId);
   if (capabilities.reasoning.thinkingParam === "thinkingLevel") {
     return {
       thinkingConfig: {
@@ -602,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,
@@ -619,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;
@@ -645,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) => {
@@ -681,6 +761,15 @@ function mapUsage(response, fallback) {
   };
 }
 
+// src/chat-model.ts
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStream,
+  createChatStream
+} from "@core-ai/core-ai";
+
 // src/google-error.ts
 import { ApiError } from "@google/genai";
 import {
@@ -814,6 +903,8 @@ function toNumericHttpCode(body) {
 
 // src/chat-model.ts
 function createGoogleGenAIChatModel(client, modelId, provider = "google") {
+  const capabilities = getGoogleModelCapabilities(modelId);
+  const adapterOptions = { capabilities };
   async function callGenerateContentApi(request) {
     try {
       return await client.models.generateContent(request);
@@ -829,12 +920,22 @@ function createGoogleGenAIChatModel(client, modelId, provider = "google") {
     }
   }
   async function generateChat(options) {
-    const request = createGenerateRequest(modelId, options);
+    const request = createGenerateRequest(
+      modelId,
+      options,
+      provider,
+      adapterOptions
+    );
     const response = await callGenerateContentApi(request);
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
-    const request = createGenerateRequest(modelId, options);
+    const request = createGenerateRequest(
+      modelId,
+      options,
+      provider,
+      adapterOptions
+    );
     return createChatStream(
       async () => transformStream(await callGenerateContentStreamApi(request)),
       { signal: options.signal }
@@ -843,7 +944,7 @@ function createGoogleGenAIChatModel(client, modelId, provider = "google") {
   return {
     provider,
     modelId,
-    capabilities: getGoogleModelCapabilities(modelId),
+    capabilities,
     generate: generateChat,
     stream: streamChat,
     async generateObject(options) {
@@ -1247,7 +1348,6 @@ function greatestCommonDivisor(a, b) {
 }
 
 // src/provider.ts
-var DEFAULT_PROVIDER_ID = "google";
 function createGoogleGenAIProvider(options = {}, factoryOptions = {}) {
   const client = options.client ?? new GoogleGenAI({
     apiKey: options.apiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/google-genai",
-    "version": "0.18.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.18.0",
+        "@core-ai/core-ai": "^0.20.0",
         "@google/genai": "^1.42.0"
     },
     "peerDependencies": {