ai 6.0.33 → 6.0.35

package/src/ui/text-stream-chat-transport.ts

@@ -0,0 +1,23 @@
+import { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
+import {
+  HttpChatTransport,
+  HttpChatTransportInitOptions,
+} from './http-chat-transport';
+import { transformTextToUiMessageStream } from './transform-text-to-ui-message-stream';
+import { UIMessage } from './ui-messages';
+
+export class TextStreamChatTransport<
+  UI_MESSAGE extends UIMessage,
+> extends HttpChatTransport<UI_MESSAGE> {
+  constructor(options: HttpChatTransportInitOptions<UI_MESSAGE> = {}) {
+    super(options);
+  }
+
+  protected processResponseStream(
+    stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+  ): ReadableStream<UIMessageChunk> {
+    return transformTextToUiMessageStream({
+      stream: stream.pipeThrough(new TextDecoderStream()),
+    });
+  }
+}

package/src/ui/transform-text-to-ui-message-stream.test.ts

@@ -0,0 +1,124 @@
+import {
+  convertArrayToReadableStream,
+  convertReadableStreamToArray,
+} from '@ai-sdk/provider-utils/test';
+import { transformTextToUiMessageStream } from './transform-text-to-ui-message-stream';
+import { describe, it, expect } from 'vitest';
+
+describe('transformTextToUiMessageStream', () => {
+  it('should transform text stream into UI message stream with correct sequence', async () => {
+    const transformedStream = transformTextToUiMessageStream({
+      stream: convertArrayToReadableStream(['Hello', ' ', 'World']),
+    });
+
+    expect(await convertReadableStreamToArray(transformedStream))
+      .toMatchInlineSnapshot(`
+        [
+          {
+            "type": "start",
+          },
+          {
+            "type": "start-step",
+          },
+          {
+            "id": "text-1",
+            "type": "text-start",
+          },
+          {
+            "delta": "Hello",
+            "id": "text-1",
+            "type": "text-delta",
+          },
+          {
+            "delta": " ",
+            "id": "text-1",
+            "type": "text-delta",
+          },
+          {
+            "delta": "World",
+            "id": "text-1",
+            "type": "text-delta",
+          },
+          {
+            "id": "text-1",
+            "type": "text-end",
+          },
+          {
+            "type": "finish-step",
+          },
+          {
+            "type": "finish",
+          },
+        ]
+      `);
+  });
+
+  it('should handle empty streams correctly', async () => {
+    const transformedStream = transformTextToUiMessageStream({
+      stream: convertArrayToReadableStream<string>([]),
+    });
+
+    expect(await convertReadableStreamToArray(transformedStream))
+      .toMatchInlineSnapshot(`
+        [
+          {
+            "type": "start",
+          },
+          {
+            "type": "start-step",
+          },
+          {
+            "id": "text-1",
+            "type": "text-start",
+          },
+          {
+            "id": "text-1",
+            "type": "text-end",
+          },
+          {
+            "type": "finish-step",
+          },
+          {
+            "type": "finish",
+          },
+        ]
+      `);
+  });
+
+  it('should handle single chunk streams', async () => {
+    const transformedStream = transformTextToUiMessageStream({
+      stream: convertArrayToReadableStream(['Complete message']),
+    });
+
+    expect(await convertReadableStreamToArray(transformedStream))
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "type": "start",
+        },
+        {
+          "type": "start-step",
+        },
+        {
+          "id": "text-1",
+          "type": "text-start",
+        },
+        {
+          "delta": "Complete message",
+          "id": "text-1",
+          "type": "text-delta",
+        },
+        {
+          "id": "text-1",
+          "type": "text-end",
+        },
+        {
+          "type": "finish-step",
+        },
+        {
+          "type": "finish",
+        },
+      ]
+    `);
+  });
+});

package/src/ui/transform-text-to-ui-message-stream.ts

@@ -0,0 +1,27 @@
+import { UIMessageChunk } from '../ui-message-stream/ui-message-chunks';
+
+export function transformTextToUiMessageStream({
+  stream,
+}: {
+  stream: ReadableStream<string>;
+}) {
+  return stream.pipeThrough(
+    new TransformStream<string, UIMessageChunk>({
+      start(controller) {
+        controller.enqueue({ type: 'start' });
+        controller.enqueue({ type: 'start-step' });
+        controller.enqueue({ type: 'text-start', id: 'text-1' });
+      },
+
+      async transform(part, controller) {
+        controller.enqueue({ type: 'text-delta', id: 'text-1', delta: part });
+      },
+
+      async flush(controller) {
+        controller.enqueue({ type: 'text-end', id: 'text-1' });
+        controller.enqueue({ type: 'finish-step' });
+        controller.enqueue({ type: 'finish' });
+      },
+    }),
+  );
+}

package/src/ui/ui-messages.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { getStaticToolName, isDataUIPart } from './ui-messages';
+
+describe('getStaticToolName', () => {
+  it('should return the tool name after the "tool-" prefix', () => {
+    expect(
+      getStaticToolName({
+        type: 'tool-getLocation',
+        toolCallId: 'tool1',
+        state: 'output-available',
+        input: {},
+        output: 'some result',
+      }),
+    ).toBe('getLocation');
+  });
+
+  it('should return the tool name for tools that contains a dash', () => {
+    expect(
+      getStaticToolName({
+        type: 'tool-get-location',
+        toolCallId: 'tool1',
+        state: 'output-available',
+        input: {},
+        output: 'some result',
+      }),
+    ).toBe('get-location');
+  });
+});
+
+describe('isDataUIPart', () => {
+  it('should return true if the part is a data part', () => {
+    expect(
+      isDataUIPart({
+        type: 'data-someDataPart',
+        data: 'some data',
+      }),
+    ).toBe(true);
+  });
+
+  it('should return false if the part is not a data part', () => {
+    expect(
+      isDataUIPart({
+        type: 'text',
+        text: 'some text',
+      }),
+    ).toBe(false);
+  });
+});