@ai-sdk/provider-utils 4.0.49 → 4.0.50

package/dist/index.mjs

@@ -693,24 +693,31 @@ function isAbortError(error) {
 
 // src/handle-fetch-error.ts
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
-var BUN_ERROR_CODES = [
+var RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
   "ConnectionRefused",
   "ConnectionClosed",
   "FailedToOpenSocket",
   "ECONNRESET",
   "ECONNREFUSED",
   "ETIMEDOUT",
-  "EPIPE"
-];
-function isBunNetworkError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const code = error.code;
-  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
-    return true;
-  }
-  return false;
+  "EPIPE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function findNetworkError(error) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error && !visited.has(current)) {
+    visited.add(current);
+    const errorWithCode = current;
+    if (typeof errorWithCode.code === "string" && RETRYABLE_NETWORK_ERROR_CODES.has(errorWithCode.code)) {
+      return errorWithCode;
+    }
+    current = current.cause;
+  }
+  return void 0;
 }
 function handleFetchError({
   error,
@@ -733,9 +740,23 @@ function handleFetchError({
       });
     }
   }
-  if (isBunNetworkError(error)) {
+  const networkError = findNetworkError(error);
+  if (networkError != null) {
+    if (APICallError.isInstance(error)) {
+      return new APICallError({
+        message: error.message,
+        cause: error.cause,
+        url: error.url,
+        requestBodyValues: error.requestBodyValues,
+        statusCode: error.statusCode,
+        responseHeaders: error.responseHeaders,
+        responseBody: error.responseBody,
+        data: error.data,
+        isRetryable: true
+      });
+    }
     return new APICallError({
-      message: `Cannot connect to API: ${error.message}`,
+      message: `Cannot connect to API: ${error instanceof Error ? error.message : networkError.message}`,
       cause: error,
       url,
       requestBodyValues,
@@ -798,7 +819,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "4.0.49" : "0.0.0-test";
+var VERSION = true ? "4.0.50" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -2842,6 +2863,62 @@ async function retryWithExponentialBackoffInternal(f, {
 // src/response-handler.ts
 import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
 var textDecoder = new TextDecoder();
+function wrapResponseBodyStream({
+  stream,
+  url,
+  requestBodyValues,
+  statusCode,
+  responseHeaders
+}) {
+  const reader = stream.getReader();
+  let readerReleased = false;
+  const releaseReader = () => {
+    if (!readerReleased) {
+      reader.releaseLock();
+      readerReleased = true;
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          releaseReader();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error) {
+        releaseReader();
+        if (isAbortError(error)) {
+          controller.error(error);
+          return;
+        }
+        controller.error(
+          handleFetchError({
+            error: new APICallError4({
+              message: "Failed to process successful response",
+              cause: error,
+              statusCode,
+              url,
+              responseHeaders,
+              requestBodyValues
+            }),
+            url,
+            requestBodyValues
+          })
+        );
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        releaseReader();
+      }
+    }
+  });
+}
 async function readResponseBodyAsText({
   response,
   url
@@ -2907,7 +2984,7 @@ var createJsonErrorResponseHandler = ({
     };
   }
 };
-var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
     throw new EmptyResponseBodyError({});
@@ -2915,7 +2992,13 @@ var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) =>
   return {
     responseHeaders,
     value: parseJsonEventStream({
-      stream: response.body,
+      stream: wrapResponseBodyStream({
+        stream: response.body,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders
+      }),
       schema: chunkSchema
     })
   };