@gullabs/google 0.8.0 → 0.8.2

package/dist/index.js

@@ -1,4 +1,4 @@
-import { zodToStandardSchema, toConfigJsonSchema, createModelRegistry, LlmError, classifyError, assertNever, computeCost, redactSecrets } from '@gullabs/core';
+import { zodToStandardSchema, toConfigJsonSchema, createModelRegistry, LlmError, assertNever, computeCost, redactSecrets, classifyError } from '@gullabs/core';
 import { z } from 'zod';
 
 // src/adapter.ts
@@ -68,6 +68,34 @@ function isGeminiCapacityError(err) {
   }
   return CAPACITY_PATTERNS.some((pattern) => pattern.test(message));
 }
+var GOOGLE_TRANSPORT_ERROR_PATTERN = /fetch failed|connection error|econnreset|econnrefused|etimedout|eai_again|epipe|socket hang up/i;
+function matchesGoogleTransportSignature(err) {
+  if (!(err instanceof Error)) return false;
+  if (GOOGLE_TRANSPORT_ERROR_PATTERN.test(err.message)) return true;
+  const code = err.code;
+  return typeof code === "string" && GOOGLE_TRANSPORT_ERROR_PATTERN.test(code);
+}
+function isGoogleTransportError(rawErr) {
+  if (matchesGoogleTransportSignature(rawErr)) return true;
+  if (rawErr instanceof Error) {
+    const cause = rawErr.cause;
+    if (matchesGoogleTransportSignature(cause)) return true;
+  }
+  return false;
+}
+function classifyGoogleError(rawErr, extra) {
+  const base = classifyError(rawErr);
+  const reclassifyAsTransport = base.kind === "unknown" && isGoogleTransportError(rawErr);
+  return new LlmError(base.message, {
+    kind: reclassifyAsTransport ? "server" : base.kind,
+    retryable: reclassifyAsTransport ? true : base.retryable,
+    ...base.httpStatus !== void 0 ? { httpStatus: base.httpStatus } : {},
+    ...base.retryAfterMs !== void 0 ? { retryAfterMs: base.retryAfterMs } : {},
+    provider: "google",
+    cause: base.cause ?? rawErr,
+    ...extra?.servedServiceTier !== void 0 ? { servedServiceTier: extra.servedServiceTier } : {}
+  });
+}
 
 // src/adapter.ts
 var ALLOWED_GOOGLE_PROVIDER_OPTION_KEYS = /* @__PURE__ */ new Set([
@@ -577,16 +605,10 @@ function geminiAdapter(opts) {
       try {
         response = await dispatch();
       } catch (rawErr) {
-        const classified = classifyError(rawErr);
-        const typed = new LlmError(classified.message, {
-          kind: classified.kind,
-          retryable: classified.retryable,
-          ...classified.httpStatus !== void 0 ? { httpStatus: classified.httpStatus } : {},
-          ...classified.retryAfterMs !== void 0 ? { retryAfterMs: classified.retryAfterMs } : {},
-          provider: "google",
-          cause: classified.cause ?? rawErr,
-          ...servedServiceTier !== void 0 ? { servedServiceTier } : {}
-        });
+        const typed = classifyGoogleError(
+          rawErr,
+          servedServiceTier !== void 0 ? { servedServiceTier } : void 0
+        );
         if (config.serviceTier === "flex" && googleProviderConfig.flexFallback !== false && isGeminiCapacityError(typed)) {
           config.serviceTier = "standard";
           servedServiceTier = "standard";
@@ -599,16 +621,7 @@ function geminiAdapter(opts) {
           try {
             response = await dispatch();
           } catch (fallbackRawErr) {
-            const fallbackClassified = classifyError(fallbackRawErr);
-            throw new LlmError(fallbackClassified.message, {
-              kind: fallbackClassified.kind,
-              retryable: fallbackClassified.retryable,
-              ...fallbackClassified.httpStatus !== void 0 ? { httpStatus: fallbackClassified.httpStatus } : {},
-              ...fallbackClassified.retryAfterMs !== void 0 ? { retryAfterMs: fallbackClassified.retryAfterMs } : {},
-              provider: "google",
-              cause: fallbackClassified.cause ?? fallbackRawErr,
-              servedServiceTier: "standard"
-            });
+            throw classifyGoogleError(fallbackRawErr, { servedServiceTier: "standard" });
           }
         } else {
           throw typed;
@@ -728,16 +741,7 @@ function geminiAdapter(opts) {
           raw: response
         };
       } catch (rawErr) {
-        if (rawErr instanceof LlmError) throw rawErr;
-        const classified = classifyError(rawErr);
-        throw new LlmError(classified.message, {
-          kind: classified.kind,
-          retryable: classified.retryable,
-          ...classified.httpStatus !== void 0 ? { httpStatus: classified.httpStatus } : {},
-          ...classified.retryAfterMs !== void 0 ? { retryAfterMs: classified.retryAfterMs } : {},
-          provider: "google",
-          cause: classified.cause ?? rawErr
-        });
+        throw classifyGoogleError(rawErr);
       }
     }
   };