@core-ai/google-genai 0.4.0 → 0.5.0

package/dist/index.js

@@ -16,6 +16,65 @@ import {
 } from "@google/genai";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
+// src/model-capabilities.ts
+var DEFAULT_CAPABILITIES = {
+  reasoning: {
+    thinkingParam: "thinkingBudget",
+    canDisableThinking: true
+  }
+};
+var MODEL_CAPABILITIES = {
+  "gemini-3-pro": {
+    reasoning: {
+      thinkingParam: "thinkingLevel",
+      canDisableThinking: false
+    }
+  },
+  "gemini-2.5-pro": {
+    reasoning: {
+      thinkingParam: "thinkingBudget",
+      canDisableThinking: false
+    }
+  },
+  "gemini-2.5-flash": {
+    reasoning: {
+      thinkingParam: "thinkingBudget",
+      canDisableThinking: true
+    }
+  },
+  "gemini-2.5-flash-lite": {
+    reasoning: {
+      thinkingParam: "thinkingBudget",
+      canDisableThinking: true
+    }
+  }
+};
+function getGoogleModelCapabilities(modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
+}
+function normalizeModelId(modelId) {
+  return modelId.replace(/-\d{8}$/, "");
+}
+function toGoogleThinkingLevel(effort) {
+  if (effort === "high" || effort === "max") {
+    return "HIGH";
+  }
+  return "LOW";
+}
+function toGoogleThinkingBudget(effort) {
+  if (effort === "minimal") {
+    return 1024;
+  }
+  if (effort === "low") {
+    return 4096;
+  }
+  if (effort === "medium") {
+    return 16384;
+  }
+  return 32768;
+}
+
 // src/object-utils.ts
 function asObject(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -46,18 +105,31 @@ function convertMessages(messages) {
     }
     if (message.role === "assistant") {
       const assistantParts = [];
-      if (message.content) {
-        assistantParts.push({ text: message.content });
-      }
-      for (const toolCall of message.toolCalls ?? []) {
-        toolCallNameById.set(toolCall.id, toolCall.name);
-        assistantParts.push({
-          functionCall: {
-            id: toolCall.id,
-            name: toolCall.name,
-            args: toolCall.arguments
-          }
-        });
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          assistantParts.push({ text: part.text });
+          continue;
+        }
+        if (part.type === "tool-call") {
+          toolCallNameById.set(part.toolCall.id, part.toolCall.name);
+          assistantParts.push({
+            functionCall: {
+              id: part.toolCall.id,
+              name: part.toolCall.name,
+              args: part.toolCall.arguments
+            }
+          });
+          continue;
+        }
+        const thoughtPart = {
+          text: part.text,
+          thought: true
+        };
+        const thoughtSignature = part.providerMetadata?.["thoughtSignature"];
+        if (typeof thoughtSignature === "string") {
+          thoughtPart["thoughtSignature"] = thoughtSignature;
+        }
+        assistantParts.push(thoughtPart);
       }
       contents.push({
         role: "model",
@@ -177,6 +249,7 @@ function createStructuredOutputOptions(options) {
   const toolName = getStructuredOutputToolName(options);
   return {
     messages: options.messages,
+    reasoning: options.reasoning,
     tools: {
       structured_output: {
         name: toolName,
@@ -232,7 +305,8 @@ function createGenerateRequest(modelId, options) {
       ...options.config?.topP !== void 0 ? { topP: options.config.topP } : {},
       ...options.config?.stopSequences ? { stopSequences: options.config.stopSequences } : {},
       ...options.config?.frequencyPenalty !== void 0 ? { frequencyPenalty: options.config.frequencyPenalty } : {},
-      ...options.config?.presencePenalty !== void 0 ? { presencePenalty: options.config.presencePenalty } : {}
+      ...options.config?.presencePenalty !== void 0 ? { presencePenalty: options.config.presencePenalty } : {},
+      ...mapReasoningToConfig(modelId, options)
     }
   };
   const providerOptions = options.providerOptions;
@@ -250,31 +324,34 @@ function createGenerateRequest(modelId, options) {
   };
 }
 function mapGenerateResponse(response) {
-  const toolCalls = parseFunctionCalls(response.functionCalls);
+  const parts = extractAssistantParts(response);
+  const toolCalls = parts.flatMap(
+    (part) => part.type === "tool-call" ? [part.toolCall] : []
+  );
+  const content = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+  const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
   const finishReason = mapFinishReason(
     response.candidates?.[0]?.finishReason ?? void 0
   );
   if (!response.candidates?.[0]) {
     return {
-      content: null,
+      parts,
+      content: content.length > 0 ? content : null,
+      reasoning: reasoning.length > 0 ? reasoning : null,
       toolCalls,
       finishReason: toolCalls.length > 0 ? "tool-calls" : finishReason,
       usage: mapUsage(response)
     };
   }
   return {
-    content: response.text ?? null,
+    parts,
+    content: content.length > 0 ? content : null,
+    reasoning: reasoning.length > 0 ? reasoning : null,
     toolCalls,
     finishReason: toolCalls.length > 0 ? "tool-calls" : finishReason,
     usage: mapUsage(response)
   };
 }
-function parseFunctionCalls(calls) {
-  if (!calls || calls.length === 0) {
-    return [];
-  }
-  return calls.map((call, index) => mapFunctionCall(call, index));
-}
 function mapFunctionCall(toolCall, index) {
   return {
     id: toolCall.id ?? `tool-${index}`,
@@ -298,6 +375,7 @@ async function* transformStream(stream) {
   const bufferedToolCalls = /* @__PURE__ */ new Map();
   let finishReason = "unknown";
   let sawToolCalls = false;
+  let reasoningOpen = false;
   let usage = {
     inputTokens: 0,
     outputTokens: 0,
@@ -305,20 +383,45 @@ async function* transformStream(stream) {
       cacheReadTokens: 0,
       cacheWriteTokens: 0
     },
-    outputTokenDetails: {
-      reasoningTokens: 0
-    }
+    outputTokenDetails: {}
   };
   for await (const chunk of stream) {
     usage = mapUsage(chunk, usage);
+    const reasoningDeltas = extractReasoningDeltas(chunk);
+    if (reasoningDeltas.length > 0) {
+      if (!reasoningOpen) {
+        reasoningOpen = true;
+        yield {
+          type: "reasoning-start"
+        };
+      }
+      for (const delta of reasoningDeltas) {
+        yield {
+          type: "reasoning-delta",
+          text: delta
+        };
+      }
+    }
     if (chunk.text) {
+      if (reasoningOpen) {
+        reasoningOpen = false;
+        yield {
+          type: "reasoning-end"
+        };
+      }
       yield {
-        type: "content-delta",
+        type: "text-delta",
         text: chunk.text
       };
     }
     const functionCalls = chunk.functionCalls ?? [];
     if (functionCalls.length > 0) {
+      if (reasoningOpen) {
+        reasoningOpen = false;
+        yield {
+          type: "reasoning-end"
+        };
+      }
       sawToolCalls = true;
       for (const [index, functionCall] of functionCalls.entries()) {
         const mappedCall = mapFunctionCall(functionCall, index);
@@ -361,6 +464,11 @@ async function* transformStream(stream) {
       finishReason = candidateFinishReason;
     }
   }
+  if (reasoningOpen) {
+    yield {
+      type: "reasoning-end"
+    };
+  }
   for (const toolCall of bufferedToolCalls.values()) {
     yield {
       type: "tool-call-end",
@@ -376,11 +484,106 @@ async function* transformStream(stream) {
     usage
   };
 }
+function mapReasoningToConfig(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getGoogleModelCapabilities(modelId);
+  const providerConfig = asObject(options.providerOptions?.["config"]);
+  const providerThinkingConfig = asObject(providerConfig["thinkingConfig"]);
+  if (Object.keys(providerThinkingConfig).length > 0) {
+    return {};
+  }
+  if (capabilities.reasoning.thinkingParam === "thinkingLevel") {
+    return {
+      thinkingConfig: {
+        thinkingLevel: toGoogleThinkingLevel(options.reasoning.effort),
+        includeThoughts: true
+      }
+    };
+  }
+  return {
+    thinkingConfig: {
+      thinkingBudget: toGoogleThinkingBudget(options.reasoning.effort),
+      includeThoughts: true
+    }
+  };
+}
+function extractAssistantParts(response) {
+  const parts = [];
+  const seenToolCalls = /* @__PURE__ */ new Set();
+  const candidateParts = response.candidates?.[0]?.content?.parts ?? [];
+  for (const part of candidateParts) {
+    if (part.thought) {
+      const thoughtText = typeof part.text === "string" ? part.text : "";
+      if (thoughtText.length === 0) {
+        continue;
+      }
+      const thoughtSignature = typeof part.thoughtSignature === "string" ? part.thoughtSignature : void 0;
+      parts.push({
+        type: "reasoning",
+        text: thoughtText,
+        ...thoughtSignature ? {
+          providerMetadata: {
+            thoughtSignature
+          }
+        } : {}
+      });
+      continue;
+    }
+    if (part.functionCall) {
+      const toolCall = mapFunctionCall(part.functionCall, 0);
+      const key = `${toolCall.id}:${toolCall.name}`;
+      if (!seenToolCalls.has(key)) {
+        seenToolCalls.add(key);
+        parts.push({
+          type: "tool-call",
+          toolCall
+        });
+      }
+      continue;
+    }
+    if (typeof part.text === "string" && part.text.length > 0) {
+      parts.push({
+        type: "text",
+        text: part.text
+      });
+    }
+  }
+  for (const [index, functionCall] of (response.functionCalls ?? []).entries()) {
+    const toolCall = mapFunctionCall(functionCall, index);
+    const key = `${toolCall.id}:${toolCall.name}`;
+    if (seenToolCalls.has(key)) {
+      continue;
+    }
+    seenToolCalls.add(key);
+    parts.push({
+      type: "tool-call",
+      toolCall
+    });
+  }
+  if (parts.length === 0 && response.text) {
+    parts.push({
+      type: "text",
+      text: response.text
+    });
+  }
+  return parts;
+}
+function extractReasoningDeltas(response) {
+  const candidateParts = response.candidates?.[0]?.content?.parts ?? [];
+  return candidateParts.flatMap((part) => {
+    if (!part.thought || typeof part.text !== "string" || part.text.length === 0) {
+      return [];
+    }
+    return [part.text];
+  });
+}
 function mapUsage(response, fallback) {
   const inputTokens = response.usageMetadata?.promptTokenCount ?? fallback?.inputTokens ?? 0;
   const textTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
-  const reasoningTokens = response.usageMetadata?.thoughtsTokenCount ?? fallback?.outputTokenDetails.reasoningTokens ?? 0;
-  const outputTokens = textTokens + reasoningTokens;
+  const reasoningTokens = response.usageMetadata?.thoughtsTokenCount ?? fallback?.outputTokenDetails?.reasoningTokens;
+  const outputTokens = textTokens + (reasoningTokens ?? 0);
   const cacheReadTokens = response.usageMetadata?.cachedContentTokenCount ?? fallback?.inputTokenDetails.cacheReadTokens ?? 0;
   return {
     inputTokens,
@@ -390,7 +593,7 @@ function mapUsage(response, fallback) {
       cacheWriteTokens: 0
     },
     outputTokenDetails: {
-      reasoningTokens
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : {}
     }
   };
 }
@@ -498,7 +701,7 @@ async function* transformStructuredOutputStream(stream, schema, provider, toolNa
   let contentBuffer = "";
   const toolArgumentDeltas = /* @__PURE__ */ new Map();
   for await (const event of stream) {
-    if (event.type === "content-delta") {
+    if (event.type === "text-delta") {
       contentBuffer += event.text;
       yield {
         type: "object-delta",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/google-genai",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "description": "Google GenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -44,7 +44,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.4.0",
+        "@core-ai/core-ai": "^0.5.0",
         "@google/genai": "^1.42.0",
         "zod-to-json-schema": "^3.25.1"
     },