ai 6.0.33 → 6.0.34

package/src/test/mock-server-response.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from 'node:events';
+import { ServerResponse } from 'node:http';
+
+class MockServerResponse extends EventEmitter {
+  writtenChunks: any[] = [];
+  headers: Record<string, string> = {};
+  statusCode = 0;
+  statusMessage = '';
+  ended = false;
+
+  write(chunk: any): boolean {
+    this.writtenChunks.push(chunk);
+    return true;
+  }
+
+  end(): void {
+    this.ended = true;
+  }
+
+  writeHead(
+    statusCode: number,
+    arg2: string | Record<string, string>,
+    arg3?: Record<string, string>,
+  ): void {
+    this.statusCode = statusCode;
+
+    if (typeof arg2 === 'string') {
+      this.statusMessage = arg2;
+      this.headers = arg3 ?? {};
+    } else {
+      this.statusMessage = '';
+      this.headers = arg2;
+    }
+  }
+
+  get body() {
+    // Combine all written chunks into a single string
+    return this.writtenChunks.join('');
+  }
+
+  /**
+   * Get the decoded chunks as strings.
+   */
+  getDecodedChunks() {
+    const decoder = new TextDecoder();
+    return this.writtenChunks.map(chunk => decoder.decode(chunk));
+  }
+
+  /**
+   * Wait for the stream to finish writing to the mock response.
+   */
+  async waitForEnd() {
+    await new Promise(resolve => {
+      const checkIfEnded = () => {
+        if (this.ended) {
+          resolve(undefined);
+        } else {
+          setImmediate(checkIfEnded);
+        }
+      };
+      checkIfEnded();
+    });
+  }
+}
+
+export function createMockServerResponse(): ServerResponse &
+  MockServerResponse {
+  return new MockServerResponse() as ServerResponse & MockServerResponse;
+}

package/src/test/mock-speech-model-v2.ts

@@ -0,0 +1,24 @@
+import { SpeechModelV2 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockSpeechModelV2 implements SpeechModelV2 {
+  readonly specificationVersion = 'v2';
+  readonly provider: SpeechModelV2['provider'];
+  readonly modelId: SpeechModelV2['modelId'];
+
+  doGenerate: SpeechModelV2['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    doGenerate = notImplemented,
+  }: {
+    provider?: SpeechModelV2['provider'];
+    modelId?: SpeechModelV2['modelId'];
+    doGenerate?: SpeechModelV2['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-speech-model-v3.ts

@@ -0,0 +1,24 @@
+import { SpeechModelV3 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockSpeechModelV3 implements SpeechModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly provider: SpeechModelV3['provider'];
+  readonly modelId: SpeechModelV3['modelId'];
+
+  doGenerate: SpeechModelV3['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    doGenerate = notImplemented,
+  }: {
+    provider?: SpeechModelV3['provider'];
+    modelId?: SpeechModelV3['modelId'];
+    doGenerate?: SpeechModelV3['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-tracer.ts

@@ -0,0 +1,156 @@
+import {
+  AttributeValue,
+  Attributes,
+  Context,
+  Exception,
+  Span,
+  SpanContext,
+  SpanOptions,
+  SpanStatus,
+  TimeInput,
+  Tracer,
+} from '@opentelemetry/api';
+
+export class MockTracer implements Tracer {
+  spans: MockSpan[] = [];
+
+  get jsonSpans() {
+    return this.spans.map(span => ({
+      name: span.name,
+      attributes: span.attributes,
+      events: span.events,
+      ...(span.status && { status: span.status }),
+    }));
+  }
+
+  startSpan(name: string, options?: SpanOptions, context?: Context): Span {
+    const span = new MockSpan({
+      name,
+      options,
+      context,
+    });
+    this.spans.push(span);
+    return span;
+  }
+
+  startActiveSpan<F extends (span: Span) => unknown>(
+    name: string,
+    arg1: unknown,
+    arg2?: unknown,
+    arg3?: F,
+  ): ReturnType<any> {
+    if (typeof arg1 === 'function') {
+      const span = new MockSpan({
+        name,
+      });
+      this.spans.push(span);
+      return arg1(span);
+    }
+    if (typeof arg2 === 'function') {
+      const span = new MockSpan({
+        name,
+        options: arg1 as SpanOptions,
+      });
+      this.spans.push(span);
+      return arg2(span);
+    }
+    if (typeof arg3 === 'function') {
+      const span = new MockSpan({
+        name,
+        options: arg1 as SpanOptions,
+        context: arg2 as Context,
+      });
+      this.spans.push(span);
+      return arg3(span);
+    }
+  }
+}
+
+class MockSpan implements Span {
+  name: string;
+  context?: Context;
+  options?: SpanOptions;
+  attributes: Attributes;
+  events: Array<{
+    name: string;
+    attributes: Attributes | undefined;
+    time?: [number, number];
+  }> = [];
+  status?: SpanStatus;
+
+  readonly _spanContext: SpanContext = new MockSpanContext();
+
+  constructor({
+    name,
+    options,
+    context,
+  }: {
+    name: string;
+    options?: SpanOptions;
+    context?: Context;
+  }) {
+    this.name = name;
+    this.context = context;
+    this.options = options;
+    this.attributes = options?.attributes ?? {};
+  }
+
+  spanContext(): SpanContext {
+    return this._spanContext;
+  }
+
+  setAttribute(key: string, value: AttributeValue): this {
+    this.attributes = { ...this.attributes, [key]: value };
+    return this;
+  }
+
+  setAttributes(attributes: Attributes): this {
+    this.attributes = { ...this.attributes, ...attributes };
+    return this;
+  }
+
+  addEvent(name: string, attributes?: Attributes): this {
+    this.events.push({ name, attributes });
+    return this;
+  }
+
+  addLink() {
+    return this;
+  }
+  addLinks() {
+    return this;
+  }
+  setStatus(status: SpanStatus) {
+    this.status = status;
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {
+    return this;
+  }
+  isRecording() {
+    return false;
+  }
+  recordException(exception: Exception, time?: TimeInput) {
+    const error =
+      typeof exception === 'string' ? new Error(exception) : exception;
+    this.events.push({
+      name: 'exception',
+      attributes: {
+        'exception.type': error.constructor?.name || 'Error',
+        'exception.name': error.name || 'Error',
+        'exception.message': error.message || '',
+        'exception.stack': error.stack || '',
+      },
+      time: Array.isArray(time) ? time : [0, 0],
+    });
+  }
+}
+
+class MockSpanContext implements SpanContext {
+  traceId = 'test-trace-id';
+  spanId = 'test-span-id';
+  traceFlags = 0;
+}

package/src/test/mock-transcription-model-v2.ts

@@ -0,0 +1,24 @@
+import { TranscriptionModelV2 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockTranscriptionModelV2 implements TranscriptionModelV2 {
+  readonly specificationVersion = 'v2';
+  readonly provider: TranscriptionModelV2['provider'];
+  readonly modelId: TranscriptionModelV2['modelId'];
+
+  doGenerate: TranscriptionModelV2['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    doGenerate = notImplemented,
+  }: {
+    provider?: TranscriptionModelV2['provider'];
+    modelId?: TranscriptionModelV2['modelId'];
+    doGenerate?: TranscriptionModelV2['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-transcription-model-v3.ts

@@ -0,0 +1,24 @@
+import { TranscriptionModelV3 } from '@ai-sdk/provider';
+import { notImplemented } from './not-implemented';
+
+export class MockTranscriptionModelV3 implements TranscriptionModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly provider: TranscriptionModelV3['provider'];
+  readonly modelId: TranscriptionModelV3['modelId'];
+
+  doGenerate: TranscriptionModelV3['doGenerate'];
+
+  constructor({
+    provider = 'mock-provider',
+    modelId = 'mock-model-id',
+    doGenerate = notImplemented,
+  }: {
+    provider?: TranscriptionModelV3['provider'];
+    modelId?: TranscriptionModelV3['modelId'];
+    doGenerate?: TranscriptionModelV3['doGenerate'];
+  } = {}) {
+    this.provider = provider;
+    this.modelId = modelId;
+    this.doGenerate = doGenerate;
+  }
+}

package/src/test/mock-values.ts

@@ -0,0 +1,4 @@
+export function mockValues<T>(...values: T[]): () => T {
+  let counter = 0;
+  return () => values[counter++] ?? values[values.length - 1];
+}

package/src/test/not-implemented.ts

@@ -0,0 +1,3 @@
+export function notImplemented(): never {
+  throw new Error('Not implemented');
+}

package/src/text-stream/create-text-stream-response.test.ts

@@ -0,0 +1,38 @@
+import {
+  convertArrayToReadableStream,
+  convertReadableStreamToArray,
+} from '@ai-sdk/provider-utils/test';
+import { createTextStreamResponse } from './create-text-stream-response';
+import { describe, it, expect } from 'vitest';
+
+describe('createTextStreamResponse', () => {
+  it('should create a Response with correct headers and encoded stream', async () => {
+    const response = createTextStreamResponse({
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        'Custom-Header': 'test',
+      },
+      textStream: convertArrayToReadableStream(['test-data']),
+    });
+
+    // Verify response properties
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(200);
+    expect(response.statusText).toBe('OK');
+
+    // Verify headers
+    expect(response.headers.get('Content-Type')).toBe(
+      'text/plain; charset=utf-8',
+    );
+    expect(response.headers.get('Custom-Header')).toBe('test');
+
+    // Verify encoded stream content
+    const decoder = new TextDecoder();
+    const encodedStream = response.body!;
+    const chunks = await convertReadableStreamToArray(encodedStream);
+    const decodedChunks = chunks.map(chunk => decoder.decode(chunk));
+
+    expect(decodedChunks).toEqual(['test-data']);
+  });
+});

package/src/text-stream/create-text-stream-response.ts

@@ -0,0 +1,18 @@
+import { prepareHeaders } from '../util/prepare-headers';
+
+export function createTextStreamResponse({
+  status,
+  statusText,
+  headers,
+  textStream,
+}: ResponseInit & {
+  textStream: ReadableStream<string>;
+}): Response {
+  return new Response(textStream.pipeThrough(new TextEncoderStream()), {
+    status: status ?? 200,
+    statusText,
+    headers: prepareHeaders(headers, {
+      'content-type': 'text/plain; charset=utf-8',
+    }),
+  });
+}

package/src/text-stream/index.ts

@@ -0,0 +1,2 @@
+export { createTextStreamResponse } from './create-text-stream-response';
+export { pipeTextStreamToResponse } from './pipe-text-stream-to-response';

package/src/text-stream/pipe-text-stream-to-response.test.ts

@@ -0,0 +1,38 @@
+import { convertArrayToReadableStream } from '@ai-sdk/provider-utils/test';
+import { createMockServerResponse } from '../test/mock-server-response';
+import { pipeTextStreamToResponse } from './pipe-text-stream-to-response';
+import { describe, it, expect } from 'vitest';
+
+describe('pipeTextStreamToResponse', () => {
+  it('should write to ServerResponse with correct headers and encoded stream', async () => {
+    const mockResponse = createMockServerResponse();
+
+    pipeTextStreamToResponse({
+      response: mockResponse,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        'Custom-Header': 'test',
+      },
+      textStream: convertArrayToReadableStream(['test-data']),
+    });
+
+    // Wait for the stream to finish writing
+    await mockResponse.waitForEnd();
+
+    // Verify response properties
+    expect(mockResponse.statusCode).toBe(200);
+    expect(mockResponse.statusMessage).toBe('OK');
+
+    // Verify headers
+    expect(mockResponse.headers).toMatchInlineSnapshot(`
+      {
+        "content-type": "text/plain; charset=utf-8",
+        "custom-header": "test",
+      }
+    `);
+
+    // Verify written data using decoded chunks
+    expect(mockResponse.getDecodedChunks()).toStrictEqual(['test-data']);
+  });
+});

package/src/text-stream/pipe-text-stream-to-response.ts

@@ -0,0 +1,26 @@
+import { ServerResponse } from 'node:http';
+import { prepareHeaders } from '../util/prepare-headers';
+import { writeToServerResponse } from '../util/write-to-server-response';
+
+export function pipeTextStreamToResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  textStream,
+}: {
+  response: ServerResponse;
+  textStream: ReadableStream<string>;
+} & ResponseInit): void {
+  writeToServerResponse({
+    response,
+    status,
+    statusText,
+    headers: Object.fromEntries(
+      prepareHeaders(headers, {
+        'content-type': 'text/plain; charset=utf-8',
+      }).entries(),
+    ),
+    stream: textStream.pipeThrough(new TextEncoderStream()),
+  });
+}

package/src/transcribe/index.ts

@@ -0,0 +1,2 @@
+export { transcribe as experimental_transcribe } from './transcribe';
+export type { TranscriptionResult as Experimental_TranscriptionResult } from './transcribe-result';

package/src/transcribe/transcribe-result.ts

@@ -0,0 +1,60 @@
+import { JSONObject } from '@ai-sdk/provider';
+import { TranscriptionModelResponseMetadata } from '../types/transcription-model-response-metadata';
+import { Warning } from '../types/warning';
+
+/**
+The result of a `transcribe` call.
+It contains the transcript and additional information.
+ */
+export interface TranscriptionResult {
+  /**
+   * The complete transcribed text from the audio.
+   */
+  readonly text: string;
+
+  /**
+   * Array of transcript segments with timing information.
+   * Each segment represents a portion of the transcribed text with start and end times.
+   */
+  readonly segments: Array<{
+    /**
+     * The text content of this segment.
+     */
+    readonly text: string;
+    /**
+     * The start time of this segment in seconds.
+     */
+    readonly startSecond: number;
+    /**
+     * The end time of this segment in seconds.
+     */
+    readonly endSecond: number;
+  }>;
+
+  /**
+   * The detected language of the audio content, as an ISO-639-1 code (e.g., 'en' for English).
+   * May be undefined if the language couldn't be detected.
+   */
+  readonly language: string | undefined;
+
+  /**
+   * The total duration of the audio file in seconds.
+   * May be undefined if the duration couldn't be determined.
+   */
+  readonly durationInSeconds: number | undefined;
+
+  /**
+  Warnings for the call, e.g. unsupported settings.
+     */
+  readonly warnings: Array<Warning>;
+
+  /**
+  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+   */
+  readonly responses: Array<TranscriptionModelResponseMetadata>;
+
+  /**
+  Provider metadata from the provider.
+   */
+  readonly providerMetadata: Record<string, JSONObject>;
+}