@codehz/ai 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1,67 +1,3 @@
-//#region src/types/adapter.ts
-const CAPABILITY_MATRIX = {
-	responses: {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: true,
-		toolCallStreaming: true,
-		hiddenReasoningReplay: "full",
-		replayFidelity: "high",
-		tools: true,
-		usage: "full",
-		billing: "lookup",
-		providerMetadata: true
-	},
-	messages: {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: true,
-		hiddenReasoningReplay: "partial",
-		replayFidelity: "medium",
-		tools: true,
-		usage: "full",
-		billing: "lookup",
-		providerMetadata: true
-	},
-	"chat.completions": {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: false,
-		hiddenReasoningReplay: "none",
-		replayFidelity: "low",
-		tools: true,
-		usage: "full",
-		billing: "derived",
-		providerMetadata: false
-	},
-	ollama: {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: false,
-		hiddenReasoningReplay: "none",
-		replayFidelity: "low",
-		tools: true,
-		usage: "partial",
-		billing: "none",
-		providerMetadata: false
-	},
-	mock: {
-		nativeStreaming: false,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: true,
-		hiddenReasoningReplay: "none",
-		replayFidelity: "high",
-		tools: true,
-		usage: "none",
-		billing: "none",
-		providerMetadata: true
-	}
-};
-//#endregion
 //#region src/core/errors.ts
 var AIError = class extends Error {
 	code;
@@ -901,12 +837,10 @@ function withTimeout(promise, ms) {
 //#region src/helpers/adapter-auxiliary.ts
 var AdapterAuxiliaryState = class {
 	request;
-	capabilities;
 	collector = new AuxiliaryCollector();
 	metadataSources = /* @__PURE__ */ new Set();
-	constructor(request, capabilities) {
+	constructor(request) {
 		this.request = request;
-		this.capabilities = capabilities;
 	}
 	recordUsage(usage, source, raw) {
 		if (this.request.include?.usage === "off" || isEmptyRecord(usage)) return;
@@ -930,8 +864,7 @@ var AdapterAuxiliaryState = class {
 					request: this.request,
 					usage: snapshot.usage,
 					billing: snapshot.billing,
-					auxiliary: snapshot.auxiliary,
-					capabilities: this.capabilities
+					auxiliary: snapshot.auxiliary
 				});
 				if (derived && !isEmptyRecord(derived)) this.collector.recordBilling({
 					...derived,
@@ -996,7 +929,7 @@ var AdapterBase = class {
 			responseId: request.requestId,
 			backend: {
 				kind: this.kind,
-				isSynthetic: !this.capabilities.nativeStreaming
+				isSynthetic: !this.nativeStreaming
 			}
 		});
 		yield factory.responseStarted(request.model);
@@ -1035,7 +968,7 @@ var AdapterBase = class {
 				requestId: request.requestId,
 				rawResponseId: result.rawResponseId,
 				adapter: this.kind,
-				isSyntheticStream: !this.capabilities.nativeStreaming,
+				isSyntheticStream: !this.nativeStreaming,
 				metadataSources: result.metadataSources,
 				warnings
 			}
@@ -1046,7 +979,7 @@ var AdapterBase = class {
 		return extractText(output);
 	}
 	createAuxiliaryState(request) {
-		return new AdapterAuxiliaryState(request, this.capabilities);
+		return new AdapterAuxiliaryState(request);
 	}
 };
 function mergeAuxiliary(base, patch) {
@@ -1187,7 +1120,7 @@ function canonicalToResponsesBlock(b) {
 }
 var ResponsesAdapter = class extends AdapterBase {
 	kind = "responses";
-	capabilities = CAPABILITY_MATRIX.responses;
+	nativeStreaming = true;
 	apiKey;
 	baseUrl;
 	fetchFn;
@@ -1491,7 +1424,7 @@ function buildStreamMetadata(options) {
 }
 var MessagesAdapter = class extends AdapterBase {
 	kind = "messages";
-	capabilities = CAPABILITY_MATRIX.messages;
+	nativeStreaming = true;
 	apiKey;
 	apiVersion;
 	baseUrl;
@@ -1945,26 +1878,10 @@ function buildAssistantReplayMessage(params) {
 }
 var ChatCompletionsAdapter = class extends AdapterBase {
 	kind = "chat-completions";
-	capabilities = {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: false,
-		hiddenReasoningReplay: "none",
-		replayFidelity: "low",
-		tools: true,
-		usage: "full",
-		billing: "derived",
-		providerMetadata: false
-	};
+	nativeStreaming = true;
 	apiKey;
 	baseUrl;
 	fetchFn;
-	markReasoningCompatibility() {
-		this.capabilities.reasoningStreaming = true;
-		this.capabilities.hiddenReasoningReplay = "partial";
-		this.capabilities.replayFidelity = "medium";
-	}
 	constructor(options) {
 		super();
 		this.apiKey = options.apiKey;
@@ -2089,7 +2006,6 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 		let currentReasoningId = "";
 		let hasMessageStarted = false;
 		let hasReasoningStarted = false;
-		let hasStreamedReasoning = false;
 		const pendingToolCalls = /* @__PURE__ */ new Map();
 		const reasoningByField = /* @__PURE__ */ new Map();
 		const finalizePendingTurn = () => {
@@ -2164,7 +2080,6 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 							if (!hasReasoningStarted) {
 								currentReasoningId = `reason-${chunk.id}`;
 								hasReasoningStarted = true;
-								hasStreamedReasoning = true;
 								accumulatedReasoning = "";
 								yield factory.reasoningStarted(currentReasoningId, "full");
 							}
@@ -2222,7 +2137,6 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 						if (finishReason && finishReason !== null) {
 							const { events, assistantReplayMessage } = finalizePendingTurn();
 							for (const event of events) yield event;
-							if (hasStreamedReasoning) this.markReasoningCompatibility();
 							const stopReason = mapStopReason(finishReason);
 							const replay = [...replayFromOutput(output)];
 							if (assistantReplayMessage) replay.push(opaqueItem("chat.completions", "replay", {
@@ -2252,7 +2166,6 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 		if (buffer.trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Chat Completions SSE frame", "STREAM_ERROR");
 		if (hasMessageStarted || hasReasoningStarted || pendingToolCalls.size > 0) {
 			yield factory.responseWarning("Stream ended without a finish_reason", "INCOMPLETE_STREAM");
-			if (hasStreamedReasoning) this.markReasoningCompatibility();
 			const { events, assistantReplayMessage } = finalizePendingTurn();
 			for (const event of events) yield event;
 			const replay = [...replayFromOutput(output)];
@@ -2357,18 +2270,7 @@ function isOllamaToolCalls(value) {
 }
 var OllamaAdapter = class extends AdapterBase {
 	kind = "ollama";
-	capabilities = {
-		nativeStreaming: true,
-		messageStreaming: true,
-		reasoningStreaming: false,
-		toolCallStreaming: false,
-		hiddenReasoningReplay: "none",
-		replayFidelity: "low",
-		tools: true,
-		usage: "partial",
-		billing: "none",
-		providerMetadata: false
-	};
+	nativeStreaming = true;
 	baseUrl;
 	apiKey;
 	fetchFn;
@@ -2609,18 +2511,34 @@ var OllamaAdapter = class extends AdapterBase {
 /**
 * Mock Adapter
 *
-* 面向测试的脚本化 adapter：
-* - 按 turn 顺序消费请求，验证调用方是否正确续接 replay / tool_result
+* 面向测试的回调驱动 adapter：
+* - 每次请求执行用户提供的 handler
+* - 验证调用方是否正确续接 replay / tool_result
 * - 发出可控的 message / reasoning / tool_call 流
 * - 注入 warning / auxiliary / content_filter / 中断 / provider error
 *
 * 这不是通用“假模型”，而是测试工具调用编排与错误路径的测试夹具。
 */
+function assertMockRequest(request, expectation, context) {
+	const prefix = `MockAdapter turn ${context.turnIndex + 1} expectation failed`;
+	if (expectation.minItems !== void 0 && request.input.length < expectation.minItems) throw new AIRequestError(`${prefix}: expected at least ${expectation.minItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.maxItems !== void 0 && request.input.length > expectation.maxItems) throw new AIRequestError(`${prefix}: expected at most ${expectation.maxItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.tools === "present" && (!request.tools || request.tools.length === 0)) throw new AIRequestError(`${prefix}: expected tools to be present`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.tools === "absent" && request.tools && request.tools.length > 0) throw new AIRequestError(`${prefix}: expected tools to be absent`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.toolChoice === "present" && request.toolChoice === void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be present`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.toolChoice === "absent" && request.toolChoice !== void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be absent`, "MOCK_EXPECTATION_FAILED");
+	if (expectation.requireReplayFromPreviousTurn && context.previousReplay.length > 0) assertReplayIncluded(request.input, context.previousReplay, prefix);
+	if (expectation.requireToolResultsForPendingCalls && context.pendingToolCalls.length > 0) {
+		const toolResultIds = new Set(request.input.filter((item) => item.type === "tool_result").map((item) => item.callId));
+		for (const call of context.pendingToolCalls) if (!toolResultIds.has(call.id)) throw new AIRequestError(`${prefix}: expected tool_result for pending tool call "${call.id}"`, "MOCK_EXPECTATION_FAILED");
+	}
+	if (expectation.items && expectation.items.length > 0) if (expectation.ordered) assertOrderedItems(request.input, expectation.items, prefix);
+	else assertUnorderedItems(request.input, expectation.items, prefix);
+}
 var MockAdapter = class extends AdapterBase {
 	kind = "mock";
-	capabilities = CAPABILITY_MATRIX.mock;
-	turns;
-	onExhausted;
+	nativeStreaming = false;
+	handler;
 	providerMetadata;
 	cursor = 0;
 	previousReplay = [];
@@ -2629,24 +2547,19 @@ var MockAdapter = class extends AdapterBase {
 	activeStream = false;
 	constructor(options) {
 		super();
-		this.turns = options.turns;
-		this.onExhausted = options.onExhausted ?? "throw";
+		this.handler = options.handler;
 		this.providerMetadata = options.providerMetadata;
 	}
 	async buildRequest(request) {
 		const turnIndex = this.cursor;
-		const turn = this.resolveTurn(turnIndex);
-		const turnName = turn.name;
-		const context = this.buildTurnContext(turnIndex);
-		if (turn.expect) if (typeof turn.expect === "function") await turn.expect(request, context);
-		else assertRequestMatchesExpectation(request, turn.expect, context);
+		const context = this.buildHandlerContext(turnIndex);
 		const remainingPendingToolCalls = consumePendingToolCalls(this.pendingToolCalls, request.input);
+		const handlerResult = this.handler(request, context);
 		this.cursor += 1;
 		return {
 			request,
-			turn,
+			handlerResult,
 			turnIndex,
-			turnName,
 			remainingPendingToolCalls
 		};
 	}
@@ -2656,76 +2569,79 @@ var MockAdapter = class extends AdapterBase {
 		try {
 			const mockRequest = providerRequest;
 			const output = [];
-			for (const [stepIndex, step] of mockRequest.turn.steps.entries()) switch (step.type) {
-				case "warning":
-					yield factory.responseWarning(step.message, step.code);
-					break;
-				case "auxiliary":
-					yield factory.responseAuxiliary({
-						usage: step.usage,
-						billing: step.billing,
-						auxiliary: step.auxiliary
-					});
-					break;
-				case "message": {
-					const item = createMessageFromStep(step, request, mockRequest.turnIndex, stepIndex);
-					yield* emitMessage(factory, item);
-					output.push(item);
-					break;
-				}
-				case "reasoning": {
-					const item = createReasoningFromStep(step, request, mockRequest.turnIndex, stepIndex);
-					yield* emitReasoning(factory, item);
-					output.push(item);
-					break;
-				}
-				case "tool_call": {
-					const item = createToolCallFromStep(step);
-					yield* emitToolCall(factory, item, step.streamArguments ?? true);
-					output.push(item);
-					break;
-				}
-				case "output": {
-					assertSupportedOutputItem(step.item);
-					const item = attachSyntheticId(step.item, request, mockRequest.turnIndex, stepIndex);
-					yield* emitOutputItem(factory, item);
-					output.push(item);
-					break;
-				}
-				case "complete": {
-					const response = this.finalizeTurn(request, factory, mockRequest, output, step);
-					yield factory.responseCompleted(response);
-					return;
-				}
-				case "error": {
-					yield factory.responseWarning(step.message, step.code);
-					const response = this.finalizeTurn(request, factory, mockRequest, output, {
-						type: "complete",
-						stopReason: step.stopReason ?? "error",
-						providerMetadata: step.providerMetadata
-					});
-					yield factory.responseCompleted(response);
-					return;
+			let stepCount = 0;
+			for await (const step of mockRequest.handlerResult) {
+				stepCount += 1;
+				switch (step.type) {
+					case "warning":
+						yield factory.responseWarning(step.message, step.code);
+						break;
+					case "auxiliary":
+						yield factory.responseAuxiliary({
+							usage: step.usage,
+							billing: step.billing,
+							auxiliary: step.auxiliary
+						});
+						break;
+					case "message": {
+						const item = createMessageFromStep(step, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitMessage(factory, item, resolveStepStreamOptions(void 0, step.stream, "message"));
+						output.push(item);
+						break;
+					}
+					case "reasoning": {
+						const item = createReasoningFromStep(step, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitReasoning(factory, item, resolveStepStreamOptions(void 0, step.stream, "reasoning"));
+						output.push(item);
+						break;
+					}
+					case "tool_call": {
+						const item = createToolCallFromStep(step);
+						yield* emitToolCall(factory, item, step.streamArguments ?? true, resolveStepStreamOptions(void 0, step.stream, "tool_call"));
+						output.push(item);
+						break;
+					}
+					case "output": {
+						assertSupportedOutputItem(step.item);
+						const item = attachSyntheticId(step.item, request, mockRequest.turnIndex, stepCount - 1);
+						yield* emitOutputItem(factory, item, resolveStepStreamOptions(void 0, step.stream, "output"));
+						output.push(item);
+						break;
+					}
+					case "complete": {
+						const response = this.finalizeTurn(request, factory, mockRequest, output, step, stepCount);
+						yield factory.responseCompleted(response);
+						return;
+					}
+					case "error": {
+						yield factory.responseWarning(step.message, step.code);
+						const response = this.finalizeTurn(request, factory, mockRequest, output, {
+							type: "complete",
+							stopReason: step.stopReason ?? "error",
+							providerMetadata: step.providerMetadata
+						}, stepCount);
+						yield factory.responseCompleted(response);
+						return;
+					}
+					case "interrupt":
+						this.pendingToolCalls = mockRequest.remainingPendingToolCalls;
+						return;
+					case "throw": throw typeof step.error === "string" ? new Error(step.error) : step.error;
 				}
-				case "interrupt":
-					this.pendingToolCalls = mockRequest.remainingPendingToolCalls;
-					return;
-				case "throw": throw typeof step.error === "string" ? new Error(step.error) : step.error;
 			}
-			const response = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" });
+			const response = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" }, stepCount);
 			yield factory.responseCompleted(response);
 		} finally {
 			this.activeStream = false;
 		}
 	}
-	finalizeTurn(request, factory, mockRequest, output, completion) {
+	finalizeTurn(request, factory, mockRequest, output, completion, stepCount) {
 		const replay = completion.replay ?? replayFromOutput(output);
 		const toolCalls = output.filter((item) => item.type === "tool_call");
 		this.previousReplay = replay;
 		this.pendingToolCalls = [...mockRequest.remainingPendingToolCalls, ...toolCalls];
 		this.history.push({
 			turnIndex: mockRequest.turnIndex,
-			turnName: mockRequest.turnName,
 			requestId: request.requestId,
 			replay,
 			toolCalls
@@ -2739,8 +2655,7 @@ var MockAdapter = class extends AdapterBase {
 			auxiliary: completion.auxiliary,
 			providerMetadata: {
 				turnIndex: mockRequest.turnIndex,
-				turnName: mockRequest.turnName,
-				scriptedSteps: mockRequest.turn.steps.length,
+				stepCount,
 				pendingToolCallIds: this.pendingToolCalls.map((item) => item.id),
 				historyLength: this.history.length,
 				...this.providerMetadata,
@@ -2751,18 +2666,7 @@ var MockAdapter = class extends AdapterBase {
 			rawResponseId: completion.rawResponseId
 		}, factory);
 	}
-	resolveTurn(turnIndex) {
-		const turn = this.turns[turnIndex];
-		if (turn !== void 0) return turn;
-		const lastTurn = this.turns.at(-1);
-		if (this.onExhausted === "repeat-last" && lastTurn !== void 0) return lastTurn;
-		if (this.onExhausted === "complete-empty") return {
-			name: "exhausted",
-			steps: []
-		};
-		throw new AIRequestError(`MockAdapter turn ${turnIndex + 1} requested, but only ${this.turns.length} turn(s) were scripted`, "MOCK_TURN_EXHAUSTED");
-	}
-	buildTurnContext(turnIndex) {
+	buildHandlerContext(turnIndex) {
 		return {
 			turnIndex,
 			previousReplay: this.previousReplay.map(cloneItem),
@@ -2775,6 +2679,32 @@ var MockAdapter = class extends AdapterBase {
 		};
 	}
 };
+function withMockStreaming(handler, options) {
+	const defaults = resolveMockTextStreamOptions(options, "mock stream wrapper");
+	if (!defaults) throw new AIRequestError("mock stream wrapper requires streaming options", "MOCK_STREAM_CONFIG_INVALID");
+	return async function* streamWrappedHandler(request, context) {
+		const source = await handler(request, context);
+		for await (const step of source) yield applyDefaultStreaming(step, defaults);
+	};
+}
+function applyDefaultStreaming(step, defaults) {
+	switch (step.type) {
+		case "message":
+		case "reasoning":
+		case "tool_call":
+		case "output":
+			if (step.stream !== void 0) return step;
+			return {
+				...step,
+				stream: {
+					charsPerSecond: defaults.charsPerSecond,
+					chunkSize: defaults.chunkSize,
+					initialDelayMs: defaults.initialDelayMs
+				}
+			};
+		default: return step;
+	}
+}
 function createMessageFromStep(step, request, turnIndex, stepIndex) {
 	return {
 		...messageItem(normalizeBlocks(step.content), { id: step.id ?? `mock-msg-${request.requestId}-${turnIndex}-${stepIndex}` }),
@@ -2811,34 +2741,95 @@ function attachSyntheticId(item, request, turnIndex, stepIndex) {
 	};
 	return item;
 }
-async function* emitOutputItem(factory, item) {
+async function* emitOutputItem(factory, item, stream) {
 	if (item.type === "message") {
-		yield* emitMessage(factory, item);
+		yield* emitMessage(factory, item, stream);
 		return;
 	}
 	if (item.type === "reasoning") {
-		yield* emitReasoning(factory, item);
+		yield* emitReasoning(factory, item, stream);
 		return;
 	}
-	yield* emitToolCall(factory, item, true);
+	yield* emitToolCall(factory, item, true, stream);
 }
-async function* emitMessage(factory, item) {
+async function* emitMessage(factory, item, stream) {
 	if (!item.id) throw new AIRequestError("Mock message output requires an id after normalization", "MOCK_MESSAGE_ID_MISSING");
 	yield factory.messageStarted(item.id);
-	for (const block of item.content) if (block.type === "text") yield factory.messageDelta(item.id, block.text);
+	let chunkIndex = 0;
+	for (const block of item.content) if (block.type === "text") for (const chunk of chunkText(block.text, stream)) {
+		await delayForChunk(stream, chunkIndex, chunk.length);
+		yield factory.messageDelta(item.id, chunk);
+		chunkIndex += 1;
+	}
 	yield factory.messageCompleted(item);
 }
-async function* emitReasoning(factory, item) {
+async function* emitReasoning(factory, item, stream) {
 	if (!item.id) throw new AIRequestError("Mock reasoning output requires an id after normalization", "MOCK_REASONING_ID_MISSING");
 	yield factory.reasoningStarted(item.id, item.visibility);
-	for (const block of item.content) yield factory.reasoningDelta(item.id, block);
+	let chunkIndex = 0;
+	for (const block of item.content) {
+		if (block.type !== "text") {
+			yield factory.reasoningDelta(item.id, block);
+			continue;
+		}
+		for (const chunk of chunkText(block.text, stream)) {
+			await delayForChunk(stream, chunkIndex, chunk.length);
+			yield factory.reasoningDelta(item.id, textBlock(chunk));
+			chunkIndex += 1;
+		}
+	}
 	yield factory.reasoningCompleted(item);
 }
-async function* emitToolCall(factory, item, streamArguments) {
+async function* emitToolCall(factory, item, streamArguments, stream) {
 	yield factory.toolCallStarted(item.id, item.name);
-	if (streamArguments && item.argumentsText) yield factory.toolCallDelta(item.id, { argumentsText: item.argumentsText });
+	if (streamArguments && item.argumentsText) {
+		let chunkIndex = 0;
+		for (const chunk of chunkText(item.argumentsText, stream)) {
+			await delayForChunk(stream, chunkIndex, chunk.length);
+			yield factory.toolCallDelta(item.id, { argumentsText: chunk });
+			chunkIndex += 1;
+		}
+	}
 	yield factory.toolCallCompleted(item);
 }
+function resolveStepStreamOptions(defaults, override, label) {
+	if (override === false) return;
+	return resolveMockTextStreamOptions(override, `${label} stream`, defaults);
+}
+function resolveMockTextStreamOptions(options, label, defaults) {
+	if (options === void 0) return defaults;
+	const chunkSize = options.chunkSize ?? defaults?.chunkSize ?? 1;
+	const initialDelayMs = options.initialDelayMs ?? defaults?.initialDelayMs ?? 0;
+	const charsPerSecond = options.charsPerSecond ?? defaults?.charsPerSecond;
+	if (!Number.isInteger(chunkSize) || chunkSize < 1) throw new AIRequestError(`${label}: chunkSize must be a positive integer`, "MOCK_STREAM_CONFIG_INVALID");
+	if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) throw new AIRequestError(`${label}: initialDelayMs must be a non-negative number`, "MOCK_STREAM_CONFIG_INVALID");
+	if (charsPerSecond !== void 0 && (!Number.isFinite(charsPerSecond) || charsPerSecond <= 0)) throw new AIRequestError(`${label}: charsPerSecond must be a positive number`, "MOCK_STREAM_CONFIG_INVALID");
+	return {
+		chunkSize,
+		initialDelayMs,
+		charsPerSecond
+	};
+}
+function chunkText(text, stream) {
+	if (!text) return [];
+	if (!stream) return [text];
+	const chars = Array.from(text);
+	const chunks = [];
+	for (let index = 0; index < chars.length; index += stream.chunkSize) chunks.push(chars.slice(index, index + stream.chunkSize).join(""));
+	return chunks;
+}
+async function delayForChunk(stream, chunkIndex, chunkLength) {
+	if (!stream) return;
+	if (chunkIndex === 0 && stream.initialDelayMs > 0) {
+		await sleep(stream.initialDelayMs);
+		return;
+	}
+	if (chunkIndex > 0 && stream.charsPerSecond !== void 0) await sleep(chunkLength / stream.charsPerSecond * 1e3);
+}
+async function sleep(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
 function resolveStopReason(output) {
 	return output.some((item) => item.type === "tool_call") ? "tool_call" : "end_turn";
 }
@@ -2846,22 +2837,6 @@ function consumePendingToolCalls(pending, input) {
 	const fulfilledIds = new Set(input.filter((item) => item.type === "tool_result").map((item) => item.callId));
 	return pending.filter((item) => !fulfilledIds.has(item.id)).map(cloneItem);
 }
-function assertRequestMatchesExpectation(request, expectation, context) {
-	const prefix = `MockAdapter turn ${context.turnIndex + 1} expectation failed`;
-	if (expectation.minItems !== void 0 && request.input.length < expectation.minItems) throw new AIRequestError(`${prefix}: expected at least ${expectation.minItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.maxItems !== void 0 && request.input.length > expectation.maxItems) throw new AIRequestError(`${prefix}: expected at most ${expectation.maxItems} input item(s)`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.tools === "present" && (!request.tools || request.tools.length === 0)) throw new AIRequestError(`${prefix}: expected tools to be present`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.tools === "absent" && request.tools && request.tools.length > 0) throw new AIRequestError(`${prefix}: expected tools to be absent`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.toolChoice === "present" && request.toolChoice === void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be present`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.toolChoice === "absent" && request.toolChoice !== void 0) throw new AIRequestError(`${prefix}: expected toolChoice to be absent`, "MOCK_EXPECTATION_FAILED");
-	if (expectation.requireReplayFromPreviousTurn && context.previousReplay.length > 0) assertReplayIncluded(request.input, context.previousReplay, prefix);
-	if (expectation.requireToolResultsForPendingCalls && context.pendingToolCalls.length > 0) {
-		const toolResultIds = new Set(request.input.filter((item) => item.type === "tool_result").map((item) => item.callId));
-		for (const call of context.pendingToolCalls) if (!toolResultIds.has(call.id)) throw new AIRequestError(`${prefix}: expected tool_result for pending tool call "${call.id}"`, "MOCK_EXPECTATION_FAILED");
-	}
-	if (expectation.items && expectation.items.length > 0) if (expectation.ordered) assertOrderedItems(request.input, expectation.items, prefix);
-	else assertUnorderedItems(request.input, expectation.items, prefix);
-}
 function assertReplayIncluded(input, replay, prefix) {
 	const fingerprints = input.map(fingerprintItem);
 	let cursor = 0;
@@ -3028,6 +3003,6 @@ function* emitToolCallEvents(item, factory) {
 	yield factory.toolCallCompleted(item);
 }
 //#endregion
-export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, CAPABILITY_MATRIX, ChatCompletionsAdapter, MessagesAdapter, MockAdapter, OllamaAdapter, ResponsesAdapter, WarningCode, aggregateEvents, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest };
+export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, ChatCompletionsAdapter, MessagesAdapter, MockAdapter, OllamaAdapter, ResponsesAdapter, WarningCode, aggregateEvents, assertMockRequest, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest, withMockStreaming };
 
 //# sourceMappingURL=index.mjs.map