@ai-sdk/provider-utils 5.0.54 → 5.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "5.0.54",
+  "version": "5.0.55",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -42,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.22",
+    "@ai-sdk/provider": "4.0.23",
     "@standard-schema/spec": "^1.1.0",
     "@workflow/serde": "4.1.0",
     "eventsource-parser": "^3.0.8",
@@ -53,7 +53,7 @@
     "@vercel/ai-tsconfig": "0.0.0",
     "msw": "2.7.0",
     "tsdown": "^0.23.0",
-    "typescript": "5.8.3",
+    "typescript": "6.0.3",
     "zod": "3.25.76"
   },
   "peerDependencies": {

package/src/download-blob.ts

@@ -45,7 +45,10 @@ export async function downloadBlob(
     });
 
     const contentType = response.headers.get('content-type') ?? undefined;
-    return new Blob([data], contentType ? { type: contentType } : undefined);
+    return new Blob(
+      [data as Uint8Array<ArrayBuffer>],
+      contentType ? { type: contentType } : undefined,
+    );
   } catch (error) {
     if (DownloadError.isInstance(error)) {
       throw error;

package/src/map-reasoning-to-provider.ts

@@ -63,6 +63,7 @@ const DEFAULT_REASONING_BUDGET_PERCENTAGES: Record<ReasoningLevel, number> = {
   medium: 0.3,
   high: 0.6,
   xhigh: 0.9,
+  max: 0.95,
 };
 
 /**

package/src/parse-json-event-stream.ts

@@ -16,7 +16,9 @@ export function parseJsonEventStream<T>({
   schema: FlexibleSchema<T>;
 }): ReadableStream<ParseResult<T>> {
   return stream
-    .pipeThrough(new TextDecoderStream())
+    .pipeThrough(
+      new TextDecoderStream() as ReadableWritablePair<string, Uint8Array>,
+    )
     .pipeThrough(new EventSourceParserStream())
     .pipeThrough(
       new TransformStream<EventSourceMessage, ParseResult<T>>({

package/src/post-to-api.ts

@@ -102,7 +102,7 @@ export const postToApi = async <T>({
         `ai-sdk-provider-utils/${VERSION}`,
         getRuntimeEnvironmentUserAgent(),
       ),
-      body: body.content,
+      body: body.content as string | FormData | Uint8Array<ArrayBuffer> | Blob,
       signal: abortSignal,
     });
 

package/src/response-handler.ts

@@ -1,4 +1,9 @@
-import { APICallError, EmptyResponseBodyError } from '@ai-sdk/provider';
+import {
+  APICallError,
+  EmptyResponseBodyError,
+  InvalidArgumentError,
+} from '@ai-sdk/provider';
+import { DownloadError } from './download-error';
 import { extractResponseHeaders } from './extract-response-headers';
 import { handleFetchError } from './handle-fetch-error';
 import { isAbortError } from './is-abort-error';
@@ -19,6 +24,8 @@ export type ResponseHandler<RETURN_TYPE> = (options: {
 
 const textDecoder = new TextDecoder();
 
+const DEFAULT_MAX_JSON_LINE_BYTES = 64 * 1024 * 1024;
+
 function wrapResponseBodyStream({
   stream,
   url,
@@ -225,9 +232,20 @@ export const createJsonResponseHandler =
     };
   };
 
-export const createJsonLinesResponseHandler =
-  <T>(responseSchema: FlexibleSchema<T>): ResponseHandler<AsyncGenerator<T>> =>
-  async ({ response }) => {
+export const createJsonLinesResponseHandler = <T>(
+  responseSchema: FlexibleSchema<T>,
+  {
+    maxLineBytes = DEFAULT_MAX_JSON_LINE_BYTES,
+  }: { maxLineBytes?: number } = {},
+): ResponseHandler<AsyncGenerator<T>> => {
+  if (!Number.isSafeInteger(maxLineBytes) || maxLineBytes <= 0) {
+    throw new InvalidArgumentError({
+      argument: 'maxLineBytes',
+      message: 'maxLineBytes must be a positive safe integer.',
+    });
+  }
+
+  return async ({ response, url }) => {
     const responseHeaders = extractResponseHeaders(response);
 
     if (response.body == null) {
@@ -239,20 +257,28 @@ export const createJsonLinesResponseHandler =
       value: parseJsonLines({
         stream: response.body,
         schema: responseSchema,
+        url,
+        maxLineBytes,
       }),
     };
   };
+};
 
 async function* parseJsonLines<T>({
   stream,
   schema,
+  url,
+  maxLineBytes,
 }: {
   stream: ReadableStream<Uint8Array>;
   schema: FlexibleSchema<T>;
+  url: string;
+  maxLineBytes: number;
 }): AsyncGenerator<T> {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
   let buffer = '';
+  let lineBytes = 0;
   let finished = false;
 
   try {
@@ -265,18 +291,37 @@ async function* parseJsonLines<T>({
         break;
       }
 
-      buffer += decoder.decode(value, { stream: true });
+      let offset = 0;
+      while (offset < value.length) {
+        const lineEnd = value.indexOf(10, offset);
+        const segmentEnd = lineEnd === -1 ? value.length : lineEnd;
 
-      let lineEnd = buffer.indexOf('\n');
-      while (lineEnd !== -1) {
-        const line = buffer.slice(0, lineEnd).replace(/\r$/, '');
-        buffer = buffer.slice(lineEnd + 1);
+        // Bound each line before decoding it, excluding the newline byte.
+        lineBytes += segmentEnd - offset;
+        if (lineBytes > maxLineBytes) {
+          throw new DownloadError({
+            message: `JSON Lines response exceeded maximum line size of ${maxLineBytes} bytes.`,
+            url,
+          });
+        }
+
+        const decodeEnd = lineEnd === -1 ? segmentEnd : lineEnd + 1;
+        buffer += decoder.decode(value.subarray(offset, decodeEnd), {
+          stream: true,
+        });
+
+        if (lineEnd === -1) {
+          break;
+        }
+
+        const line = buffer.slice(0, -1).replace(/\r$/, '');
+        buffer = '';
+        lineBytes = 0;
+        offset = decodeEnd;
 
         if (line.trim().length > 0) {
           yield await parseJSON({ text: line, schema });
         }
-
-        lineEnd = buffer.indexOf('\n');
       }
     }
 

package/src/streaming-tool-call-tracker.ts

@@ -128,6 +128,7 @@ export class StreamingToolCallTracker<
       typeof wireName === 'string' && wireName.trim().length === 0;
     const wireId = this.getNonBlankString(toolCallDelta.id);
     const name = this.getNonBlankString(wireName);
+    const argumentsDelta = toolCallDelta.function?.arguments;
     const { index } = toolCallDelta;
 
     const resolution = this.resolveToolCall({
@@ -135,8 +136,9 @@ export class StreamingToolCallTracker<
       index,
       name,
       hasExplicitCallStart:
-        name != null &&
-        startsWithStructuredValue(toolCallDelta.function?.arguments),
+        name != null && startsWithStructuredValue(argumentsDelta),
+      hasEmptyArguments:
+        argumentsDelta == null || argumentsDelta.trim().length === 0,
     });
 
     if (resolution.kind === 'ambiguous') {
@@ -199,6 +201,7 @@ export class StreamingToolCallTracker<
    * | known | matching | any | matching call, new call, or ambiguity |
    * | known | conflicting | named | new call |
    * | unseen | matching | structured start | new call |
+   * | unseen | matching | named empty arguments | incomplete call, new call, or ambiguity |
    * | unseen | matching | continuation | matching call or ambiguity |
    * | absent | matching | any | matching call, new call, or ambiguity |
    * | absent | absent | named | new call |
@@ -209,11 +212,13 @@ export class StreamingToolCallTracker<
     index,
     name,
     hasExplicitCallStart,
+    hasEmptyArguments,
   }: {
     wireId: string | undefined;
     index: number | null | undefined;
     name: string | undefined;
     hasExplicitCallStart: boolean;
+    hasEmptyArguments: boolean;
   }): ToolCallResolution {
     const indexedToolCalls =
       index != null ? this.toolCallsByIndex.get(index) : undefined;
@@ -268,13 +273,16 @@ export class StreamingToolCallTracker<
       }
 
       if (matchingIndexedToolCalls.length > 0) {
-        // A previously unseen ID plus a named structured argument start is
-        // stronger evidence of a distinct call than a reused index/name. This
-        // also keeps interleaved same-name calls separate while still allowing
-        // IDs to change on ordinary continuation fragments.
+        // A named structured start with an unseen ID identifies a new call.
+        // Empty arguments can also occur when a continuation changes its ID.
+        // Keep the incomplete matching call in that case, and start a new call
+        // only after the matching structured arguments are complete.
         return hasExplicitCallStart
           ? { kind: 'new' }
-          : this.resolveMatchingToolCall(matchingIndexedToolCalls, false);
+          : this.resolveMatchingToolCall(
+              matchingIndexedToolCalls,
+              name != null && hasEmptyArguments,
+            );
       }
 
       return { kind: 'new' };
@@ -297,12 +305,7 @@ export class StreamingToolCallTracker<
     const unfinishedToolCalls = this.toolCalls.filter(
       toolCall => !toolCall.hasFinished,
     );
-    if (unfinishedToolCalls.length === 1) {
-      return { kind: 'existing', toolCall: unfinishedToolCalls[0] };
-    }
-    return unfinishedToolCalls.length > 1
-      ? { kind: 'ambiguous' }
-      : { kind: 'new' };
+    return this.resolveMatchingToolCall(unfinishedToolCalls, false);
   }
 
   private filterToolCallsByName(
@@ -326,26 +329,28 @@ export class StreamingToolCallTracker<
       return { kind: 'new' };
     }
 
-    if (!hasExplicitCallStart) {
-      return toolCalls.length === 1
-        ? { kind: 'existing', toolCall: toolCalls[0] }
-        : { kind: 'ambiguous' };
-    }
-
     // A repeated name can occur on continuations. A fresh structured
     // argument prefix is evidence of another call only after the matching call
-    // has completed its own structured argument payload.
+    // has completed its own structured argument payload. When labels are
+    // missing, a sole call without a complete structured payload is the only
+    // viable continuation target.
     const continuableToolCalls = toolCalls.filter(
       toolCall => !toolCall.argumentState.hasCompleteStructuredValue,
     );
 
+    if (!hasExplicitCallStart && toolCalls.length === 1) {
+      return { kind: 'existing', toolCall: toolCalls[0] };
+    }
+
     if (continuableToolCalls.length === 1) {
       return { kind: 'existing', toolCall: continuableToolCalls[0] };
     }
 
-    return continuableToolCalls.length > 1
-      ? { kind: 'ambiguous' }
-      : { kind: 'new' };
+    if (continuableToolCalls.length > 1 || !hasExplicitCallStart) {
+      return { kind: 'ambiguous' };
+    }
+
+    return { kind: 'new' };
   }
 
   private processNewToolCall(