ai 6.0.33 → 6.0.35

package/src/ui-message-stream/ui-message-chunks.ts

@@ -0,0 +1,344 @@
+import { z } from 'zod/v4';
+import {
+  ProviderMetadata,
+  providerMetadataSchema,
+} from '../types/provider-metadata';
+import { FinishReason } from '../types/language-model';
+import {
+  InferUIMessageData,
+  InferUIMessageMetadata,
+  UIDataTypes,
+  UIMessage,
+} from '../ui/ui-messages';
+import { ValueOf } from '../util/value-of';
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+
+export const uiMessageChunkSchema = lazySchema(() =>
+  zodSchema(
+    z.union([
+      z.strictObject({
+        type: z.literal('text-start'),
+        id: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('text-delta'),
+        id: z.string(),
+        delta: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('text-end'),
+        id: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('error'),
+        errorText: z.string(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-input-start'),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        providerExecuted: z.boolean().optional(),
+        dynamic: z.boolean().optional(),
+        title: z.string().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-input-delta'),
+        toolCallId: z.string(),
+        inputTextDelta: z.string(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-input-available'),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        input: z.unknown(),
+        providerExecuted: z.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        dynamic: z.boolean().optional(),
+        title: z.string().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-input-error'),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        input: z.unknown(),
+        providerExecuted: z.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        dynamic: z.boolean().optional(),
+        errorText: z.string(),
+        title: z.string().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-approval-request'),
+        approvalId: z.string(),
+        toolCallId: z.string(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-output-available'),
+        toolCallId: z.string(),
+        output: z.unknown(),
+        providerExecuted: z.boolean().optional(),
+        dynamic: z.boolean().optional(),
+        preliminary: z.boolean().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-output-error'),
+        toolCallId: z.string(),
+        errorText: z.string(),
+        providerExecuted: z.boolean().optional(),
+        dynamic: z.boolean().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('tool-output-denied'),
+        toolCallId: z.string(),
+      }),
+      z.strictObject({
+        type: z.literal('reasoning-start'),
+        id: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('reasoning-delta'),
+        id: z.string(),
+        delta: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('reasoning-end'),
+        id: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('source-url'),
+        sourceId: z.string(),
+        url: z.string(),
+        title: z.string().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('source-document'),
+        sourceId: z.string(),
+        mediaType: z.string(),
+        title: z.string(),
+        filename: z.string().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.literal('file'),
+        url: z.string(),
+        mediaType: z.string(),
+        providerMetadata: providerMetadataSchema.optional(),
+      }),
+      z.strictObject({
+        type: z.custom<`data-${string}`>(
+          (value): value is `data-${string}` =>
+            typeof value === 'string' && value.startsWith('data-'),
+          { message: 'Type must start with "data-"' },
+        ),
+        id: z.string().optional(),
+        data: z.unknown(),
+        transient: z.boolean().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('start-step'),
+      }),
+      z.strictObject({
+        type: z.literal('finish-step'),
+      }),
+      z.strictObject({
+        type: z.literal('start'),
+        messageId: z.string().optional(),
+        messageMetadata: z.unknown().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('finish'),
+        finishReason: z
+          .enum([
+            'stop',
+            'length',
+            'content-filter',
+            'tool-calls',
+            'error',
+            'other',
+          ] as const satisfies readonly FinishReason[])
+          .optional(),
+        messageMetadata: z.unknown().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('abort'),
+        reason: z.string().optional(),
+      }),
+      z.strictObject({
+        type: z.literal('message-metadata'),
+        messageMetadata: z.unknown(),
+      }),
+    ]),
+  ),
+);
+
+export type DataUIMessageChunk<DATA_TYPES extends UIDataTypes> = ValueOf<{
+  [NAME in keyof DATA_TYPES & string]: {
+    type: `data-${NAME}`;
+    id?: string;
+    data: DATA_TYPES[NAME];
+    transient?: boolean;
+  };
+}>;
+
+export type UIMessageChunk<
+  METADATA = unknown,
+  DATA_TYPES extends UIDataTypes = UIDataTypes,
+> =
+  | {
+      type: 'text-start';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'text-delta';
+      delta: string;
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'text-end';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'reasoning-start';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'reasoning-delta';
+      id: string;
+      delta: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'reasoning-end';
+      id: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'error';
+      errorText: string;
+    }
+  | {
+      type: 'tool-input-available';
+      toolCallId: string;
+      toolName: string;
+      input: unknown;
+      providerExecuted?: boolean;
+      providerMetadata?: ProviderMetadata;
+      dynamic?: boolean;
+      title?: string;
+    }
+  | {
+      type: 'tool-input-error';
+      toolCallId: string;
+      toolName: string;
+      input: unknown;
+      providerExecuted?: boolean;
+      providerMetadata?: ProviderMetadata;
+      dynamic?: boolean;
+      errorText: string;
+      title?: string;
+    }
+  | {
+      type: 'tool-approval-request';
+      approvalId: string;
+      toolCallId: string;
+    }
+  | {
+      type: 'tool-output-available';
+      toolCallId: string;
+      output: unknown;
+      providerExecuted?: boolean;
+      dynamic?: boolean;
+      preliminary?: boolean;
+    }
+  | {
+      type: 'tool-output-error';
+      toolCallId: string;
+      errorText: string;
+      providerExecuted?: boolean;
+      dynamic?: boolean;
+    }
+  | {
+      type: 'tool-output-denied';
+      toolCallId: string;
+    }
+  | {
+      type: 'tool-input-start';
+      toolCallId: string;
+      toolName: string;
+      providerExecuted?: boolean;
+      dynamic?: boolean;
+      title?: string;
+    }
+  | {
+      type: 'tool-input-delta';
+      toolCallId: string;
+      inputTextDelta: string;
+    }
+  | {
+      type: 'source-url';
+      sourceId: string;
+      url: string;
+      title?: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'source-document';
+      sourceId: string;
+      mediaType: string;
+      title: string;
+      filename?: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | {
+      type: 'file';
+      url: string;
+      mediaType: string;
+      providerMetadata?: ProviderMetadata;
+    }
+  | DataUIMessageChunk<DATA_TYPES>
+  | {
+      type: 'start-step';
+    }
+  | {
+      type: 'finish-step';
+    }
+  | {
+      type: 'start';
+      messageId?: string;
+      messageMetadata?: METADATA;
+    }
+  | {
+      type: 'finish';
+      finishReason?: FinishReason;
+      messageMetadata?: METADATA;
+    }
+  | {
+      type: 'abort';
+      reason?: string;
+    }
+  | {
+      type: 'message-metadata';
+      messageMetadata: METADATA;
+    };
+
+export function isDataUIMessageChunk(
+  chunk: UIMessageChunk,
+): chunk is DataUIMessageChunk<UIDataTypes> {
+  return chunk.type.startsWith('data-');
+}
+
+export type InferUIMessageChunk<T extends UIMessage> = UIMessageChunk<
+  InferUIMessageMetadata<T>,
+  InferUIMessageData<T>
+>;

package/src/ui-message-stream/ui-message-stream-headers.ts

@@ -0,0 +1,7 @@
+export const UI_MESSAGE_STREAM_HEADERS = {
+  'content-type': 'text/event-stream',
+  'cache-control': 'no-cache',
+  connection: 'keep-alive',
+  'x-vercel-ai-ui-message-stream': 'v1',
+  'x-accel-buffering': 'no', // disable nginx buffering
+};

package/src/ui-message-stream/ui-message-stream-on-finish-callback.ts

@@ -0,0 +1,32 @@
+import { FinishReason } from '../types/language-model';
+import { UIMessage } from '../ui/ui-messages';
+
+export type UIMessageStreamOnFinishCallback<UI_MESSAGE extends UIMessage> =
+  (event: {
+    /**
+     * The updated list of UI messages.
+     */
+    messages: UI_MESSAGE[];
+
+    /**
+     * Indicates whether the response message is a continuation of the last original message,
+     * or if a new message was created.
+     */
+    isContinuation: boolean;
+
+    /**
+     * Indicates whether the stream was aborted.
+     */
+    isAborted: boolean;
+
+    /**
+     * The message that was sent to the client as a response
+     * (including the original message if it was extended).
+     */
+    responseMessage: UI_MESSAGE;
+
+    /**
+     * The reason why the generation finished.
+     */
+    finishReason?: FinishReason;
+  }) => PromiseLike<void> | void;

package/src/ui-message-stream/ui-message-stream-response-init.ts

@@ -0,0 +1,5 @@
+export type UIMessageStreamResponseInit = ResponseInit & {
+  consumeSseStream?: (options: {
+    stream: ReadableStream<string>;
+  }) => PromiseLike<void> | void;
+};

package/src/ui-message-stream/ui-message-stream-writer.ts

@@ -0,0 +1,24 @@
+import { UIMessage } from '../ui';
+import { ErrorHandler } from '../util/error-handler';
+import { InferUIMessageChunk } from './ui-message-chunks';
+
+export interface UIMessageStreamWriter<
+  UI_MESSAGE extends UIMessage = UIMessage,
+> {
+  /**
+   * Appends a data stream part to the stream.
+   */
+  write(part: InferUIMessageChunk<UI_MESSAGE>): void;
+
+  /**
+   * Merges the contents of another stream to this stream.
+   */
+  merge(stream: ReadableStream<InferUIMessageChunk<UI_MESSAGE>>): void;
+
+  /**
+   * Error handler that is used by the data stream writer.
+   * This is intended for forwarding when merging streams
+   * to prevent duplicated error masking.
+   */
+  onError: ErrorHandler | undefined;
+}

package/src/util/as-array.ts

@@ -0,0 +1,3 @@
+export function asArray<T>(value: T | T[] | undefined): T[] {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}

package/src/util/async-iterable-stream.test.ts

@@ -0,0 +1,241 @@
+import {
+  convertArrayToReadableStream,
+  convertAsyncIterableToArray,
+  convertReadableStreamToArray,
+} from '@ai-sdk/provider-utils/test';
+import { createAsyncIterableStream } from './async-iterable-stream';
+import { describe, it, expect } from 'vitest';
+
+describe('createAsyncIterableStream()', () => {
+  it('should read all chunks from a non-empty stream using async iteration', async () => {
+    const source = convertArrayToReadableStream(['chunk1', 'chunk2', 'chunk3']);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    expect(await convertAsyncIterableToArray(asyncIterableStream)).toEqual([
+      'chunk1',
+      'chunk2',
+      'chunk3',
+    ]);
+  });
+
+  it('should handle an empty stream gracefully', async () => {
+    const source = convertArrayToReadableStream<string>([]);
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    expect(await convertAsyncIterableToArray(asyncIterableStream)).toEqual([]);
+  });
+
+  it('should maintain ReadableStream functionality', async () => {
+    const source = convertArrayToReadableStream(['chunk1', 'chunk2', 'chunk3']);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    expect(await convertReadableStreamToArray(asyncIterableStream)).toEqual([
+      'chunk1',
+      'chunk2',
+      'chunk3',
+    ]);
+  });
+
+  it('should cancel stream on early exit from for-await loop', async () => {
+    let streamCancelled = false;
+
+    const source = new ReadableStream({
+      start(controller) {
+        controller.enqueue('chunk1');
+        controller.enqueue('chunk2');
+        controller.enqueue('chunk3');
+      },
+      cancel() {
+        streamCancelled = true;
+      },
+    });
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    const collected: string[] = [];
+    for await (const chunk of asyncIterableStream) {
+      collected.push(chunk);
+      if (chunk === 'chunk2') {
+        break;
+      }
+    }
+
+    expect(collected).toEqual(['chunk1', 'chunk2']);
+    expect(streamCancelled).toBe(true);
+  });
+
+  it('should cancel stream when exception thrown inside for-await loop', async () => {
+    let streamCancelled = false;
+
+    const source = new ReadableStream({
+      start(controller) {
+        controller.enqueue('chunk1');
+        controller.enqueue('chunk2');
+        controller.enqueue('chunk3');
+      },
+      cancel() {
+        streamCancelled = true;
+      },
+    });
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    const collected: string[] = [];
+    await expect(async () => {
+      for await (const chunk of asyncIterableStream) {
+        collected.push(chunk);
+        if (chunk === 'chunk2') {
+          throw new Error('Test error');
+        }
+      }
+    }).rejects.toThrow('Test error');
+
+    expect(collected).toEqual(['chunk1', 'chunk2']);
+    expect(streamCancelled).toBe(true);
+  });
+
+  it('should not cancel stream when exception thrown inside for-await loop', async () => {
+    let streamCancelled = false;
+
+    const source = new ReadableStream({
+      start(controller) {
+        controller.enqueue('chunk1');
+        controller.enqueue('chunk2');
+        controller.enqueue('chunk3');
+        controller.close();
+      },
+      cancel() {
+        streamCancelled = true;
+      },
+    });
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    expect(await convertAsyncIterableToArray(asyncIterableStream)).toEqual([
+      'chunk1',
+      'chunk2',
+      'chunk3',
+    ]);
+
+    expect(streamCancelled).toBe(false);
+  });
+
+  it('should not allow iterating twice after breaking', async () => {
+    const source = convertArrayToReadableStream(['chunk1', 'chunk2', 'chunk3']);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    const collected: string[] = [];
+    for await (const chunk of asyncIterableStream) {
+      collected.push(chunk);
+      if (chunk === 'chunk1') {
+        break;
+      }
+    }
+
+    expect(collected).toEqual(['chunk1']);
+
+    for await (const chunk of asyncIterableStream) {
+      collected.push(chunk);
+    }
+
+    expect(collected).toEqual(['chunk1']);
+  });
+
+  it('should propagate errors from source stream to async iterable', async () => {
+    let controller: ReadableStreamDefaultController<string>;
+    const source = new ReadableStream({
+      start(ctrl) {
+        controller = ctrl;
+        controller.enqueue('chunk1');
+        controller.enqueue('chunk2');
+      },
+    });
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    const collected: string[] = [];
+    await expect(async () => {
+      for await (const chunk of asyncIterableStream) {
+        collected.push(chunk);
+        if (chunk === 'chunk2') {
+          controller.error(new Error('Stream error'));
+        }
+      }
+    }).rejects.toThrow('Stream error');
+
+    expect(collected).toEqual(['chunk1', 'chunk2']);
+  });
+
+  it('should stop async iterable when stream is cancelled', async () => {
+    let iterationCompleted = false;
+    let errorCaught: Error | null = null;
+
+    const source = convertArrayToReadableStream(['chunk1', 'chunk2', 'chunk3']);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    try {
+      for await (const chunk of asyncIterableStream) {
+        if (chunk === 'chunk1') {
+          await asyncIterableStream.cancel('Test cancellation');
+        }
+      }
+      iterationCompleted = true;
+    } catch (error) {
+      errorCaught = error as Error;
+    }
+
+    expect(iterationCompleted).toBe(false);
+    expect(errorCaught).not.toBeNull();
+  });
+
+  it('should not collect any chunks when iterating on already cancelled stream', async () => {
+    const source = convertArrayToReadableStream(['chunk1', 'chunk2', 'chunk3']);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    await asyncIterableStream.cancel();
+
+    const collected: string[] = [];
+    for await (const chunk of asyncIterableStream) {
+      collected.push(chunk);
+    }
+
+    expect(collected).toEqual([]);
+  });
+
+  it('should not throw when return is called after the stream completed', async () => {
+    const input = ['chunk1', 'chunk2', 'chunk3'];
+    const source = convertArrayToReadableStream(input);
+
+    const asyncIterableStream = createAsyncIterableStream(source);
+
+    const asyncIterator = asyncIterableStream[Symbol.asyncIterator]();
+
+    const output = await (async () => {
+      const output: Array<string> = [];
+
+      while (true) {
+        const value = await asyncIterator.next();
+
+        if (value.done) {
+          break;
+        }
+
+        output.push(value.value);
+      }
+
+      return output;
+    })();
+
+    expect(output).toEqual(input);
+
+    expect(await asyncIterator.return?.()).toEqual({
+      done: true,
+      value: undefined,
+    });
+  });
+});