@ai-sdk/provider-utils 5.0.30 → 5.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.30",
+  "version": "5.0.33",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/create-provider-stream-error.ts

@@ -0,0 +1,53 @@
+const marker = Symbol.for('vercel.ai.providerStreamError');
+
+export type ProviderStreamError = {
+  readonly message: string;
+  readonly type?: string;
+  readonly code?: string | number;
+  readonly statusCode?: number;
+  readonly isRetryable?: boolean;
+  readonly data: unknown;
+};
+
+/**
+ * Adds provider-owned status and retry metadata to a stream error payload
+ * without requiring provider packages to depend on AI SDK Core.
+ */
+export function createProviderStreamError({
+  message,
+  type,
+  code,
+  statusCode,
+  isRetryable,
+  data,
+}: {
+  message: string;
+  type?: string;
+  code?: string | number;
+  statusCode?: number;
+  isRetryable?: boolean;
+  data: unknown;
+}): ProviderStreamError {
+  const error = {
+    message,
+    type,
+    code,
+    statusCode,
+    isRetryable,
+    data,
+  };
+
+  Object.defineProperty(error, marker, { value: true });
+
+  return error;
+}
+
+export function isProviderStreamError(
+  error: unknown,
+): error is ProviderStreamError {
+  return (
+    typeof error === 'object' &&
+    error != null &&
+    (error as Record<symbol, unknown>)[marker] === true
+  );
+}

package/src/embedding-model-capabilities.ts

@@ -0,0 +1,9 @@
+/**
+ * Symbol for exposing the UTF-8 input byte budget of an embedding model.
+ *
+ * This capability is experimental and intentionally lives outside the versioned
+ * embedding model specification.
+ */
+export const EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL = Symbol.for(
+  'vercel.ai.embeddingModel.maxInputBytesPerCall',
+);

package/src/handle-fetch-error.ts

@@ -3,7 +3,7 @@ import { isAbortError } from './is-abort-error';
 
 const FETCH_FAILED_ERROR_MESSAGES = ['fetch failed', 'failed to fetch'];
 
-const BUN_ERROR_CODES = [
+const RETRYABLE_NETWORK_ERROR_CODES = new Set([
   'ConnectionRefused',
   'ConnectionClosed',
   'FailedToOpenSocket',
@@ -11,19 +11,33 @@ const BUN_ERROR_CODES = [
   'ECONNREFUSED',
   'ETIMEDOUT',
   'EPIPE',
-];
+  'UND_ERR_SOCKET',
+  'UND_ERR_HEADERS_TIMEOUT',
+  'UND_ERR_BODY_TIMEOUT',
+  'UND_ERR_CONNECT_TIMEOUT',
+]);
 
-function isBunNetworkError(error: unknown): error is Error & { code?: string } {
-  if (!(error instanceof Error)) {
-    return false;
-  }
+function findNetworkError(
+  error: unknown,
+): (Error & { code?: unknown }) | undefined {
+  const visited = new Set<Error>();
+  let current = error;
+
+  while (current instanceof Error && !visited.has(current)) {
+    visited.add(current);
 
-  const code = (error as any).code;
-  if (typeof code === 'string' && BUN_ERROR_CODES.includes(code)) {
-    return true;
+    const errorWithCode = current as Error & { code?: unknown };
+    if (
+      typeof errorWithCode.code === 'string' &&
+      RETRYABLE_NETWORK_ERROR_CODES.has(errorWithCode.code)
+    ) {
+      return errorWithCode;
+    }
+
+    current = (current as Error & { cause?: unknown }).cause;
   }
 
-  return false;
+  return undefined;
 }
 
 export function handleFetchError({
@@ -58,9 +72,27 @@ export 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,

package/src/index.ts

@@ -15,6 +15,11 @@ export {
   createToolNameMapping,
   type ToolNameMapping,
 } from './create-tool-name-mapping';
+export {
+  createProviderStreamError,
+  isProviderStreamError,
+  type ProviderStreamError,
+} from './create-provider-stream-error';
 export * from './delay';
 export { DelayedPromise } from './delayed-promise';
 export {
@@ -24,6 +29,7 @@ export {
 } from './detect-media-type';
 export { downloadBlob } from './download-blob';
 export { DownloadError } from './download-error';
+export { EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL } from './embedding-model-capabilities';
 export { fetchWithValidatedRedirects } from './fetch-with-validated-redirects';
 export { extractLines } from './extract-lines';
 export * from './extract-response-headers';
@@ -54,6 +60,7 @@ export {
 export { type MaybePromiseLike } from './maybe-promise-like';
 export { mediaTypeToExtension } from './media-type-to-extension';
 export { normalizeHeaders } from './normalize-headers';
+export { normalizeBatchRequestCounts } from './normalize-batch-request-counts';
 export * from './parse-json';
 export { parseJsonEventStream } from './parse-json-event-stream';
 export { parseProviderOptions } from './parse-provider-options';

package/src/normalize-batch-request-counts.ts

@@ -0,0 +1,42 @@
+import type { Experimental_BatchV4Status as BatchV4Status } from '@ai-sdk/provider';
+
+/**
+ * Normalizes complete batch request counts.
+ *
+ * Returns `undefined` when any count is missing, is not a non-negative safe
+ * integer, or when the item counts do not add up to the total.
+ */
+export function normalizeBatchRequestCounts({
+  total,
+  pending,
+  completed,
+  failed,
+}: {
+  total: number | null | undefined;
+  pending: number | null | undefined;
+  completed: number | null | undefined;
+  failed: number | null | undefined;
+}): BatchV4Status['requestCounts'] | undefined {
+  if (
+    isNonNegativeSafeInteger(total) &&
+    isNonNegativeSafeInteger(pending) &&
+    isNonNegativeSafeInteger(completed) &&
+    isNonNegativeSafeInteger(failed) &&
+    pending + completed + failed === total
+  ) {
+    return {
+      total,
+      pending,
+      completed,
+      failed,
+    };
+  }
+
+  return undefined;
+}
+
+function isNonNegativeSafeInteger(
+  value: number | null | undefined,
+): value is number {
+  return value != null && Number.isSafeInteger(value) && value >= 0;
+}

package/src/response-handler.ts

@@ -1,5 +1,7 @@
 import { APICallError, EmptyResponseBodyError } from '@ai-sdk/provider';
 import { extractResponseHeaders } from './extract-response-headers';
+import { handleFetchError } from './handle-fetch-error';
+import { isAbortError } from './is-abort-error';
 import { parseJSON, safeParseJSON, type ParseResult } from './parse-json';
 import { parseJsonEventStream } from './parse-json-event-stream';
 import { readResponseWithSizeLimit } from './read-response-with-size-limit';
@@ -17,6 +19,74 @@ export type ResponseHandler<RETURN_TYPE> = (options: {
 
 const textDecoder = new TextDecoder();
 
+function wrapResponseBodyStream({
+  stream,
+  url,
+  requestBodyValues,
+  statusCode,
+  responseHeaders,
+}: {
+  stream: ReadableStream<Uint8Array>;
+  url: string;
+  requestBodyValues: unknown;
+  statusCode: number;
+  responseHeaders: Record<string, string>;
+}): ReadableStream<Uint8Array> {
+  const reader = stream.getReader();
+  let readerReleased = false;
+
+  const releaseReader = () => {
+    if (!readerReleased) {
+      reader.releaseLock();
+      readerReleased = true;
+    }
+  };
+
+  return new ReadableStream<Uint8Array>({
+    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 APICallError({
+              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,
@@ -102,7 +172,7 @@ export const createEventSourceResponseHandler =
   <T>(
     chunkSchema: FlexibleSchema<T>,
   ): ResponseHandler<ReadableStream<ParseResult<T>>> =>
-  async ({ response }: { response: Response }) => {
+  async ({ response, url, requestBodyValues }) => {
     const responseHeaders = extractResponseHeaders(response);
 
     if (response.body == null) {
@@ -112,7 +182,13 @@ export const createEventSourceResponseHandler =
     return {
       responseHeaders,
       value: parseJsonEventStream({
-        stream: response.body,
+        stream: wrapResponseBodyStream({
+          stream: response.body,
+          url,
+          requestBodyValues,
+          statusCode: response.status,
+          responseHeaders,
+        }),
         schema: chunkSchema,
       }),
     };
@@ -149,6 +225,73 @@ export const createJsonResponseHandler =
     };
   };
 
+export const createJsonLinesResponseHandler =
+  <T>(responseSchema: FlexibleSchema<T>): ResponseHandler<AsyncGenerator<T>> =>
+  async ({ response }) => {
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (response.body == null) {
+      throw new EmptyResponseBodyError({});
+    }
+
+    return {
+      responseHeaders,
+      value: parseJsonLines({
+        stream: response.body,
+        schema: responseSchema,
+      }),
+    };
+  };
+
+async function* parseJsonLines<T>({
+  stream,
+  schema,
+}: {
+  stream: ReadableStream<Uint8Array>;
+  schema: FlexibleSchema<T>;
+}): AsyncGenerator<T> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let finished = false;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        finished = true;
+        buffer += decoder.decode();
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+
+      let lineEnd = buffer.indexOf('\n');
+      while (lineEnd !== -1) {
+        const line = buffer.slice(0, lineEnd).replace(/\r$/, '');
+        buffer = buffer.slice(lineEnd + 1);
+
+        if (line.trim().length > 0) {
+          yield await parseJSON({ text: line, schema });
+        }
+
+        lineEnd = buffer.indexOf('\n');
+      }
+    }
+
+    const finalLine = buffer.replace(/\r$/, '');
+    if (finalLine.trim().length > 0) {
+      yield await parseJSON({ text: finalLine, schema });
+    }
+  } finally {
+    if (!finished) {
+      await reader.cancel().catch(() => {});
+    }
+    reader.releaseLock();
+  }
+}
+
 export const createBinaryResponseHandler =
   (): ResponseHandler<Uint8Array> =>
   async ({ response, url, requestBodyValues }) => {

package/src/types/tool-approval-request.ts

@@ -14,6 +14,11 @@ export type ToolApprovalRequest = {
    */
   toolCallId: string;
 
+  /**
+   * Reason why the tool call requires approval.
+   */
+  reason?: string;
+
   /**
    * Flag indicating whether the tool was automatically approved or denied.
    *