@ai-sdk/provider-utils 3.0.35 → 3.0.36

package/dist/index.mjs

@@ -583,6 +583,32 @@ function isAbortError(error) {
 
 // src/handle-fetch-error.ts
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "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,
   url,
@@ -604,6 +630,29 @@ function handleFetchError({
       });
     }
   }
+  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 instanceof Error ? error.message : networkError.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
   return error;
 }
 
@@ -660,7 +709,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "3.0.35" : "0.0.0-test";
+var VERSION = true ? "3.0.36" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -1312,6 +1361,62 @@ async function resolve(value) {
 // 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
@@ -1377,7 +1482,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({});
@@ -1385,7 +1490,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
     })
   };