@ai-sdk/provider-utils 5.0.30 → 5.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.30",
+  "version": "5.0.32",
   "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/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

@@ -149,6 +149,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.
    *