ai-test-kit 0.0.1

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/language/index.d.mts

@@ -0,0 +1,218 @@
+import { Mock } from "vitest";
+import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3Content, LanguageModelV3File, LanguageModelV3FinishReason, LanguageModelV3GenerateResult, LanguageModelV3Reasoning, LanguageModelV3Source, LanguageModelV3StreamPart, LanguageModelV3StreamResult, LanguageModelV3Text, LanguageModelV3ToolCall, LanguageModelV3ToolResult, LanguageModelV3Usage } from "@ai-sdk/provider";
+
+//#region src/language/stream.d.ts
+/** Simulated timing for a stream. Shared by `Stream.simulate`, `MockLanguageModel.streamResult`, and the `stream` chunks form. */
+type StreamDelayOptions = {
+  /** Delay before the first part is emitted. */initialDelayInMs?: number; /** Delay between each subsequent part. */
+  chunkDelayInMs?: number;
+};
+/** Operations for building, draining, and inspecting language model streams in tests. */
+declare const Stream: {
+  /** Builds a `ReadableStream` from an array of parts. */from: <PART>(parts: Array<PART>) => ReadableStream<PART>; /** Builds a `ReadableStream` that emits parts with optional delays, for timing tests. */
+  simulate: <PART>(chunks: Array<PART>, opts?: StreamDelayOptions) => ReadableStream<PART>; /** Reads a stream to completion and returns every part it emitted. */
+  toArray: <PART>(stream: ReadableStream<PART>) => Promise<Array<PART>>; /** Joins the `text-delta` parts of a stream-part sequence into the full text. */
+  text: (parts: Array<LanguageModelV3StreamPart>) => string; /** Returns the finish reason from a stream-part sequence, if a `finish` part is present. */
+  finishReason: (parts: Array<LanguageModelV3StreamPart>) => LanguageModelV3FinishReason | undefined;
+};
+//#endregion
+//#region src/language/mock-language-model.d.ts
+/** A (possibly partial) non-streaming result; only `content` is required, the rest defaults. */
+type GenerateResultInput = Partial<LanguageModelV3GenerateResult> & {
+  content: Array<LanguageModelV3Content>;
+};
+/** How to respond to a `doGenerate` call. */
+type GenerateResponse = string | Error | GenerateResultInput | LanguageModelV3['doGenerate'];
+/** How to respond to a `doStream` call. A bare array streams without delay; the object form adds delays. */
+type StreamResponse = string | Error | Array<LanguageModelV3StreamPart> | ({
+  chunks: Array<LanguageModelV3StreamPart>;
+} & StreamDelayOptions) | LanguageModelV3StreamResult | LanguageModelV3['doStream'];
+/**
+ * A single mock response. A `string` or `Error` applies to whichever method is called;
+ * the object forms target one method explicitly.
+ *
+ * Note: `string` and `{ content }` describe the output for both methods — when streamed, a stream is
+ * derived from the content. To sequence responses across calls, pass an `Array<MockResponse>` at the
+ * top level. Because of that, a raw stream is expressed via the `stream` form (`{ stream: [...] }`),
+ * never a bare array.
+ */
+type MockResponse = string | Error | GenerateResultInput | {
+  generate?: GenerateResponse;
+  stream?: StreamResponse;
+};
+/** Optional identity overrides for a mock model. */
+type MockLanguageModelOptions = {
+  /** The provider id; defaults to `mock-provider`. */provider?: string; /** The model id; defaults to an auto-incrementing `mock-model-{n}`. */
+  modelId?: string;
+};
+/**
+ * A `LanguageModelV3` mock whose `doGenerate`/`doStream` are `vi.fn()` spies. Each call is also
+ * recorded on `doGenerateCalls`/`doStreamCalls` so call arguments can be inspected without vitest.
+ * Instances are created via the {@link MockLanguageModel} factory.
+ */
+declare class LanguageModelMock implements LanguageModelV3 {
+  /** The language model spec version this mock implements. */
+  readonly specificationVersion = "v3";
+  /** URL patterns the model supports — none, for a mock. */
+  readonly supportedUrls: LanguageModelV3['supportedUrls'];
+  /** The provider id. */
+  readonly provider: string;
+  /** The model id. */
+  readonly modelId: string;
+  /** Spy implementing `doGenerate`, resolving the configured response. */
+  doGenerate: Mock<LanguageModelV3['doGenerate']>;
+  /** Spy implementing `doStream`, resolving the configured response. */
+  doStream: Mock<LanguageModelV3['doStream']>;
+  /** Call options captured for every `doGenerate` invocation, in order. */
+  doGenerateCalls: Array<LanguageModelV3CallOptions>;
+  /** Call options captured for every `doStream` invocation, in order. */
+  doStreamCalls: Array<LanguageModelV3CallOptions>;
+  /** Builds the spies and identity from the configured response(s) and options. */
+  constructor(input?: MockResponse | Array<MockResponse>, options?: MockLanguageModelOptions);
+}
+/**
+ * Namespace for building mock language models. `from` creates a mock `LanguageModelV3`; the other
+ * builders assemble the values a model returns. Exported as both a value (the namespace) and a type
+ * (the model instance).
+ *
+ * @example
+ * const model = MockLanguageModel.from('Hello, world!');
+ * const flaky = MockLanguageModel.from([new Error('rate limited'), 'recovered']);
+ * const built = MockLanguageModel.from({ content: MockLanguageModel.content('Hi') });
+ */
+declare const MockLanguageModel: {
+  from: (input?: MockResponse | Array<MockResponse>, options?: MockLanguageModelOptions) => LanguageModelMock;
+  content: (input: string | Array<LanguageModelV3Content>) => Array<LanguageModelV3Content>;
+  generateResult: (input: string | GenerateResultInput) => LanguageModelV3GenerateResult;
+  streamResult: (input: string | Array<LanguageModelV3StreamPart>, opts?: StreamDelayOptions) => LanguageModelV3StreamResult;
+  usage: (overrides?: {
+    inputTokens?: Partial<LanguageModelV3Usage["inputTokens"]>;
+    outputTokens?: Partial<LanguageModelV3Usage["outputTokens"]>;
+  }) => LanguageModelV3Usage;
+  finishReason: (unified?: LanguageModelV3FinishReason["unified"]) => LanguageModelV3FinishReason;
+};
+/** A mock language model instance, as returned by {@link MockLanguageModel.from}. */
+type MockLanguageModel = LanguageModelMock;
+//#endregion
+//#region src/language/content.d.ts
+/** Builders for the static content parts a language model returns from `doGenerate`. */
+declare const Content: {
+  /** A text part. */text: (text: string) => LanguageModelV3Text; /** A reasoning part. */
+  reasoning: (text: string) => LanguageModelV3Reasoning; /** A tool call. `input` is stringified to JSON unless already a string. */
+  toolCall: (args: {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+  }) => LanguageModelV3ToolCall; /** A tool result. */
+  toolResult: (args: {
+    toolCallId: string;
+    toolName: string;
+    result: LanguageModelV3ToolResult["result"];
+    isError?: boolean;
+  }) => LanguageModelV3ToolResult; /** A file part. */
+  file: (args: {
+    mediaType: string;
+    data: string | Uint8Array;
+  }) => LanguageModelV3File; /** A URL source part. */
+  source: (args: {
+    id: string;
+    url: string;
+    title?: string;
+  }) => LanguageModelV3Source;
+};
+//#endregion
+//#region src/language/stream-parts.d.ts
+/** The `warnings` array carried by a `stream-start` part. */
+type StreamStartWarnings = Extract<LanguageModelV3StreamPart, {
+  type: 'stream-start';
+}>['warnings'];
+/** The fields of a `response-metadata` part, without its `type` tag. */
+type ResponseMetadata = Omit<Extract<LanguageModelV3StreamPart, {
+  type: 'response-metadata';
+}>, 'type'>;
+/** Options for the streamed-text part builders: a stable part `id` plus a tokenization strategy. */
+type StreamPartOptions = {
+  /** Stable id shared by the start/delta/end parts. */id?: string; /** Split the text into fixed-size slices of at most this many characters. */
+  length?: number; /** Split the text on this delimiter, re-appending it to each token. */
+  separator?: string;
+};
+/**
+ * Builders for individual stream parts emitted by a language model's `doStream`. The text-like
+ * builders return a start / delta / end block (without a trailing `finish`) so streams compose by
+ * concatenation; control parts (`finish`, `error`, …) are single parts.
+ */
+declare const StreamParts: {
+  /** A text block: `text-start` → `text-delta`* → `text-end`. */text: (text: string, {
+    id,
+    length,
+    separator
+  }?: StreamPartOptions) => Array<LanguageModelV3StreamPart>; /** A reasoning block: `reasoning-start` → `reasoning-delta`* → `reasoning-end`. */
+  reasoning: (text: string, {
+    id,
+    length,
+    separator
+  }?: StreamPartOptions) => Array<LanguageModelV3StreamPart>; /** A streamed tool input: `tool-input-start` → `tool-input-delta`* → `tool-input-end`. */
+  toolInput: (args: {
+    id: string;
+    toolName: string;
+    input: unknown;
+    length?: number;
+  }) => Array<LanguageModelV3StreamPart>; /** A completed tool call (same shape as the content part). */
+  toolCall: (args: {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+  }) => LanguageModelV3StreamPart; /** A tool result (same shape as the content part). */
+  toolResult: (args: {
+    toolCallId: string;
+    toolName: string;
+    result: Parameters<typeof Content.toolResult>[0]["result"];
+    isError?: boolean;
+  }) => LanguageModelV3StreamPart; /** A source part. */
+  source: (args: {
+    id: string;
+    url: string;
+    title?: string;
+  }) => LanguageModelV3StreamPart; /** A file part. */
+  file: (args: {
+    mediaType: string;
+    data: string | Uint8Array;
+  }) => LanguageModelV3StreamPart; /** The terminal `finish` part with usage and finish reason. The finish reason may be a unified string. */
+  finish: (opts?: {
+    finishReason?: LanguageModelV3FinishReason | LanguageModelV3FinishReason["unified"];
+    usage?: LanguageModelV3Usage;
+  }) => LanguageModelV3StreamPart; /** An error part, mirroring a provider failing mid-stream. */
+  error: (error: unknown) => LanguageModelV3StreamPart; /** The opening `stream-start` part carrying call warnings. */
+  streamStart: (warnings?: StreamStartWarnings) => LanguageModelV3StreamPart; /** Provider response metadata (id, timestamp, modelId, …). */
+  responseMetadata: (meta?: ResponseMetadata) => LanguageModelV3StreamPart; /** A raw passthrough part. */
+  raw: (rawValue: unknown) => LanguageModelV3StreamPart;
+};
+//#endregion
+//#region src/language/options.d.ts
+/**
+ * Determinism helpers to spread into `generateText`/`streamText` so ids and timestamps are stable.
+ *
+ * Note: `Options.stream` sets `_internal.now` to control timestamps, but the AI SDK has a bug where
+ * the `finish-step` response timestamp in the error streaming path uses `new Date()` directly. Tests
+ * that hit that path additionally need `vi.useFakeTimers()`.
+ *
+ * @example
+ * await generateText({ model, prompt: 'x', ...Options.generate });
+ * streamText({ model, prompt: 'x', ...Options.stream });
+ */
+declare const Options: {
+  /** Stable id generator used by `Options.generate` / `Options.stream`. */generateId: () => string; /** Spread into `generateText` for a deterministic `generateId`. */
+  generate: {
+    _internal: {
+      generateId: () => string;
+    };
+  }; /** Spread into `streamText` for a deterministic `generateId` and `now`. */
+  stream: {
+    _internal: {
+      generateId: () => string;
+      now: () => number;
+    };
+  };
+};
+//#endregion
+export { Content, type GenerateResponse, MockLanguageModel, type MockLanguageModelOptions, type MockResponse, Options, Stream, type StreamDelayOptions, type StreamPartOptions, StreamParts, type StreamResponse };

package/dist/language/index.mjs

@@ -0,0 +1,363 @@
+import { t as tokenize } from "../tokenize-C-Zp26iY.mjs";
+import { simulateReadableStream } from "ai";
+import { vi } from "vitest";
+import { convertArrayToReadableStream, convertReadableStreamToArray } from "@ai-sdk/provider-utils/test";
+
+//#region src/internal/defaults.ts
+/** Standard "stop" finish reason used when none is supplied. */
+const defaultFinishReason = {
+	unified: "stop",
+	raw: "stop"
+};
+/** Small, stable token usage used when none is supplied. */
+const defaultUsage = {
+	inputTokens: {
+		total: 10,
+		noCache: 10,
+		cacheRead: 0,
+		cacheWrite: 0
+	},
+	outputTokens: {
+		total: 20,
+		text: 20,
+		reasoning: 0
+	}
+};
+/** Normalizes a finish reason: a bare unified value becomes `{ unified, raw }`; an object passes through. */
+const toFinishReason = (reason) => typeof reason === "string" ? {
+	unified: reason,
+	raw: reason
+} : reason;
+
+//#endregion
+//#region src/internal/json.ts
+/** Stringifies tool input to the JSON string the provider spec expects, leaving strings untouched. */
+const toJSONString = (input) => typeof input === "string" ? input : JSON.stringify(input);
+
+//#endregion
+//#region src/language/content.ts
+/** Builders for the static content parts a language model returns from `doGenerate`. */
+const Content = {
+	text: (text) => ({
+		type: "text",
+		text
+	}),
+	reasoning: (text) => ({
+		type: "reasoning",
+		text
+	}),
+	toolCall: (args) => ({
+		type: "tool-call",
+		toolCallId: args.toolCallId,
+		toolName: args.toolName,
+		input: toJSONString(args.input)
+	}),
+	toolResult: (args) => ({
+		type: "tool-result",
+		toolCallId: args.toolCallId,
+		toolName: args.toolName,
+		result: args.result,
+		...args.isError !== void 0 ? { isError: args.isError } : {}
+	}),
+	file: (args) => ({
+		type: "file",
+		mediaType: args.mediaType,
+		data: args.data
+	}),
+	source: (args) => ({
+		type: "source",
+		sourceType: "url",
+		id: args.id,
+		url: args.url,
+		...args.title !== void 0 ? { title: args.title } : {}
+	})
+};
+
+//#endregion
+//#region src/language/stream.ts
+/** Operations for building, draining, and inspecting language model streams in tests. */
+const Stream = {
+	from: (parts) => convertArrayToReadableStream(parts),
+	simulate: (chunks, opts = {}) => simulateReadableStream({
+		chunks,
+		...opts
+	}),
+	toArray: (stream) => convertReadableStreamToArray(stream),
+	text: (parts) => parts.filter((part) => part.type === "text-delta").map((part) => part.delta).join(""),
+	finishReason: (parts) => parts.find((part) => part.type === "finish")?.finishReason
+};
+
+//#endregion
+//#region src/language/stream-parts.ts
+/**
+* Builders for individual stream parts emitted by a language model's `doStream`. The text-like
+* builders return a start / delta / end block (without a trailing `finish`) so streams compose by
+* concatenation; control parts (`finish`, `error`, …) are single parts.
+*/
+const StreamParts = {
+	text: (text, { id = "1", length, separator } = {}) => [
+		{
+			type: "text-start",
+			id
+		},
+		...tokenize(text, {
+			length,
+			separator
+		}).map((delta) => ({
+			type: "text-delta",
+			id,
+			delta
+		})),
+		{
+			type: "text-end",
+			id
+		}
+	],
+	reasoning: (text, { id = "1", length, separator } = {}) => [
+		{
+			type: "reasoning-start",
+			id
+		},
+		...tokenize(text, {
+			length,
+			separator
+		}).map((delta) => ({
+			type: "reasoning-delta",
+			id,
+			delta
+		})),
+		{
+			type: "reasoning-end",
+			id
+		}
+	],
+	toolInput: (args) => [
+		{
+			type: "tool-input-start",
+			id: args.id,
+			toolName: args.toolName
+		},
+		...tokenize(toJSONString(args.input), { length: args.length }).map((delta) => ({
+			type: "tool-input-delta",
+			id: args.id,
+			delta
+		})),
+		{
+			type: "tool-input-end",
+			id: args.id
+		}
+	],
+	toolCall: (args) => Content.toolCall(args),
+	toolResult: (args) => Content.toolResult(args),
+	source: (args) => Content.source(args),
+	file: (args) => Content.file(args),
+	finish: (opts = {}) => ({
+		type: "finish",
+		finishReason: toFinishReason(opts.finishReason ?? defaultFinishReason),
+		usage: opts.usage ?? defaultUsage
+	}),
+	error: (error) => ({
+		type: "error",
+		error
+	}),
+	streamStart: (warnings = []) => ({
+		type: "stream-start",
+		warnings
+	}),
+	responseMetadata: (meta = {}) => ({
+		type: "response-metadata",
+		...meta
+	}),
+	raw: (rawValue) => ({
+		type: "raw",
+		rawValue
+	})
+};
+
+//#endregion
+//#region src/language/mock-language-model.ts
+/** Monotonic counter backing the auto-generated model ids. */
+let modelCounter = 0;
+/** Returns the next unique auto-generated model id. */
+const nextModelId = () => {
+	modelCounter += 1;
+	return `mock-model-${modelCounter}`;
+};
+/** Throws a clear error when a method is called but no matching response was configured. */
+const notImplemented = (method) => {
+	throw new Error(`MockLanguageModel.${method} was called but no matching response was provided.`);
+};
+/** Narrows a response to the explicit `{ generate, stream }` form. */
+const isExplicit = (response) => typeof response === "object" && response !== null && !(response instanceof Error) && ("generate" in response || "stream" in response);
+/** Expands a single content part into the stream parts that represent it. */
+const partToStreamParts = (part, id) => {
+	if (part.type === "text") return StreamParts.text(part.text, { id });
+	if (part.type === "reasoning") return StreamParts.reasoning(part.text, { id });
+	return [part];
+};
+/** Derives a stream from content parts: `stream-start` → one block per part → `finish`. */
+const contentToStream = (content, finishReason, usage) => [
+	StreamParts.streamStart(),
+	...content.flatMap((part, index) => partToStreamParts(part, String(index))),
+	StreamParts.finish({
+		finishReason,
+		usage
+	})
+];
+/** The streamed form of a string is the streamed form of a single text content part. */
+const textToStream = (text) => contentToStream([Content.text(text)]);
+/** Fills a partial generate result with default finish reason, usage, and warnings. */
+const buildGenerateResult = (input) => ({
+	finishReason: defaultFinishReason,
+	usage: defaultUsage,
+	warnings: [],
+	...input
+});
+/** Wraps stream parts into a stream result, with optional simulated delays. */
+const buildStreamResult = (chunks, initialDelayInMs, chunkDelayInMs) => ({ stream: simulateReadableStream({
+	chunks,
+	initialDelayInMs,
+	chunkDelayInMs
+}) });
+/** Resolves the `generate` form of an explicit response into a generate result. */
+const resolveGenerateResponse = async (response, options) => {
+	if (typeof response === "string") return buildGenerateResult({ content: [Content.text(response)] });
+	if (response instanceof Error) throw response;
+	if (typeof response === "function") return response(options);
+	return buildGenerateResult(response);
+};
+/** Resolves the `stream` form of an explicit response into a stream result. */
+const resolveStreamResponse = async (response, options) => {
+	if (typeof response === "string") return buildStreamResult(textToStream(response));
+	if (response instanceof Error) throw response;
+	if (Array.isArray(response)) return buildStreamResult(response);
+	if (typeof response === "function") return response(options);
+	if ("chunks" in response) return buildStreamResult(response.chunks, response.initialDelayInMs, response.chunkDelayInMs);
+	return response;
+};
+/** Resolves a top-level response for a `doGenerate` call. */
+const resolveGenerate = async (response, options) => {
+	if (typeof response === "string") return buildGenerateResult({ content: [Content.text(response)] });
+	if (response instanceof Error) throw response;
+	if (isExplicit(response)) return response.generate === void 0 ? notImplemented("doGenerate") : resolveGenerateResponse(response.generate, options);
+	if ("content" in response) return buildGenerateResult(response);
+	return notImplemented("doGenerate");
+};
+/** Resolves a top-level response for a `doStream` call. */
+const resolveStream = async (response, options) => {
+	if (typeof response === "string") return buildStreamResult(textToStream(response));
+	if (response instanceof Error) throw response;
+	if (isExplicit(response)) return response.stream === void 0 ? notImplemented("doStream") : resolveStreamResponse(response.stream, options);
+	if ("content" in response) return buildStreamResult(contentToStream(response.content, response.finishReason, response.usage));
+	return notImplemented("doStream");
+};
+/** Picks the response for the current call: a single response repeats, an array advances and clamps. */
+const pickResponse = (input, callIndex) => {
+	if (!Array.isArray(input)) return input;
+	if (input.length === 0) return {};
+	return input[Math.min(callIndex, input.length - 1)] ?? {};
+};
+/**
+* A `LanguageModelV3` mock whose `doGenerate`/`doStream` are `vi.fn()` spies. Each call is also
+* recorded on `doGenerateCalls`/`doStreamCalls` so call arguments can be inspected without vitest.
+* Instances are created via the {@link MockLanguageModel} factory.
+*/
+var LanguageModelMock = class {
+	/** The language model spec version this mock implements. */
+	specificationVersion = "v3";
+	/** URL patterns the model supports — none, for a mock. */
+	supportedUrls = {};
+	/** The provider id. */
+	provider;
+	/** The model id. */
+	modelId;
+	/** Spy implementing `doGenerate`, resolving the configured response. */
+	doGenerate;
+	/** Spy implementing `doStream`, resolving the configured response. */
+	doStream;
+	/** Call options captured for every `doGenerate` invocation, in order. */
+	doGenerateCalls = [];
+	/** Call options captured for every `doStream` invocation, in order. */
+	doStreamCalls = [];
+	/** Builds the spies and identity from the configured response(s) and options. */
+	constructor(input = {}, options = {}) {
+		this.provider = options.provider ?? "mock-provider";
+		this.modelId = options.modelId ?? nextModelId();
+		this.doGenerate = vi.fn(async (callOptions) => {
+			const response = pickResponse(input, this.doGenerateCalls.length);
+			this.doGenerateCalls.push(callOptions);
+			return resolveGenerate(response, callOptions);
+		});
+		this.doStream = vi.fn(async (callOptions) => {
+			const response = pickResponse(input, this.doStreamCalls.length);
+			this.doStreamCalls.push(callOptions);
+			return resolveStream(response, callOptions);
+		});
+	}
+};
+/** Builds the content array for a generate result: a string becomes one text part; an array passes through. */
+const content = (input) => typeof input === "string" ? [Content.text(input)] : input;
+/** Builds a full generate result, filling finish reason, usage, and warnings. */
+const generateResult = (input) => buildGenerateResult(typeof input === "string" ? { content: [Content.text(input)] } : input);
+/** Builds a full stream result; a string is assembled into `stream-start` → text → `finish`. */
+const streamResult = (input, opts = {}) => buildStreamResult(typeof input === "string" ? textToStream(input) : input, opts.initialDelayInMs, opts.chunkDelayInMs);
+/** Builds a usage object, overriding individual token fields on top of the defaults. */
+const usage = (overrides = {}) => ({
+	inputTokens: {
+		...defaultUsage.inputTokens,
+		...overrides.inputTokens
+	},
+	outputTokens: {
+		...defaultUsage.outputTokens,
+		...overrides.outputTokens
+	}
+});
+/** Builds a finish reason from its unified value (raw mirrors it). */
+const finishReason = (unified = "stop") => toFinishReason(unified);
+/** Creates a mock `LanguageModelV3` from a response spec (or sequence of them). */
+const from = (input, options) => new LanguageModelMock(input ?? {}, options);
+/**
+* Namespace for building mock language models. `from` creates a mock `LanguageModelV3`; the other
+* builders assemble the values a model returns. Exported as both a value (the namespace) and a type
+* (the model instance).
+*
+* @example
+* const model = MockLanguageModel.from('Hello, world!');
+* const flaky = MockLanguageModel.from([new Error('rate limited'), 'recovered']);
+* const built = MockLanguageModel.from({ content: MockLanguageModel.content('Hi') });
+*/
+const MockLanguageModel = {
+	from,
+	content,
+	generateResult,
+	streamResult,
+	usage,
+	finishReason
+};
+
+//#endregion
+//#region src/language/options.ts
+/** Deterministic id generator so generated message ids are stable across runs. */
+const generateId = () => "aitxt-mock-id";
+/**
+* Determinism helpers to spread into `generateText`/`streamText` so ids and timestamps are stable.
+*
+* Note: `Options.stream` sets `_internal.now` to control timestamps, but the AI SDK has a bug where
+* the `finish-step` response timestamp in the error streaming path uses `new Date()` directly. Tests
+* that hit that path additionally need `vi.useFakeTimers()`.
+*
+* @example
+* await generateText({ model, prompt: 'x', ...Options.generate });
+* streamText({ model, prompt: 'x', ...Options.stream });
+*/
+const Options = {
+	generateId,
+	generate: { _internal: { generateId } },
+	stream: { _internal: {
+		generateId,
+		now: () => 0
+	} }
+};
+
+//#endregion
+export { Content, MockLanguageModel, Options, Stream, StreamParts };

package/dist/tokenize-C-Zp26iY.mjs

@@ -0,0 +1,13 @@
+//#region src/internal/tokenize.ts
+/**
+* Splits text into tokens. Shared by every streamed-text builder so chunking behavior lives
+* in one place. With no strategy the whole string is a single token.
+*/
+const tokenize = (text, { length, separator } = {}) => {
+	if (separator !== void 0) return text.split(separator).map((token) => token + separator);
+	if (length !== void 0) return text.split(new RegExp(`(.{1,${length}})`)).filter((token) => token.length > 0);
+	return [text];
+};
+
+//#endregion
+export { tokenize as t };