ai 6.0.33 → 6.0.35

package/src/util/serial-job-executor.test.ts

@@ -0,0 +1,162 @@
+import { DelayedPromise } from '@ai-sdk/provider-utils';
+import { describe, expect, it } from 'vitest';
+import { SerialJobExecutor } from './serial-job-executor';
+
+describe('SerialJobExecutor', () => {
+  it('should execute a single job successfully', async () => {
+    const executor = new SerialJobExecutor();
+    const result = new DelayedPromise<string>();
+
+    const jobPromise = executor.run(async () => {
+      result.resolve('done');
+    });
+
+    await jobPromise;
+    expect(await result.promise).toBe('done');
+  });
+
+  it('should execute multiple jobs in serial order', async () => {
+    const executor = new SerialJobExecutor();
+    const executionOrder: number[] = [];
+    const job1Promise = new DelayedPromise<void>();
+    const job2Promise = new DelayedPromise<void>();
+    const job3Promise = new DelayedPromise<void>();
+
+    // Start all jobs
+    const promise1 = executor.run(async () => {
+      executionOrder.push(1);
+      job1Promise.resolve();
+    });
+
+    const promise2 = executor.run(async () => {
+      executionOrder.push(2);
+      job2Promise.resolve();
+    });
+
+    const promise3 = executor.run(async () => {
+      executionOrder.push(3);
+      job3Promise.resolve();
+    });
+
+    // Wait for all jobs to complete
+    await Promise.all([promise1, promise2, promise3]);
+
+    // Verify execution order
+    expect(executionOrder).toEqual([1, 2, 3]);
+  });
+
+  it('should handle job errors correctly', async () => {
+    const executor = new SerialJobExecutor();
+    const error = new Error('test error');
+
+    const promise = executor.run(async () => {
+      throw error;
+    });
+
+    await expect(promise).rejects.toThrow(error);
+  });
+
+  it('should execute jobs one at a time', async () => {
+    const executor = new SerialJobExecutor();
+    let concurrentJobs = 0;
+    let maxConcurrentJobs = 0;
+    const job1 = new DelayedPromise<void>();
+    const job2 = new DelayedPromise<void>();
+
+    // Start two jobs
+    const promise1 = executor.run(async () => {
+      concurrentJobs++;
+      maxConcurrentJobs = Math.max(maxConcurrentJobs, concurrentJobs);
+      await job1.promise;
+      concurrentJobs--;
+    });
+
+    const promise2 = executor.run(async () => {
+      concurrentJobs++;
+      maxConcurrentJobs = Math.max(maxConcurrentJobs, concurrentJobs);
+      await job2.promise;
+      concurrentJobs--;
+    });
+
+    // Let both jobs proceed and complete
+    job1.resolve();
+    job2.resolve();
+
+    await Promise.all([promise1, promise2]);
+
+    expect(maxConcurrentJobs).toBe(1);
+  });
+
+  it('should handle mixed success and failure jobs', async () => {
+    const executor = new SerialJobExecutor();
+    const results: string[] = [];
+    const error = new Error('test error');
+
+    // Queue multiple jobs with mixed success/failure
+    const promise1 = executor.run(async () => {
+      results.push('job1');
+    });
+
+    const promise2 = executor.run(async () => {
+      throw error;
+    });
+
+    const promise3 = executor.run(async () => {
+      results.push('job3');
+    });
+
+    // First job should succeed
+    await promise1;
+    expect(results).toEqual(['job1']);
+
+    // Second job should fail
+    await expect(promise2).rejects.toThrow(error);
+
+    // Third job should still execute and succeed
+    await promise3;
+    expect(results).toEqual(['job1', 'job3']);
+  });
+
+  it('should handle concurrent calls to run()', async () => {
+    const executor = new SerialJobExecutor();
+    const executionOrder: number[] = [];
+    const startOrder: number[] = [];
+
+    // Create delayed promises for controlling job execution
+    const job1 = new DelayedPromise<void>();
+    const job2 = new DelayedPromise<void>();
+    const job3 = new DelayedPromise<void>();
+
+    // Start all jobs concurrently
+    const promises = [
+      executor.run(async () => {
+        startOrder.push(1);
+        await job1.promise;
+        executionOrder.push(1);
+      }),
+      executor.run(async () => {
+        startOrder.push(2);
+        await job2.promise;
+        executionOrder.push(2);
+      }),
+      executor.run(async () => {
+        startOrder.push(3);
+        await job3.promise;
+        executionOrder.push(3);
+      }),
+    ].map(p => p.catch(e => e));
+
+    // Resolve jobs in reverse order to verify execution order is maintained
+    job3.resolve();
+    job2.resolve();
+    job1.resolve();
+
+    // Wait for all jobs to complete
+    await Promise.all(promises);
+
+    // Verify that jobs were queued in the order they were submitted
+    expect(startOrder).toEqual([1, 2, 3]);
+    // Verify that jobs were executed in the order they were queued
+    expect(executionOrder).toEqual([1, 2, 3]);
+  });
+});

package/src/util/serial-job-executor.ts

@@ -0,0 +1,36 @@
+import { Job } from './job';
+
+export class SerialJobExecutor {
+  private queue: Array<Job> = [];
+  private isProcessing = false;
+
+  private async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    while (this.queue.length > 0) {
+      await this.queue[0]();
+      this.queue.shift();
+    }
+
+    this.isProcessing = false;
+  }
+
+  async run(job: Job): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          await job();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+
+      void this.processQueue();
+    });
+  }
+}

package/src/util/simulate-readable-stream.test.ts

@@ -0,0 +1,98 @@
+import { simulateReadableStream } from './simulate-readable-stream';
+import { convertReadableStreamToArray } from '@ai-sdk/provider-utils/test';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('simulateReadableStream', () => {
+  let delayValues: (number | null)[] = [];
+  const mockDelay = (ms: number | null) => {
+    delayValues.push(ms);
+    return Promise.resolve();
+  };
+
+  beforeEach(() => {
+    delayValues = [];
+  });
+
+  it('should create a readable stream with provided values', async () => {
+    const values = ['a', 'b', 'c'];
+    const stream = simulateReadableStream({ chunks: values });
+
+    expect(await convertReadableStreamToArray(stream)).toEqual(values);
+  });
+
+  it('should respect the chunkDelayInMs setting', async () => {
+    const stream = simulateReadableStream({
+      chunks: [1, 2, 3],
+      initialDelayInMs: 500,
+      chunkDelayInMs: 100,
+      _internal: { delay: mockDelay },
+    });
+
+    await convertReadableStreamToArray(stream); // consume stream
+
+    expect(delayValues).toEqual([500, 100, 100]);
+  });
+
+  it('should handle empty values array', async () => {
+    const stream = simulateReadableStream({ chunks: [] });
+    const reader = stream.getReader();
+
+    const { done, value } = await reader.read();
+
+    expect(done).toBe(true);
+    expect(value).toBeUndefined();
+  });
+
+  it('should handle different types of values', async () => {
+    const stream = simulateReadableStream({
+      chunks: [
+        { id: 1, text: 'hello' },
+        { id: 2, text: 'world' },
+      ],
+    });
+
+    expect(await convertReadableStreamToArray(stream)).toEqual([
+      { id: 1, text: 'hello' },
+      { id: 2, text: 'world' },
+    ]);
+  });
+
+  it('should skip all delays when both delay settings are null', async () => {
+    const stream = simulateReadableStream({
+      chunks: [1, 2, 3],
+      initialDelayInMs: null,
+      chunkDelayInMs: null,
+      _internal: { delay: mockDelay },
+    });
+
+    await convertReadableStreamToArray(stream); // consume stream
+
+    expect(delayValues).toEqual([null, null, null]);
+  });
+
+  it('should apply chunk delays but skip initial delay when initialDelayInMs is null', async () => {
+    const stream = simulateReadableStream({
+      chunks: [1, 2, 3],
+      initialDelayInMs: null,
+      chunkDelayInMs: 100,
+      _internal: { delay: mockDelay },
+    });
+
+    await convertReadableStreamToArray(stream); // consume stream
+
+    expect(delayValues).toEqual([null, 100, 100]);
+  });
+
+  it('should apply initial delay but skip chunk delays when chunkDelayInMs is null', async () => {
+    const stream = simulateReadableStream({
+      chunks: [1, 2, 3],
+      initialDelayInMs: 500,
+      chunkDelayInMs: null,
+      _internal: { delay: mockDelay },
+    });
+
+    await convertReadableStreamToArray(stream); // consume stream
+
+    expect(delayValues).toEqual([500, null, null]);
+  });
+});

package/src/util/simulate-readable-stream.ts

@@ -0,0 +1,39 @@
+import { delay as delayFunction } from '@ai-sdk/provider-utils';
+
+/**
+ * Creates a ReadableStream that emits the provided values with an optional delay between each value.
+ *
+ * @param options - The configuration options
+ * @param options.chunks - Array of values to be emitted by the stream
+ * @param options.initialDelayInMs - Optional initial delay in milliseconds before emitting the first value (default: 0). Can be set to `null` to skip the initial delay. The difference between `initialDelayInMs: null` and `initialDelayInMs: 0` is that `initialDelayInMs: null` will emit the values without any delay, while `initialDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @returns A ReadableStream that emits the provided values
+ */
+export function simulateReadableStream<T>({
+  chunks,
+  initialDelayInMs = 0,
+  chunkDelayInMs = 0,
+  _internal,
+}: {
+  chunks: T[];
+  initialDelayInMs?: number | null;
+  chunkDelayInMs?: number | null;
+  _internal?: {
+    delay?: (ms: number | null) => Promise<void>;
+  };
+}): ReadableStream<T> {
+  const delay = _internal?.delay ?? delayFunction;
+
+  let index = 0;
+
+  return new ReadableStream({
+    async pull(controller) {
+      if (index < chunks.length) {
+        await delay(index === 0 ? initialDelayInMs : chunkDelayInMs);
+        controller.enqueue(chunks[index++]);
+      } else {
+        controller.close();
+      }
+    },
+  });
+}

package/src/util/split-array.test.ts

@@ -0,0 +1,60 @@
+import { expect, it } from 'vitest';
+import { splitArray } from './split-array';
+
+it('should split an array into chunks of the specified size', () => {
+  const array = [1, 2, 3, 4, 5];
+  const size = 2;
+  const result = splitArray(array, size);
+  expect(result).toEqual([[1, 2], [3, 4], [5]]);
+});
+
+it('should return an empty array when the input array is empty', () => {
+  const array: number[] = [];
+  const size = 2;
+  const result = splitArray(array, size);
+  expect(result).toEqual([]);
+});
+
+it('should return the original array when the chunk size is greater than the array length', () => {
+  const array = [1, 2, 3];
+  const size = 5;
+  const result = splitArray(array, size);
+  expect(result).toEqual([[1, 2, 3]]);
+});
+
+it('should return the original array when the chunk size is equal to the array length', () => {
+  const array = [1, 2, 3];
+  const size = 3;
+  const result = splitArray(array, size);
+  expect(result).toEqual([[1, 2, 3]]);
+});
+
+it('should handle chunk size of 1 correctly', () => {
+  const array = [1, 2, 3];
+  const size = 1;
+  const result = splitArray(array, size);
+  expect(result).toEqual([[1], [2], [3]]);
+});
+
+it('should throw an error for chunk size of 0', () => {
+  const array = [1, 2, 3];
+  const size = 0;
+  expect(() => splitArray(array, size)).toThrow(
+    'chunkSize must be greater than 0',
+  );
+});
+
+it('should throw an error for negative chunk size', () => {
+  const array = [1, 2, 3];
+  const size = -1;
+  expect(() => splitArray(array, size)).toThrow(
+    'chunkSize must be greater than 0',
+  );
+});
+
+it('should handle non-integer chunk size by flooring the size', () => {
+  const array = [1, 2, 3, 4, 5];
+  const size = 2.5;
+  const result = splitArray(array, Math.floor(size));
+  expect(result).toEqual([[1, 2], [3, 4], [5]]);
+});

package/src/util/split-array.ts

@@ -0,0 +1,20 @@
+/**
+ * Splits an array into chunks of a specified size.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to split.
+ * @param {number} chunkSize - The size of each chunk.
+ * @returns {T[][]} - A new array containing the chunks.
+ */
+export function splitArray<T>(array: T[], chunkSize: number): T[][] {
+  if (chunkSize <= 0) {
+    throw new Error('chunkSize must be greater than 0');
+  }
+
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+
+  return result;
+}

package/src/util/value-of.ts

@@ -0,0 +1,65 @@
+// License for this File only:
+//
+// MIT License
+//
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+// Copyright (c) Vercel, Inc. (https://vercel.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+// to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	'foo': 1,
+	'bar': 2,
+	'biz': 3
+}
+
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+	return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+	return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
+*/
+export type ValueOf<
+  ObjectType,
+  ValueType extends keyof ObjectType = keyof ObjectType,
+> = ObjectType[ValueType];