@codehz/ai 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,55 +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
-	}
-};
-//#endregion
 //#region src/core/errors.ts
 var AIError = class extends Error {
 	code;
@@ -491,17 +439,14 @@ function createEventFactory(state) {
 }
 //#endregion
 //#region src/core/aggregator.ts
-function createInitialState() {
+function createAggregatorState() {
 	return {
-		pendingMessages: /* @__PURE__ */ new Map(),
-		pendingReasonings: /* @__PURE__ */ new Map(),
-		pendingToolCalls: /* @__PURE__ */ new Map(),
-		outputOrder: [],
-		completedMessages: /* @__PURE__ */ new Map(),
-		completedReasonings: /* @__PURE__ */ new Map(),
-		completedToolCalls: /* @__PURE__ */ new Map(),
 		auxiliary: {},
-		warnings: []
+		warnings: [],
+		warningSet: /* @__PURE__ */ new Set(),
+		output: [],
+		textParts: [],
+		toolCalls: []
 	};
 }
 function handleResponseStarted(state, event) {
@@ -523,55 +468,16 @@ function handleResponseAuxiliary(state, event) {
 	};
 	if (event.auxiliary) state.auxiliary = mergeAuxiliary$1(state.auxiliary, event.auxiliary);
 }
-function handleMessageStarted(state, event) {
-	state.pendingMessages.set(event.item.id, {
-		role: event.item.role,
-		texts: []
-	});
-}
-function handleMessageDelta(state, event) {
-	const pending = state.pendingMessages.get(event.itemId);
-	if (pending) pending.texts.push(event.delta.text);
-}
 function handleMessageCompleted(state, event) {
-	const item = event.item;
-	const itemId = item.id ?? `msg-${state.outputOrder.length}`;
-	state.completedMessages.set(itemId, item);
-	state.outputOrder.push(itemId);
-	state.pendingMessages.delete(itemId);
-}
-function handleReasoningStarted(state, event) {
-	state.pendingReasonings.set(event.item.id, {
-		visibility: event.item.visibility,
-		blocks: []
-	});
-}
-function handleReasoningDelta(state, event) {
-	const pending = state.pendingReasonings.get(event.itemId);
-	if (pending) pending.blocks.push(event.delta);
+	state.output.push(event.item);
+	pushMessageText(state, event.item);
 }
 function handleReasoningCompleted(state, event) {
-	const item = event.item;
-	const stableId = item.id ?? `reason-${state.outputOrder.length}-${Date.now()}`;
-	state.completedReasonings.set(stableId, item);
-	state.outputOrder.push(stableId);
-	state.pendingReasonings.delete(item.id ?? "");
-}
-function handleToolCallStarted(state, event) {
-	state.pendingToolCalls.set(event.item.id, {
-		name: event.item.name,
-		argsParts: []
-	});
-}
-function handleToolCallDelta(state, event) {
-	const pending = state.pendingToolCalls.get(event.itemId);
-	if (pending && event.delta.argumentsText) pending.argsParts.push(event.delta.argumentsText);
+	state.output.push(event.item);
 }
 function handleToolCallCompleted(state, event) {
-	const item = event.item;
-	state.completedToolCalls.set(item.id, item);
-	state.outputOrder.push(item.id);
-	state.pendingToolCalls.delete(item.id);
+	state.output.push(event.item);
+	state.toolCalls.push(event.item);
 }
 function handleResponseCompleted(state, event) {
 	state.replayFromAdapter = event.response.replay;
@@ -590,26 +496,6 @@ function handleResponseCompleted(state, event) {
 	if (event.response.warnings) pushWarnings(state, event.response.warnings);
 }
 function buildResponse(state) {
-	const output = [];
-	for (const id of state.outputOrder) {
-		const msg = state.completedMessages.get(id);
-		if (msg) {
-			output.push(msg);
-			continue;
-		}
-		const reason = state.completedReasonings.get(id);
-		if (reason) {
-			output.push(reason);
-			continue;
-		}
-		const tc = state.completedToolCalls.get(id);
-		if (tc) {
-			output.push(tc);
-			continue;
-		}
-	}
-	const text = output.filter((item) => item.type === "message").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("");
-	const toolCalls = output.filter((item) => item.type === "tool_call");
 	const backendFromResponse = state.backendFromAdapter;
 	const backend = {
 		adapter: backendFromResponse?.adapter ?? state.backendInfo?.kind ?? "unknown",
@@ -621,10 +507,10 @@ function buildResponse(state) {
 	};
 	return {
 		id: state.responseIdFromAdapter ?? state.responseId,
-		output,
+		output: state.output,
 		replay: state.replayFromAdapter ?? [],
-		text,
-		toolCalls,
+		text: state.textParts.join(""),
+		toolCalls: state.toolCalls,
 		stopReason: state.stopReasonFromAdapter,
 		usage: state.usage,
 		billing: state.billing,
@@ -638,8 +524,13 @@ function buildResponse(state) {
 * 适用于测试和离线处理场景。
 */
 function aggregateEvents(events) {
-	const state = createInitialState();
-	for (const event of events) switch (event.type) {
+	const state = createAggregatorState();
+	for (const event of events) aggregateEvent(state, event);
+	return finalizeAggregation(state);
+}
+function aggregateEvent(state, event) {
+	state.lastEventType = event.type;
+	switch (event.type) {
 		case "response.started":
 			handleResponseStarted(state, event);
 			break;
@@ -650,29 +541,17 @@ function aggregateEvents(events) {
 			handleResponseAuxiliary(state, event);
 			break;
 		case "message.started":
-			handleMessageStarted(state, event);
-			break;
 		case "message.delta":
-			handleMessageDelta(state, event);
-			break;
-		case "message.completed":
-			handleMessageCompleted(state, event);
-			break;
 		case "reasoning.started":
-			handleReasoningStarted(state, event);
-			break;
 		case "reasoning.delta":
-			handleReasoningDelta(state, event);
+		case "tool_call.started":
+		case "tool_call.delta": break;
+		case "message.completed":
+			handleMessageCompleted(state, event);
 			break;
 		case "reasoning.completed":
 			handleReasoningCompleted(state, event);
 			break;
-		case "tool_call.started":
-			handleToolCallStarted(state, event);
-			break;
-		case "tool_call.delta":
-			handleToolCallDelta(state, event);
-			break;
 		case "tool_call.completed":
 			handleToolCallCompleted(state, event);
 			break;
@@ -680,8 +559,9 @@ function aggregateEvents(events) {
 			handleResponseCompleted(state, event);
 			break;
 	}
-	const lastEvent = events[events.length - 1];
-	if (!lastEvent || lastEvent.type !== "response.completed") throw new Error("Stream must end with response.completed event to produce a valid AIResponse");
+}
+function finalizeAggregation(state) {
+	if (state.lastEventType !== "response.completed") throw new Error("Stream must end with response.completed event to produce a valid AIResponse");
 	return buildResponse(state);
 }
 function mergeAuxiliary$1(base, patch) {
@@ -690,20 +570,26 @@ function mergeAuxiliary$1(base, patch) {
 		...patch
 	};
 	if (base.providerMetadata || patch.providerMetadata) merged.providerMetadata = {
-		...base.providerMetadata ?? {},
-		...patch.providerMetadata ?? {}
+		...base.providerMetadata,
+		...patch.providerMetadata
 	};
 	return merged;
 }
 function pushWarnings(state, warnings) {
-	for (const warning of warnings) if (!state.warnings.includes(warning)) state.warnings.push(warning);
+	for (const warning of warnings) if (!state.warningSet.has(warning)) {
+		state.warningSet.add(warning);
+		state.warnings.push(warning);
+	}
+}
+function pushMessageText(state, item) {
+	for (const block of item.content) if (block.type === "text") state.textParts.push(block.text);
 }
 //#endregion
 //#region src/core/collect-stream.ts
 async function collectStream(stream) {
-	const events = [];
-	for await (const event of stream) events.push(event);
-	return aggregateEvents(events);
+	const state = createAggregatorState();
+	for await (const event of stream) aggregateEvent(state, event);
+	return finalizeAggregation(state);
 }
 //#endregion
 //#region src/helpers/mapping.ts
@@ -951,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;
@@ -980,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,
@@ -1046,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);
@@ -1085,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
 			}
@@ -1096,18 +979,18 @@ var AdapterBase = class {
 		return extractText(output);
 	}
 	createAuxiliaryState(request) {
-		return new AdapterAuxiliaryState(request, this.capabilities);
+		return new AdapterAuxiliaryState(request);
 	}
 };
 function mergeAuxiliary(base, patch) {
 	if (!base && !patch) return void 0;
 	const merged = {
-		...base ?? {},
-		...patch ?? {}
+		...base,
+		...patch
 	};
 	if (base?.providerMetadata || patch?.providerMetadata) merged.providerMetadata = {
-		...base?.providerMetadata ?? {},
-		...patch?.providerMetadata ?? {}
+		...base?.providerMetadata,
+		...patch?.providerMetadata
 	};
 	return merged;
 }
@@ -1189,6 +1072,7 @@ function parseSSEEvents(chunk) {
 function ensureResponsesTextBlocks(blocks, field) {
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
+		if (!block) continue;
 		if (block.type !== "text" && block.type !== "json") throw new AIRequestError(`responses does not support ${field}[${i}] of type "${block.type}"; only text/json blocks are supported`, "UNSUPPORTED_CONTENT_BLOCK");
 	}
 	return blocks;
@@ -1236,7 +1120,7 @@ function canonicalToResponsesBlock(b) {
 }
 var ResponsesAdapter = class extends AdapterBase {
 	kind = "responses";
-	capabilities = CAPABILITY_MATRIX.responses;
+	nativeStreaming = true;
 	apiKey;
 	baseUrl;
 	fetchFn;
@@ -1468,6 +1352,7 @@ var ResponsesAdapter = class extends AdapterBase {
 function ensureMessagesTextBlocks(blocks, field) {
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
+		if (!block) continue;
 		if (block.type !== "text" && block.type !== "json") throw new AIRequestError(`messages does not support ${field}[${i}] of type "${block.type}"; only text/json blocks are supported`, "UNSUPPORTED_CONTENT_BLOCK");
 	}
 	return blocks;
@@ -1539,7 +1424,7 @@ function buildStreamMetadata(options) {
 }
 var MessagesAdapter = class extends AdapterBase {
 	kind = "messages";
-	capabilities = CAPABILITY_MATRIX.messages;
+	nativeStreaming = true;
 	apiKey;
 	apiVersion;
 	baseUrl;
@@ -1932,6 +1817,7 @@ function parseChatSSE(buffer) {
 function ensureTextCompatibleBlocks(blocks, field) {
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
+		if (!block) continue;
 		if (block.type !== "text" && block.type !== "json") throw new AIRequestError(`chat-completions does not support ${field}[${i}] of type "${block.type}"; only text/json blocks are supported`, "UNSUPPORTED_CONTENT_BLOCK");
 	}
 	return blocks;
@@ -1992,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;
@@ -2136,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 = () => {
@@ -2211,7 +2080,6 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 							if (!hasReasoningStarted) {
 								currentReasoningId = `reason-${chunk.id}`;
 								hasReasoningStarted = true;
-								hasStreamedReasoning = true;
 								accumulatedReasoning = "";
 								yield factory.reasoningStarted(currentReasoningId, "full");
 							}
@@ -2269,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", {
@@ -2299,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)];
@@ -2343,6 +2209,7 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 function ensureOllamaTextBlocks(blocks, field) {
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
+		if (!block) continue;
 		if (block.type !== "text" && block.type !== "json") throw new AIRequestError(`ollama does not support ${field}[${i}] of type "${block.type}"; only text/json blocks are supported`, "UNSUPPORTED_CONTENT_BLOCK");
 	}
 	return blocks;
@@ -2403,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;
@@ -2651,6 +2507,390 @@ var OllamaAdapter = class extends AdapterBase {
 	}
 };
 //#endregion
+//#region src/adapters/mock.ts
+/**
+* Mock Adapter
+*
+* 面向测试的脚本化 adapter：
+* - 按 turn 顺序消费请求，验证调用方是否正确续接 replay / tool_result
+* - 发出可控的 message / reasoning / tool_call 流
+* - 注入 warning / auxiliary / content_filter / 中断 / provider error
+*
+* 这不是通用“假模型”，而是测试工具调用编排与错误路径的测试夹具。
+*/
+var MockAdapter = class extends AdapterBase {
+	kind = "mock";
+	nativeStreaming = false;
+	turns;
+	onExhausted;
+	providerMetadata;
+	defaultStream;
+	cursor = 0;
+	previousReplay = [];
+	pendingToolCalls = [];
+	history = [];
+	activeStream = false;
+	constructor(options) {
+		super();
+		this.turns = options.turns;
+		this.onExhausted = options.onExhausted ?? "throw";
+		this.providerMetadata = options.providerMetadata;
+		this.defaultStream = resolveMockTextStreamOptions(options.stream, "adapter stream");
+	}
+	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 remainingPendingToolCalls = consumePendingToolCalls(this.pendingToolCalls, request.input);
+		this.cursor += 1;
+		return {
+			request,
+			turn,
+			turnIndex,
+			turnName,
+			remainingPendingToolCalls
+		};
+	}
+	async *runStream(providerRequest, factory, request) {
+		if (this.activeStream) throw new AIRequestError("MockAdapter does not support concurrent streams", "MOCK_CONCURRENT_STREAM");
+		this.activeStream = true;
+		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, resolveStepStreamOptions(this.defaultStream, step.stream, "message"));
+					output.push(item);
+					break;
+				}
+				case "reasoning": {
+					const item = createReasoningFromStep(step, request, mockRequest.turnIndex, stepIndex);
+					yield* emitReasoning(factory, item, resolveStepStreamOptions(this.defaultStream, step.stream, "reasoning"));
+					output.push(item);
+					break;
+				}
+				case "tool_call": {
+					const item = createToolCallFromStep(step);
+					yield* emitToolCall(factory, item, step.streamArguments ?? true, resolveStepStreamOptions(this.defaultStream, step.stream, "tool_call"));
+					output.push(item);
+					break;
+				}
+				case "output": {
+					assertSupportedOutputItem(step.item);
+					const item = attachSyntheticId(step.item, request, mockRequest.turnIndex, stepIndex);
+					yield* emitOutputItem(factory, item, resolveStepStreamOptions(this.defaultStream, step.stream, "output"));
+					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;
+				}
+				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" });
+			yield factory.responseCompleted(response);
+		} finally {
+			this.activeStream = false;
+		}
+	}
+	finalizeTurn(request, factory, mockRequest, output, completion) {
+		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
+		});
+		return this.buildResponse(request, {
+			output,
+			replay,
+			stopReason: completion.stopReason ?? resolveStopReason(output),
+			usage: completion.usage,
+			billing: completion.billing,
+			auxiliary: completion.auxiliary,
+			providerMetadata: {
+				turnIndex: mockRequest.turnIndex,
+				turnName: mockRequest.turnName,
+				scriptedSteps: mockRequest.turn.steps.length,
+				pendingToolCallIds: this.pendingToolCalls.map((item) => item.id),
+				historyLength: this.history.length,
+				...this.providerMetadata,
+				...completion.providerMetadata
+			},
+			warnings: completion.warnings,
+			metadataSources: ["mock"],
+			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) {
+		return {
+			turnIndex,
+			previousReplay: this.previousReplay.map(cloneItem),
+			pendingToolCalls: this.pendingToolCalls.map(cloneItem),
+			history: this.history.map((record) => ({
+				...record,
+				replay: record.replay.map(cloneItem),
+				toolCalls: record.toolCalls.map(cloneItem)
+			}))
+		};
+	}
+};
+function createMessageFromStep(step, request, turnIndex, stepIndex) {
+	return {
+		...messageItem(normalizeBlocks(step.content), { id: step.id ?? `mock-msg-${request.requestId}-${turnIndex}-${stepIndex}` }),
+		role: "assistant"
+	};
+}
+function createReasoningFromStep(step, request, turnIndex, stepIndex) {
+	return reasoningItem(normalizeBlocks(step.content), step.visibility ?? "full", step.id ?? `mock-reason-${request.requestId}-${turnIndex}-${stepIndex}`);
+}
+function createToolCallFromStep(step) {
+	return {
+		type: "tool_call",
+		id: step.id,
+		name: step.name,
+		argumentsText: step.argumentsText,
+		argumentsJson: step.argumentsJson
+	};
+}
+function normalizeBlocks(content) {
+	return typeof content === "string" ? [textBlock(content)] : content;
+}
+function assertSupportedOutputItem(item) {
+	if (item.type === "opaque") throw new AIRequestError("MockAdapter does not stream opaque output items; use complete.replay if needed", "MOCK_OPAQUE_OUTPUT");
+}
+function attachSyntheticId(item, request, turnIndex, stepIndex) {
+	if (item.type === "message") return {
+		...item,
+		id: item.id ?? `mock-msg-${request.requestId}-${turnIndex}-${stepIndex}`,
+		role: "assistant"
+	};
+	if (item.type === "reasoning") return {
+		...item,
+		id: item.id ?? `mock-reason-${request.requestId}-${turnIndex}-${stepIndex}`
+	};
+	return item;
+}
+async function* emitOutputItem(factory, item, stream) {
+	if (item.type === "message") {
+		yield* emitMessage(factory, item, stream);
+		return;
+	}
+	if (item.type === "reasoning") {
+		yield* emitReasoning(factory, item, stream);
+		return;
+	}
+	yield* emitToolCall(factory, item, true, stream);
+}
+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);
+	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, 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);
+	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, stream) {
+	yield factory.toolCallStarted(item.id, item.name);
+	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";
+}
+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;
+	for (const replayItem of replay) {
+		const target = fingerprintItem(replayItem);
+		const foundIndex = fingerprints.indexOf(target, cursor);
+		if (foundIndex === -1) throw new AIRequestError(`${prefix}: previous replay item was not carried into the next request`, "MOCK_EXPECTATION_FAILED");
+		cursor = foundIndex + 1;
+	}
+}
+function assertOrderedItems(input, expectations, prefix) {
+	let cursor = 0;
+	for (const expected of expectations) {
+		let matched = false;
+		while (cursor < input.length) {
+			const item = input[cursor];
+			if (item !== void 0 && matchesItemExpectation(item, expected)) {
+				matched = true;
+				cursor += 1;
+				break;
+			}
+			cursor += 1;
+		}
+		if (!matched) throw new AIRequestError(`${prefix}: missing ordered input item ${describeExpectation(expected)}`, "MOCK_EXPECTATION_FAILED");
+	}
+}
+function assertUnorderedItems(input, expectations, prefix) {
+	for (const expected of expectations) if (!input.some((item) => matchesItemExpectation(item, expected))) throw new AIRequestError(`${prefix}: missing input item ${describeExpectation(expected)}`, "MOCK_EXPECTATION_FAILED");
+}
+function matchesItemExpectation(item, expected) {
+	if (item.type !== expected.type) return false;
+	if (expected.id !== void 0 && "id" in item && item.id !== expected.id) return false;
+	switch (item.type) {
+		case "message": return (expected.role === void 0 || item.role === expected.role) && matchesText(item.content, expected.textIncludes);
+		case "reasoning": return (expected.visibility === void 0 || item.visibility === expected.visibility) && matchesText(item.content, expected.textIncludes);
+		case "tool_call": return (expected.name === void 0 || item.name === expected.name) && (expected.textIncludes === void 0 || item.argumentsText.includes(expected.textIncludes));
+		case "tool_result": return (expected.toolName === void 0 || item.toolName === expected.toolName) && (expected.callId === void 0 || item.callId === expected.callId) && (expected.outcome === void 0 || item.outcome === expected.outcome) && matchesText(item.content, expected.textIncludes);
+		case "opaque": return (expected.source === void 0 || item.source === expected.source) && (expected.purpose === void 0 || item.purpose === expected.purpose);
+	}
+}
+function matchesText(blocks, textIncludes) {
+	if (textIncludes === void 0) return true;
+	return blocks.some((block) => {
+		if (block.type === "text") return block.text.includes(textIncludes);
+		if (block.type === "json") return JSON.stringify(block.json).includes(textIncludes);
+		return false;
+	});
+}
+function fingerprintItem(item) {
+	return JSON.stringify(item);
+}
+function describeExpectation(expectation) {
+	const parts = [`type=${expectation.type}`];
+	if (expectation.role) parts.push(`role=${expectation.role}`);
+	if (expectation.name) parts.push(`name=${expectation.name}`);
+	if (expectation.toolName) parts.push(`toolName=${expectation.toolName}`);
+	if (expectation.callId) parts.push(`callId=${expectation.callId}`);
+	if (expectation.textIncludes) parts.push(`textIncludes=${JSON.stringify(expectation.textIncludes)}`);
+	return `{ ${parts.join(", ")} }`;
+}
+function cloneItem(item) {
+	return structuredClone(item);
+}
+//#endregion
 //#region src/helpers/synthetic-stream.ts
 /**
 * 模拟流式 (Synthetic Streaming)
@@ -2753,6 +2993,6 @@ function* emitToolCallEvents(item, factory) {
 	yield factory.toolCallCompleted(item);
 }
 //#endregion
-export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, CAPABILITY_MATRIX, ChatCompletionsAdapter, MessagesAdapter, 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, 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 };
 
 //# sourceMappingURL=index.mjs.map