@core-ai/google-genai 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -30,7 +30,6 @@ type GoogleReasoningMetadata = {
 type GoogleModelCapabilities = {
     reasoning: ModelCapabilities['reasoning'] & {
         thinkingParam: 'thinkingLevel' | 'thinkingBudget';
-        canDisableThinking: boolean;
     };
 };
 declare function getGoogleModelCapabilities(modelId: string): GoogleModelCapabilities;

package/dist/index.js

@@ -30,25 +30,25 @@ var ALL_EFFORTS = [
 function createCapabilities(config) {
   return {
     reasoning: {
-      supported: true,
+      mode: config.mode,
       supportedEfforts: ALL_EFFORTS,
       restrictsSamplingParams: false,
-      thinkingParam: config.thinkingParam,
-      canDisableThinking: config.canDisableThinking
+      supportedToolChoices: ["auto", "none", "required", "tool"],
+      thinkingParam: config.thinkingParam
     }
   };
 }
 var DEFAULT_CAPABILITIES = createCapabilities({
   thinkingParam: "thinkingBudget",
-  canDisableThinking: true
+  mode: "optional"
 });
 var REQUIRED_THINKING_BUDGET_CAPABILITIES = createCapabilities({
   thinkingParam: "thinkingBudget",
-  canDisableThinking: false
+  mode: "always-on"
 });
 var THINKING_LEVEL_CAPABILITIES = createCapabilities({
   thinkingParam: "thinkingLevel",
-  canDisableThinking: false
+  mode: "always-on"
 });
 var MODEL_CAPABILITIES = {
   "gemini-3.1-pro": THINKING_LEVEL_CAPABILITIES,
@@ -683,17 +683,133 @@ function mapUsage(response, fallback) {
 
 // src/google-error.ts
 import { ApiError } from "@google/genai";
-import { ProviderError } from "@core-ai/core-ai";
+import {
+  AbortedError,
+  ContextLengthExceededError,
+  ModelOverloadedError,
+  ProviderError,
+  RateLimitError,
+  ServiceUnavailableError,
+  getErrorMessage,
+  getHttpStatusCode,
+  getRetryAfterSecondsFromError,
+  isAbortErrorByName,
+  isRateLimitStatus,
+  isTransientUnavailableStatus
+} from "@core-ai/core-ai";
+var OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
 function wrapGoogleError(error, provider = "google") {
-  if (error instanceof ApiError) {
-    return new ProviderError(error.message, provider, error.status, error);
+  if (isGoogleAbortError(error)) {
+    return new AbortedError(error, provider);
   }
-  return new ProviderError(
-    error instanceof Error ? error.message : String(error),
-    provider,
-    void 0,
-    error
+  const message = getErrorMessage(error);
+  const statusCode = error instanceof ApiError ? error.status : getHttpStatusCode(error, ["status"]);
+  const body = tryParseGoogleApiErrorBody(message);
+  const effectiveHttp = statusCode ?? toNumericHttpCode(body);
+  const options = { statusCode: effectiveHttp, cause: error };
+  const status = body?.status?.toUpperCase();
+  const combinedText = `${body?.message ?? ""} ${message}`;
+  const contextLength = getContextLengthDetails(combinedText);
+  if (contextLength) {
+    return new ContextLengthExceededError(message, provider, {
+      ...options,
+      ...contextLength
+    });
+  }
+  if (indicatesGoogleOverload(combinedText, effectiveHttp)) {
+    return new ModelOverloadedError(message, provider, options);
+  }
+  if (isGoogleRateLimit(effectiveHttp, status)) {
+    return new RateLimitError(message, provider, {
+      ...options,
+      retryAfterSeconds: getRetryAfterSecondsFromError(error) ?? parseRetryAfterFromMessage(combinedText)
+    });
+  }
+  if (status === "UNAVAILABLE" || isTransientUnavailableStatus(effectiveHttp)) {
+    return new ServiceUnavailableError(message, provider, options);
+  }
+  return new ProviderError(message, provider, options);
+}
+function isGoogleAbortError(error) {
+  if (isAbortErrorByName(error)) {
+    return true;
+  }
+  const message = getErrorMessage(error).toLowerCase();
+  return message.includes("the operation was aborted") || message.includes("this operation was aborted") || message.includes("request aborted") || message.includes("the request was aborted");
+}
+function isGoogleRateLimit(statusCode, status) {
+  return isRateLimitStatus(statusCode) || status === "RESOURCE_EXHAUSTED";
+}
+function indicatesGoogleOverload(text, statusCode) {
+  if (statusCode !== void 0 && !OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES.has(statusCode)) {
+    return false;
+  }
+  const lower = text.toLowerCase();
+  return /\boverloaded\b/.test(lower) || /\bhigh demand\b/.test(lower) || /\bthrottled\b/.test(lower) || /\brunning out of capacity\b/.test(lower) || /\bno capacity available\b/.test(lower);
+}
+function getContextLengthDetails(text) {
+  const match = text.match(
+    /input token count \((\d+)\) exceeds the maximum number of tokens allowed \((\d+)\)/i
+  );
+  if (match) {
+    const actualTokens = match[1];
+    const maxTokens = match[2];
+    if (actualTokens !== void 0 && maxTokens !== void 0) {
+      return {
+        maxTokens: parseInt(maxTokens, 10),
+        actualTokens: parseInt(actualTokens, 10)
+      };
+    }
+  }
+  const alternate = text.match(
+    /input token count is (\d+) but model only supports up to (\d+)/i
   );
+  if (alternate) {
+    const actualTokens = alternate[1];
+    const maxTokens = alternate[2];
+    if (actualTokens !== void 0 && maxTokens !== void 0) {
+      return {
+        maxTokens: parseInt(maxTokens, 10),
+        actualTokens: parseInt(actualTokens, 10)
+      };
+    }
+  }
+  if (/exceeds the maximum number of tokens allowed/i.test(text) || /unable to submit request because the input token count/i.test(text)) {
+    return {};
+  }
+  return void 0;
+}
+function tryParseGoogleApiErrorBody(message) {
+  const jsonStart = message.indexOf("{");
+  const candidate = jsonStart >= 0 ? message.slice(jsonStart) : message;
+  try {
+    const parsed = JSON.parse(candidate);
+    if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object") {
+      return parsed.error;
+    }
+  } catch {
+  }
+  return null;
+}
+function parseRetryAfterFromMessage(text) {
+  const match = text.match(/please retry in (\d+)\s*s/i);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  const seconds = parseInt(match[1], 10);
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+function toNumericHttpCode(body) {
+  if (body?.code === void 0) {
+    return void 0;
+  }
+  if (typeof body.code === "number" && Number.isFinite(body.code)) {
+    return body.code;
+  }
+  if (typeof body.code === "string" && /^\d+$/.test(body.code)) {
+    return parseInt(body.code, 10);
+  }
+  return void 0;
 }
 
 // src/chat-model.ts

package/package.json

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