refactor: move Stream/Iterable to root and pluralize builder namespaces

Stream and Iterable operate on any ReadableStream<PART> / AsyncIterable<ITEM>,
so they no longer belong under ai-test-kit/language. Move them to the root
ai-test-kit entry (with StreamDelayOptions); MockLanguageModel keeps using
simulateStream internally. Drop the language-specific Stream.text() and
Stream.finishReason() reducers: no consumers use them, and the only inline
equivalents work on the high-level TextStreamPart layer, not provider-level
LanguageModelV3StreamPart, so they would not be a drop-in anyway.

Also bring the builder/utility namespaces in line with the plural ones that
already exist (UIParts, UIChunks, UIMessages, Options, StreamParts): rename
Stream -> Streams, Iterable -> Iterables, Content -> ContentParts. Singular
Mock* factories are unchanged. This leaves room for a future Errors namespace.
The .from() construction verb stays (mirrors Array.from and the Mock*.from
factories).

Import Stream/Iterable from 'ai-test-kit' (now Streams/Iterables); Content is
now ContentParts from 'ai-test-kit/language'.

Author: zirkelc

README.md

@@ -2,8 +2,9 @@ import { describe, expect, test } from 'vitest';
 import * as root from './index.js';
 
 describe('root barrel', () => {
-  test('should be intentionally empty (import from subpaths like ai-test-kit/language)', () => {
+  test('should export the generic stream and iterable helpers', () => {
     // Assert
-    expect(Object.keys(root).length).toBe(0);
+    expect(typeof root.Streams).toBe('object');
+    expect(typeof root.Iterables).toBe('object');
   });
 });

src/index.test.ts

@@ -1,5 +1,6 @@
 /**
- * Root entry. Intentionally empty — import a model family from its own subpath:
+ * Root entry for the generic, layer-agnostic helpers. Import a model family from its own subpath:
  * `ai-test-kit/language`, `ai-test-kit/embedding`, `ai-test-kit/image`, or `ai-test-kit/ui`.
  */
-export {};
+export { Iterables } from './iterable.js';
+export { Streams, type StreamDelayOptions } from './stream.js';

src/index.ts

@@ -1,14 +1,14 @@
 import { describe, expect, test } from 'vitest';
-import { Iterable } from './iterable.js';
-import { Stream } from './stream.js';
+import { Iterables } from './iterable.js';
+import { Streams } from './stream.js';
 
-describe('Iterable', () => {
+describe('Iterables', () => {
   test('from() and toArray() should round-trip items', async () => {
     // Arrange
     const items = [1, 2, 3];
 
     // Act
-    const roundTripped = await Iterable.toArray(Iterable.from(items));
+    const roundTripped = await Iterables.toArray(Iterables.from(items));
 
     // Assert
     expect(roundTripped).toEqual(items);
@@ -22,19 +22,19 @@ describe('Iterable', () => {
     }
 
     // Act
-    const items = await Iterable.toArray(generate());
+    const items = await Iterables.toArray(generate());
 
     // Assert
     expect(items).toEqual(['a', 'b']);
   });
 
   test('toStream() should convert an async iterable into a drainable ReadableStream', async () => {
     // Arrange
-    const iterable = Iterable.from(['x', 'y']);
+    const iterable = Iterables.from(['x', 'y']);
 
     // Act
-    const stream = Iterable.toStream(iterable);
-    const items = await Stream.toArray(stream);
+    const stream = Iterables.toStream(iterable);
+    const items = await Streams.toArray(stream);
 
     // Assert
     expect(stream).toBeInstanceOf(ReadableStream);
@@ -49,7 +49,7 @@ describe('Iterable', () => {
     }
 
     // Act
-    const result = Stream.toArray(Iterable.toStream(failing()));
+    const result = Streams.toArray(Iterables.toStream(failing()));
 
     // Assert
     await expect(result).rejects.toThrow();

src/language/iterable.test.ts src/iterable.test.tssrc/language/iterable.test.ts renamed to src/iterable.test.ts

@@ -8,11 +8,11 @@ async function* fromArray<ITEM>(items: Array<ITEM>): AsyncGenerator<ITEM> {
 /**
  * Operations for building, draining, and converting async iterables in tests.
  *
- * The complement to `Stream`: where `Stream` works with `ReadableStream`s, `Iterable` works with
+ * The complement to `Streams`: where `Streams` works with `ReadableStream`s, `Iterables` works with
  * `AsyncIterable`s (async generators and anything consumed via `for await`). Cross over to the full
- * `Stream` toolbox with `Iterable.toStream`.
+ * `Streams` toolbox with `Iterables.toStream`.
  */
-export const Iterable = {
+export const Iterables = {
   /** Builds an `AsyncIterable` that yields each item in order, e.g. to feed code that consumes one. */
   from: <ITEM>(items: Array<ITEM>): AsyncIterable<ITEM> => fromArray(items),
 

src/language/iterable.ts src/iterable.tssrc/language/iterable.ts renamed to src/iterable.ts

@@ -1,74 +1,74 @@
 import { describe, expect, test } from 'vitest';
-import { Content } from './content.js';
+import { ContentParts } from './content.js';
 
-describe('Content', () => {
+describe('ContentParts', () => {
   test('text() should build a text part', () => {
     // Act
-    const part = Content.text('hi');
+    const part = ContentParts.text('hi');
 
     // Assert
     expect(part).toEqual({ type: 'text', text: 'hi' });
   });
 
   test('reasoning() should build a reasoning part', () => {
     // Act
-    const part = Content.reasoning('thinking');
+    const part = ContentParts.reasoning('thinking');
 
     // Assert
     expect(part).toEqual({ type: 'reasoning', text: 'thinking' });
   });
 
   test('toolCall() should stringify object input to JSON', () => {
     // Act
-    const part = Content.toolCall({ toolCallId: '1', toolName: 'weather', input: { city: 'Tokyo' } });
+    const part = ContentParts.toolCall({ toolCallId: '1', toolName: 'weather', input: { city: 'Tokyo' } });
 
     // Assert
     expect(part).toEqual({ type: 'tool-call', toolCallId: '1', toolName: 'weather', input: '{"city":"Tokyo"}' });
   });
 
   test('toolCall() should pass string input through', () => {
     // Act
-    const part = Content.toolCall({ toolCallId: '1', toolName: 'weather', input: '{"city":"Tokyo"}' });
+    const part = ContentParts.toolCall({ toolCallId: '1', toolName: 'weather', input: '{"city":"Tokyo"}' });
 
     // Assert
     expect(part.input).toBe('{"city":"Tokyo"}');
   });
 
   test('toolResult() should omit isError when not provided', () => {
     // Act
-    const part = Content.toolResult({ toolCallId: '1', toolName: 'weather', result: { temp: 20 } });
+    const part = ContentParts.toolResult({ toolCallId: '1', toolName: 'weather', result: { temp: 20 } });
 
     // Assert
     expect(part).toEqual({ type: 'tool-result', toolCallId: '1', toolName: 'weather', result: { temp: 20 } });
   });
 
   test('toolResult() should include isError when provided', () => {
     // Act
-    const part = Content.toolResult({ toolCallId: '1', toolName: 'weather', result: 'nope', isError: true });
+    const part = ContentParts.toolResult({ toolCallId: '1', toolName: 'weather', result: 'nope', isError: true });
 
     // Assert
     expect(part.isError).toBe(true);
   });
 
   test('file() should build a file part', () => {
     // Act
-    const part = Content.file({ mediaType: 'image/png', data: 'abc' });
+    const part = ContentParts.file({ mediaType: 'image/png', data: 'abc' });
 
     // Assert
     expect(part).toEqual({ type: 'file', mediaType: 'image/png', data: 'abc' });
   });
 
   test('source() should build a url source, omitting title when absent', () => {
     // Act
-    const part = Content.source({ id: 's1', url: 'https://example.com' });
+    const part = ContentParts.source({ id: 's1', url: 'https://example.com' });
 
     // Assert
     expect(part).toEqual({ type: 'source', sourceType: 'url', id: 's1', url: 'https://example.com' });
   });
 
   test('source() should include title when provided', () => {
     // Act
-    const part = Content.source({ id: 's1', url: 'https://example.com', title: 'Example' });
+    const part = ContentParts.source({ id: 's1', url: 'https://example.com', title: 'Example' });
 
     // Assert
     expect(part).toEqual({ type: 'source', sourceType: 'url', id: 's1', url: 'https://example.com', title: 'Example' });

src/language/content.test.ts

@@ -9,7 +9,7 @@ import type {
 import { toJSONString } from '../internal/json.js';
 
 /** Builders for the static content parts a language model returns from `doGenerate`. */
-export const Content = {
+export const ContentParts = {
   /** A text part. */
   text: (text: string): LanguageModelV3Text => ({ type: 'text', text }),
 

src/language/content.ts

@@ -6,10 +6,8 @@ describe('language barrel', () => {
     // Assert
     expect(typeof language.MockLanguageModel).toBe('object');
     expect(typeof language.MockLanguageModel.from).toBe('function');
-    expect(typeof language.Content).toBe('object');
+    expect(typeof language.ContentParts).toBe('object');
     expect(typeof language.StreamParts).toBe('object');
-    expect(typeof language.Stream).toBe('object');
-    expect(typeof language.Iterable).toBe('object');
     expect(typeof language.Options).toBe('object');
   });
 });

src/language/index.test.ts

@@ -6,8 +6,6 @@ export {
   type StreamResponse,
 } from './mock-language-model.js';
 
-export { Content } from './content.js';
+export { ContentParts } from './content.js';
 export { StreamParts, type StreamPartOptions } from './stream-parts.js';
-export { Stream, type StreamDelayOptions } from './stream.js';
-export { Iterable } from './iterable.js';
 export { Options } from './options.js';

src/language/index.ts

@@ -1,9 +1,9 @@
 import { generateText, streamText } from 'ai';
 import { describe, expect, test } from 'vitest';
-import { Content } from './content.js';
+import { Streams } from '../stream.js';
+import { ContentParts } from './content.js';
 import { MockLanguageModel } from './mock-language-model.js';
 import { Options } from './options.js';
-import { Stream } from './stream.js';
 import { StreamParts } from './stream-parts.js';
 
 describe('MockLanguageModel', () => {
@@ -30,9 +30,9 @@ describe('MockLanguageModel', () => {
       await expect(result).rejects.toThrow();
     });
 
-    test('should return explicit content built from Content atoms', async () => {
+    test('should return explicit content built from ContentParts atoms', async () => {
       // Arrange
-      const model = MockLanguageModel.from({ content: [Content.text('explicit')] });
+      const model = MockLanguageModel.from({ content: [ContentParts.text('explicit')] });
 
       // Act
       const result = await generateText({ model, prompt: 'Hi', ...Options.generate });
@@ -44,7 +44,7 @@ describe('MockLanguageModel', () => {
 
     test('should accept a unified finish-reason string in the content form', async () => {
       // Arrange
-      const model = MockLanguageModel.from({ content: [Content.text('truncated')], finishReason: 'length' });
+      const model = MockLanguageModel.from({ content: [ContentParts.text('truncated')], finishReason: 'length' });
 
       // Act
       const result = await generateText({ model, prompt: 'Hi', ...Options.generate });
@@ -66,10 +66,10 @@ describe('MockLanguageModel', () => {
       expect(result.text).toBe('prompt-parts:1');
     });
 
-    test('should surface a tool call from Content.toolCall', async () => {
+    test('should surface a tool call from ContentParts.toolCall', async () => {
       // Arrange
       const model = MockLanguageModel.from({
-        content: [Content.toolCall({ toolCallId: 'call-1', toolName: 'weather', input: { city: 'Tokyo' } })],
+        content: [ContentParts.toolCall({ toolCallId: 'call-1', toolName: 'weather', input: { city: 'Tokyo' } })],
       });
 
       // Act
@@ -88,7 +88,7 @@ describe('MockLanguageModel', () => {
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('Hello World');
@@ -101,19 +101,19 @@ describe('MockLanguageModel', () => {
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('abcdef');
     });
 
     test('should derive a stream from content', async () => {
       // Arrange
-      const model = MockLanguageModel.from({ content: [Content.text('derived')] });
+      const model = MockLanguageModel.from({ content: [ContentParts.text('derived')] });
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('derived');
@@ -122,12 +122,12 @@ describe('MockLanguageModel', () => {
     test('should make a string and the equivalent content stream identically', async () => {
       // Arrange
       const fromString = MockLanguageModel.from('Hello');
-      const fromContent = MockLanguageModel.from({ content: [Content.text('Hello')] });
+      const fromContent = MockLanguageModel.from({ content: [ContentParts.text('Hello')] });
       const callOptions = { prompt: [] } as never;
 
       // Act
-      const stringParts = await Stream.toArray((await fromString.doStream(callOptions)).stream);
-      const contentParts = await Stream.toArray((await fromContent.doStream(callOptions)).stream);
+      const stringParts = await Streams.toArray((await fromString.doStream(callOptions)).stream);
+      const contentParts = await Streams.toArray((await fromContent.doStream(callOptions)).stream);
 
       // Assert
       expect(stringParts).toEqual(contentParts);
@@ -141,7 +141,7 @@ describe('MockLanguageModel', () => {
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('fast');
@@ -155,7 +155,7 @@ describe('MockLanguageModel', () => {
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('has-prompt');
@@ -164,11 +164,11 @@ describe('MockLanguageModel', () => {
     test('should stream from a bare ReadableStream in the stream form', async () => {
       // Arrange
       const parts = [StreamParts.streamStart(), ...StreamParts.text('piped'), StreamParts.finish()];
-      const model = MockLanguageModel.from({ stream: Stream.from(parts) });
+      const model = MockLanguageModel.from({ stream: Streams.from(parts) });
 
       // Act
       const result = streamText({ model, prompt: 'Hi', ...Options.stream });
-      const text = (await Stream.toArray(result.textStream)).join('');
+      const text = (await Streams.toArray(result.textStream)).join('');
 
       // Assert
       expect(text).toBe('piped');
@@ -315,14 +315,14 @@ describe('MockLanguageModel', () => {
     test('streamResult() should wrap a ReadableStream as a stream result', async () => {
       // Arrange
       const parts = [...StreamParts.text('wrapped'), StreamParts.finish()];
-      const stream = Stream.from(parts);
+      const stream = Streams.from(parts);
 
       // Act
       const result = MockLanguageModel.streamResult(stream);
 
       // Assert
       expect(result.stream).toBe(stream);
-      expect(await Stream.toArray(result.stream)).toEqual(parts);
+      expect(await Streams.toArray(result.stream)).toEqual(parts);
     });
   });