@codehz/ai 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -11,8 +11,10 @@ var AIError = class extends Error {
 };
 /** 请求构造失败 — 参数校验不通过。在进入 adapter 前同步抛错。 */
 var AIRequestError = class extends AIError {
-	constructor(message, code) {
+	issues;
+	constructor(message, code, issues) {
 		super(message, code, "AIRequestError");
+		this.issues = issues;
 	}
 };
 /** Provider 调用失败 — HTTP 非 2xx、网络错误。由 AdapterBase 捕获转为 warning。 */
@@ -59,7 +61,9 @@ const WarningCode = {
 	/** 能力降级 */
 	CAPABILITY_DOWNGRADE: "CAPABILITY_DOWNGRADE",
 	/** 模拟流式 */
-	SYNTHETIC_STREAM: "SYNTHETIC_STREAM"
+	SYNTHETIC_STREAM: "SYNTHETIC_STREAM",
+	/** 工具调用以批量方式到达（非 token 级流式） */
+	TOOL_CALL_BATCHED: "TOOL_CALL_BATCHED"
 };
 //#endregion
 //#region src/core/validation.ts
@@ -194,6 +198,16 @@ function validateToolChoice(toolChoice, issues) {
 	if (toolChoice === "auto" || toolChoice === "none") return;
 	if (!isRecord(toolChoice) || toolChoice.type !== "tool" || typeof toolChoice.name !== "string" || toolChoice.name.length === 0) pushIssue(issues, "toolChoice", "TOOL_CHOICE_INVALID", "toolChoice must be auto, none, or { type: \"tool\", name }");
 }
+/** Validate include settings, appending issues to the given array. */
+function validateInclude(include, issues) {
+	if (!isRecord(include)) {
+		pushIssue(issues, "include", "INCLUDE_INVALID", "include must be an object");
+		return;
+	}
+	if (include.usage !== void 0 && (typeof include.usage !== "string" || !INCLUDE_MODES.has(include.usage))) pushIssue(issues, "include.usage", "INCLUDE_USAGE_INVALID", "include.usage must be off or best_effort");
+	if (include.billing !== void 0 && (typeof include.billing !== "string" || !INCLUDE_MODES.has(include.billing))) pushIssue(issues, "include.billing", "INCLUDE_BILLING_INVALID", "include.billing must be off or best_effort");
+	if (include.providerMetadata !== void 0 && (typeof include.providerMetadata !== "string" || !INCLUDE_MODES.has(include.providerMetadata))) pushIssue(issues, "include.providerMetadata", "INCLUDE_PROVIDER_METADATA_INVALID", "include.providerMetadata must be off or best_effort");
+}
 /**
 * 校验 AIRequest，返回校验问题列表。
 * 空数组表示无问题。
@@ -205,7 +219,7 @@ function validateRequest(request) {
 	if (!Array.isArray(request.input) || request.input.length === 0) pushIssue(issues, "input", "INPUT_EMPTY", "input must be a non-empty array");
 	if (Array.isArray(request.input)) for (let i = 0; i < request.input.length; i++) validateInputItem(request.input[i], `input[${i}]`, issues);
 	if (request.temperature !== void 0) {
-		if (typeof request.temperature !== "number" || isNaN(request.temperature)) issues.push({
+		if (typeof request.temperature !== "number" || !Number.isFinite(request.temperature)) issues.push({
 			field: "temperature",
 			code: "TEMPERATURE_NOT_NUMBER",
 			message: "temperature must be a number"
@@ -217,7 +231,7 @@ function validateRequest(request) {
 		});
 	}
 	if (request.maxOutputTokens !== void 0) {
-		if (typeof request.maxOutputTokens !== "number" || isNaN(request.maxOutputTokens)) issues.push({
+		if (typeof request.maxOutputTokens !== "number" || !Number.isFinite(request.maxOutputTokens)) issues.push({
 			field: "maxOutputTokens",
 			code: "MAX_OUTPUT_TOKENS_NOT_NUMBER",
 			message: "maxOutputTokens must be a number"
@@ -228,12 +242,7 @@ function validateRequest(request) {
 			message: "maxOutputTokens must be a positive integer"
 		});
 	}
-	if (request.include !== void 0) if (!isRecord(request.include)) pushIssue(issues, "include", "INCLUDE_INVALID", "include must be an object");
-	else {
-		if (request.include.usage !== void 0 && !INCLUDE_MODES.has(request.include.usage)) pushIssue(issues, "include.usage", "INCLUDE_USAGE_INVALID", "include.usage must be off or best_effort");
-		if (request.include.billing !== void 0 && !INCLUDE_MODES.has(request.include.billing)) pushIssue(issues, "include.billing", "INCLUDE_BILLING_INVALID", "include.billing must be off or best_effort");
-		if (request.include.providerMetadata !== void 0 && !INCLUDE_MODES.has(request.include.providerMetadata)) pushIssue(issues, "include.providerMetadata", "INCLUDE_PROVIDER_METADATA_INVALID", "include.providerMetadata must be off or best_effort");
-	}
+	if (request.include !== void 0) validateInclude(request.include, issues);
 	if (request.metadata !== void 0) {
 		if (!isRecord(request.metadata)) pushIssue(issues, "metadata", "METADATA_INVALID", "metadata must be an object");
 		else for (const [key, value] of Object.entries(request.metadata)) if (typeof value !== "string") pushIssue(issues, `metadata.${key}`, "METADATA_VALUE_INVALID", `metadata.${key} must be a string`);
@@ -260,8 +269,9 @@ function validateRequest(request) {
 * 适用于客户端入口的快速失败检查。
 */
 function assertValidRequest(request) {
-	const first = validateRequest(request)[0];
-	if (first) throw new AIRequestError(first.message, first.code);
+	const issues = validateRequest(request);
+	const first = issues[0];
+	if (first) throw new AIRequestError(first.message, first.code, issues);
 }
 //#endregion
 //#region src/core/normalize.ts
@@ -279,6 +289,11 @@ const DEFAULT_INCLUDE = {
 */
 function normalizeRequest(request, options) {
 	const { model, defaults } = options;
+	const earlyIncludeIssues = [];
+	if (request.include !== void 0) validateInclude(request.include, earlyIncludeIssues);
+	if (defaults?.include !== void 0) validateInclude(defaults.include, earlyIncludeIssues);
+	const firstIncludeIssue = earlyIncludeIssues[0];
+	if (firstIncludeIssue) throw new AIRequestError(firstIncludeIssue.message, firstIncludeIssue.code, earlyIncludeIssues);
 	const merged = {
 		...defaults,
 		...request,
@@ -350,11 +365,11 @@ function createEventFactory(state) {
 				...data
 			};
 		},
-		responseCompleted(response) {
+		responseCompleted(completion) {
 			return {
 				...base(),
 				type: "response.completed",
-				response
+				...completion
 			};
 		},
 		messageStarted(id) {
@@ -367,22 +382,19 @@ function createEventFactory(state) {
 				}
 			};
 		},
-		messageDelta(itemId, text) {
+		messageDelta(itemId, delta) {
 			return {
 				...base(),
 				type: "message.delta",
 				itemId,
-				delta: {
-					type: "text",
-					text
-				}
+				delta
 			};
 		},
-		messageCompleted(item) {
+		messageCompleted(itemId) {
 			return {
 				...base(),
 				type: "message.completed",
-				item
+				itemId
 			};
 		},
 		reasoningStarted(id, visibility) {
@@ -403,11 +415,11 @@ function createEventFactory(state) {
 				delta
 			};
 		},
-		reasoningCompleted(item) {
+		reasoningCompleted(itemId) {
 			return {
 				...base(),
 				type: "reasoning.completed",
-				item
+				itemId
 			};
 		},
 		toolCallStarted(id, name) {
@@ -428,11 +440,11 @@ function createEventFactory(state) {
 				delta
 			};
 		},
-		toolCallCompleted(item) {
+		toolCallCompleted(itemId) {
 			return {
 				...base(),
 				type: "tool_call.completed",
-				item
+				itemId
 			};
 		},
 		/** 返回当前已发出的 sequence 计数（用于断言） */
@@ -446,6 +458,20 @@ function createEventFactory(state) {
 	};
 }
 //#endregion
+//#region src/core/merge-auxiliary.ts
+function mergeAuxiliary(base, patch) {
+	if (!base && !patch) return void 0;
+	const merged = {
+		...base,
+		...patch
+	};
+	if (base?.providerMetadata || patch?.providerMetadata) merged.providerMetadata = {
+		...base?.providerMetadata,
+		...patch?.providerMetadata
+	};
+	return merged;
+}
+//#endregion
 //#region src/core/aggregator.ts
 function createAggregatorState() {
 	return {
@@ -454,10 +480,45 @@ function createAggregatorState() {
 		warningSet: /* @__PURE__ */ new Set(),
 		output: [],
 		textParts: [],
-		toolCalls: []
+		toolCalls: [],
+		started: false,
+		completed: false,
+		activeItems: /* @__PURE__ */ new Map()
+	};
+}
+function getActiveItem(state, itemId, expectedType) {
+	const item = state.activeItems.get(itemId);
+	if (!item) throw streamProtocolError(`Received ${expectedType} delta/completed for unknown item: ${itemId}`);
+	if (item.type !== expectedType) throw streamProtocolError(`Item ${itemId} started as ${item.type} but received ${expectedType} event`);
+	return item;
+}
+function finalizeMessage(active) {
+	return {
+		type: "message",
+		id: active.id,
+		role: active.role,
+		content: active.content
+	};
+}
+function finalizeReasoning(active) {
+	return {
+		type: "reasoning",
+		id: active.id,
+		visibility: active.visibility,
+		content: active.content
+	};
+}
+function finalizeToolCall(active) {
+	return {
+		type: "tool_call",
+		id: active.id,
+		name: active.name,
+		argumentsText: active.argumentsText
 	};
 }
 function handleResponseStarted(state, event) {
+	if (state.started) throw streamProtocolError("Stream must contain exactly one response.started event");
+	state.started = true;
 	state.responseId = event.responseId;
 	state.model = event.model;
 	state.backendInfo = event.backend;
@@ -474,47 +535,97 @@ function handleResponseAuxiliary(state, event) {
 		...state.billing,
 		...event.billing
 	};
-	if (event.auxiliary) state.auxiliary = mergeAuxiliary$1(state.auxiliary, event.auxiliary);
+	if (event.auxiliary) state.auxiliary = mergeAuxiliary(state.auxiliary, event.auxiliary) ?? {};
+}
+function handleMessageStarted(state, event) {
+	const id = event.item.id;
+	if (state.activeItems.has(id)) throw streamProtocolError(`Item with id ${id} is already active`);
+	state.activeItems.set(id, {
+		type: "message",
+		id,
+		role: event.item.role,
+		content: []
+	});
+}
+function handleMessageDelta(state, event) {
+	getActiveItem(state, event.itemId, "message").content.push(event.delta);
 }
 function handleMessageCompleted(state, event) {
-	state.output.push(event.item);
-	pushMessageText(state, event.item);
+	const active = getActiveItem(state, event.itemId, "message");
+	state.activeItems.delete(event.itemId);
+	const item = finalizeMessage(active);
+	state.output.push(item);
+	pushMessageText(state, item);
+}
+function handleReasoningStarted(state, event) {
+	const id = event.item.id;
+	if (state.activeItems.has(id)) throw streamProtocolError(`Item with id ${id} is already active`);
+	state.activeItems.set(id, {
+		type: "reasoning",
+		id,
+		visibility: event.item.visibility,
+		content: []
+	});
+}
+function handleReasoningDelta(state, event) {
+	getActiveItem(state, event.itemId, "reasoning").content.push(event.delta);
 }
 function handleReasoningCompleted(state, event) {
-	state.output.push(event.item);
+	const active = getActiveItem(state, event.itemId, "reasoning");
+	state.activeItems.delete(event.itemId);
+	state.output.push(finalizeReasoning(active));
+}
+function handleToolCallStarted(state, event) {
+	const id = event.item.id;
+	if (state.activeItems.has(id)) throw streamProtocolError(`Item with id ${id} is already active`);
+	state.activeItems.set(id, {
+		type: "tool_call",
+		id,
+		name: event.item.name,
+		argumentsText: ""
+	});
+}
+function handleToolCallDelta(state, event) {
+	const active = getActiveItem(state, event.itemId, "tool_call");
+	if (event.delta.argumentsText) active.argumentsText += event.delta.argumentsText;
 }
 function handleToolCallCompleted(state, event) {
-	state.output.push(event.item);
-	state.toolCalls.push(event.item);
+	const active = getActiveItem(state, event.itemId, "tool_call");
+	state.activeItems.delete(event.itemId);
+	const item = finalizeToolCall(active);
+	state.output.push(item);
+	state.toolCalls.push(item);
 }
 function handleResponseCompleted(state, event) {
-	state.replayFromAdapter = event.response.replay;
-	state.responseIdFromAdapter = event.response.id;
-	state.stopReasonFromAdapter = event.response.stopReason;
-	state.backendFromAdapter = event.response.backend;
-	if (event.response.usage) state.usage = {
+	if (state.activeItems.size > 0) throw streamProtocolError("response.completed received while active items still pending");
+	state.completed = true;
+	state.replayFromAdapter = event.replay;
+	state.stopReasonFromAdapter = event.stopReason;
+	state.backendFromAdapter = event.trace;
+	if (event.usage) state.usage = {
 		...state.usage,
-		...event.response.usage
+		...event.usage
 	};
-	if (event.response.billing) state.billing = {
+	if (event.billing) state.billing = {
 		...state.billing,
-		...event.response.billing
+		...event.billing
 	};
-	if (event.response.auxiliary) state.auxiliary = mergeAuxiliary$1(state.auxiliary, event.response.auxiliary);
-	if (event.response.warnings) pushWarnings(state, event.response.warnings);
+	if (event.auxiliary) state.auxiliary = mergeAuxiliary(state.auxiliary, event.auxiliary) ?? {};
+	if (event.warnings) pushWarnings(state, event.warnings);
+	if (event.opaqueOutput) state.output.push(...event.opaqueOutput);
 }
 function buildResponse(state) {
-	const backendFromResponse = state.backendFromAdapter;
+	const backendFromCompleted = state.backendFromAdapter;
 	const backend = {
-		adapter: backendFromResponse?.adapter ?? state.backendInfo?.kind ?? "unknown",
-		isSyntheticStream: backendFromResponse?.isSyntheticStream ?? state.backendInfo?.isSynthetic ?? false,
-		requestId: backendFromResponse?.requestId ?? state.responseId,
-		rawResponseId: backendFromResponse?.rawResponseId,
-		metadataSources: backendFromResponse?.metadataSources,
-		warnings: backendFromResponse?.warnings
+		adapter: backendFromCompleted?.adapter ?? state.backendInfo?.kind ?? "unknown",
+		isSyntheticStream: backendFromCompleted?.isSyntheticStream ?? state.backendInfo?.isSynthetic ?? false,
+		requestId: backendFromCompleted?.requestId ?? state.responseId,
+		rawResponseId: backendFromCompleted?.rawResponseId,
+		metadataSources: backendFromCompleted?.metadataSources,
+		warnings: backendFromCompleted?.warnings
 	};
 	return {
-		id: state.responseIdFromAdapter ?? state.responseId,
+		id: state.responseId,
 		output: state.output,
 		replay: state.replayFromAdapter ?? [],
 		text: state.textParts.join(""),
@@ -537,6 +648,7 @@ function aggregateEvents(events) {
 	return finalizeAggregation(state);
 }
 function aggregateEvent(state, event) {
+	validateEventEnvelope(state, event);
 	state.lastEventType = event.type;
 	switch (event.type) {
 		case "response.started":
@@ -549,17 +661,29 @@ function aggregateEvent(state, event) {
 			handleResponseAuxiliary(state, event);
 			break;
 		case "message.started":
+			handleMessageStarted(state, event);
+			break;
 		case "message.delta":
-		case "reasoning.started":
-		case "reasoning.delta":
-		case "tool_call.started":
-		case "tool_call.delta": break;
+			handleMessageDelta(state, event);
+			break;
 		case "message.completed":
 			handleMessageCompleted(state, event);
 			break;
+		case "reasoning.started":
+			handleReasoningStarted(state, event);
+			break;
+		case "reasoning.delta":
+			handleReasoningDelta(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;
@@ -569,20 +693,10 @@ function aggregateEvent(state, event) {
 	}
 }
 function finalizeAggregation(state) {
-	if (state.lastEventType !== "response.completed") throw new Error("Stream must end with response.completed event to produce a valid AIResponse");
+	if (!state.started) throw streamProtocolError("Stream must start with response.started event");
+	if (!state.completed || state.lastEventType !== "response.completed") throw streamProtocolError("Stream must end with response.completed event to produce a valid AIResponse");
 	return buildResponse(state);
 }
-function mergeAuxiliary$1(base, patch) {
-	const merged = {
-		...base,
-		...patch
-	};
-	if (base.providerMetadata || patch.providerMetadata) merged.providerMetadata = {
-		...base.providerMetadata,
-		...patch.providerMetadata
-	};
-	return merged;
-}
 function pushWarnings(state, warnings) {
 	for (const warning of warnings) if (!state.warningSet.has(warning)) {
 		state.warningSet.add(warning);
@@ -592,6 +706,16 @@ function pushWarnings(state, warnings) {
 function pushMessageText(state, item) {
 	for (const block of item.content) if (block.type === "text") state.textParts.push(block.text);
 }
+function validateEventEnvelope(state, event) {
+	if (state.completed) throw streamProtocolError("response.completed must be the final stream event");
+	if (!state.started && event.type !== "response.started") throw streamProtocolError("Stream must start with response.started event");
+	if (state.responseId !== void 0 && event.responseId !== state.responseId) throw streamProtocolError("All stream events must use the same responseId");
+	if (state.nextSequence !== void 0 && event.sequence !== state.nextSequence) throw streamProtocolError(`Expected event sequence ${state.nextSequence}, received ${event.sequence}`);
+	state.nextSequence = event.sequence + 1;
+}
+function streamProtocolError(message) {
+	return new AIStreamError(message, "STREAM_PROTOCOL_ERROR");
+}
 //#endregion
 //#region src/core/collect-stream.ts
 async function collectStream(stream) {
@@ -937,7 +1061,7 @@ var AdapterBase = class {
 			responseId: request.requestId,
 			backend: {
 				kind: this.kind,
-				isSynthetic: !this.nativeStreaming
+				isSynthetic: this.capabilities.textStreaming === "synthetic"
 			}
 		});
 		yield factory.responseStarted(request.model);
@@ -945,12 +1069,25 @@ var AdapterBase = class {
 			const providerRequest = await this.buildRequest(request);
 			yield* this.runStream(providerRequest, factory, request);
 		} catch (err) {
-			if (err instanceof AIRequestError || err instanceof AIStreamError || err instanceof AIMappingError) throw err;
-			yield factory.responseWarning(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
-			yield factory.responseCompleted(this.buildResponse(request, {
-				output: [],
-				replay: []
-			}, factory));
+			if (err instanceof AIRequestError || err instanceof AIProviderError || err instanceof AIStreamError) throw err;
+			if (err instanceof AIMappingError) {
+				yield factory.responseWarning(err.message, "MAPPING_ERROR");
+				const errorResp = this.buildResponse(request, {
+					output: [],
+					replay: []
+				}, factory);
+				yield factory.responseCompleted({
+					replay: errorResp.replay,
+					stopReason: errorResp.stopReason,
+					trace: errorResp.backend,
+					usage: errorResp.usage,
+					billing: errorResp.billing,
+					auxiliary: errorResp.auxiliary,
+					warnings: errorResp.warnings
+				});
+				return;
+			}
+			throw err;
 		}
 	}
 	/**
@@ -976,7 +1113,7 @@ var AdapterBase = class {
 				requestId: request.requestId,
 				rawResponseId: result.rawResponseId,
 				adapter: this.kind,
-				isSyntheticStream: !this.nativeStreaming,
+				isSyntheticStream: this.capabilities.textStreaming === "synthetic",
 				metadataSources: result.metadataSources,
 				warnings
 			}
@@ -990,18 +1127,6 @@ var AdapterBase = class {
 		return new AdapterAuxiliaryState(request);
 	}
 };
-function mergeAuxiliary(base, patch) {
-	if (!base && !patch) return void 0;
-	const merged = {
-		...base,
-		...patch
-	};
-	if (base?.providerMetadata || patch?.providerMetadata) merged.providerMetadata = {
-		...base?.providerMetadata,
-		...patch?.providerMetadata
-	};
-	return merged;
-}
 function mergeWarnings(...groups) {
 	const merged = [];
 	for (const group of groups) {
@@ -1011,6 +1136,91 @@ function mergeWarnings(...groups) {
 	return merged.length > 0 ? merged : void 0;
 }
 //#endregion
+//#region src/helpers/adapter-security.ts
+/**
+* Adapter 边界安全辅助
+*
+* - opaque replay 入站 envelope（大小 / 深度）
+* - provider HTTP 错误 body 出站脱敏
+*/
+const MAX_OPAQUE_PAYLOAD_BYTES = 65536;
+const MAX_OPAQUE_JSON_DEPTH = 8;
+const PROVIDER_ERROR_MESSAGE_MAX_LEN = 500;
+const PROVIDER_ERROR_RAW_BODY_THRESHOLD = 200;
+/** 测量 JSON 值嵌套深度（对象/数组）；循环引用按已访问节点深度计。 */
+function measureJsonDepth(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return 0;
+	if (seen.has(value)) return 0;
+	seen.add(value);
+	let maxChild = 0;
+	if (Array.isArray(value)) for (const item of value) maxChild = Math.max(maxChild, measureJsonDepth(item, seen));
+	else for (const key of Object.keys(value)) maxChild = Math.max(maxChild, measureJsonDepth(value[key], seen));
+	return 1 + maxChild;
+}
+/**
+* Opaque replay 通用 envelope：必须是 object、体积 ≤ 64KB、深度 ≤ 8。
+* 不校验 adapter 专用字段形状。
+*/
+function validateOpaqueReplayEnvelope(payload) {
+	if (typeof payload !== "object" || payload === null) return {
+		ok: false,
+		reason: "payload must be an object"
+	};
+	let raw;
+	try {
+		raw = JSON.stringify(payload);
+	} catch {
+		return {
+			ok: false,
+			reason: "payload is not JSON-serializable"
+		};
+	}
+	if (raw === void 0) return {
+		ok: false,
+		reason: "payload is not JSON-serializable"
+	};
+	if (raw.length > 65536) return {
+		ok: false,
+		reason: `opaque payload exceeds max size (${raw.length} > ${MAX_OPAQUE_PAYLOAD_BYTES})`
+	};
+	const depth = measureJsonDepth(payload);
+	if (depth > 8) return {
+		ok: false,
+		reason: `opaque payload nesting depth (${depth}) exceeds max (8)`
+	};
+	return { ok: true };
+}
+/** envelope 失败时抛 AIRequestError。 */
+function assertOpaqueReplayEnvelope(payload) {
+	const result = validateOpaqueReplayEnvelope(payload);
+	if (!result.ok) throw new AIRequestError(`Invalid opaque replay payload: ${result.reason}`, "INVALID_OPAQUE_REPLAY");
+}
+/**
+* 从 provider HTTP 错误 body 提取可对外暴露的短消息，避免泄漏 HTML / 内部路径等。
+*/
+function extractProviderErrorMessage(body, status) {
+	if (!body) return `HTTP ${status}`;
+	try {
+		const parsed = JSON.parse(body);
+		if (parsed && typeof parsed === "object") {
+			const record = parsed;
+			const errorField = record.error;
+			let msg;
+			if (errorField && typeof errorField === "object" && errorField !== null) msg = errorField.message;
+			if (typeof msg !== "string") msg = typeof errorField === "string" ? errorField : record.message;
+			if (typeof msg === "string" && msg.length > 0) return msg.slice(0, 500);
+		}
+	} catch {}
+	const trimmed = body.trimStart();
+	if (trimmed.startsWith("<!") || trimmed.startsWith("<html") || body.length > 200) return `HTTP ${status}. Body omitted (${body.length} bytes)`;
+	return body.slice(0, 500);
+}
+/** 统一构造脱敏后的 AIProviderError。 */
+function providerHttpError(status, body) {
+	const safe = extractProviderErrorMessage(body, status);
+	return new AIProviderError(`Provider returned ${status}: ${safe}`, "PROVIDER_ERROR", status, safe);
+}
+//#endregion
 //#region src/helpers/usage-mapping.ts
 function num(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -1090,43 +1300,55 @@ function usageFromOllama(raw) {
 * - 未完成的行保留在 rest 中，等待下次 chunk 补全
 * - 支持跨 chunk 的 event 分片
 */
-function parseSSEEvents(chunk) {
+function parseSSEEvents(chunk, options = {}) {
 	const events = [];
 	let eventType = "";
 	let dataLines = [];
 	let consumedUntil = 0;
 	let cursor = 0;
 	let malformedEvents = 0;
+	const emitEvent = (consumedCursor) => {
+		const dataStr = dataLines.join("\n");
+		if (dataStr === "[DONE]") {
+			eventType = "";
+			dataLines = [];
+			consumedUntil = consumedCursor;
+			return;
+		}
+		try {
+			const data = JSON.parse(dataStr);
+			events.push({
+				type: eventType,
+				data
+			});
+		} catch {
+			malformedEvents++;
+		}
+		eventType = "";
+		dataLines = [];
+		consumedUntil = consumedCursor;
+	};
+	const consumeLine = (line, consumedCursor) => {
+		if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+		else if (line.startsWith("data: ")) dataLines.push(line.slice(6));
+		else if (line === "" && eventType && dataLines.length > 0) emitEvent(consumedCursor);
+		else if (line === "" && !eventType && dataLines.length === 0) consumedUntil = consumedCursor;
+	};
 	while (cursor < chunk.length) {
 		const lineEnd = chunk.indexOf("\n", cursor);
 		if (lineEnd === -1) break;
 		let line = chunk.slice(cursor, lineEnd);
 		cursor = lineEnd + 1;
 		if (line.endsWith("\r")) line = line.slice(0, -1);
-		if (line.startsWith("event: ")) eventType = line.slice(7).trim();
-		else if (line.startsWith("data: ")) dataLines.push(line.slice(6));
-		else if (line === "" && eventType && dataLines.length > 0) {
-			const dataStr = dataLines.join("\n");
-			if (dataStr === "[DONE]") {
-				eventType = "";
-				dataLines = [];
-				consumedUntil = cursor;
-				continue;
-			}
-			try {
-				const data = JSON.parse(dataStr);
-				events.push({
-					type: eventType,
-					data
-				});
-			} catch {
-				malformedEvents++;
-			}
-			eventType = "";
-			dataLines = [];
-			consumedUntil = cursor;
-		} else if (line === "" && !eventType && dataLines.length === 0) consumedUntil = cursor;
+		consumeLine(line, cursor);
+	}
+	if (options.allowEOF && cursor < chunk.length) {
+		let line = chunk.slice(cursor);
+		if (line.endsWith("\r")) line = line.slice(0, -1);
+		consumeLine(line, chunk.length);
+		cursor = chunk.length;
 	}
+	if (options.allowEOF && eventType && dataLines.length > 0) emitEvent(chunk.length);
 	return {
 		events,
 		rest: chunk.slice(consumedUntil),
@@ -1134,71 +1356,288 @@ function parseSSEEvents(chunk) {
 	};
 }
 //#endregion
-//#region src/adapters/responses.ts
+//#region src/helpers/synthetic-stream.ts
 /**
-* Responses Adapter
+* 模拟流式 (Synthetic Streaming)
 *
-* 接入 OpenAI Responses API (responses 端点)。
-* 职责分层：
-*   1. buildRequest — 将 NormalizedRequest 转换为 Responses API 请求
-*   2. runStream     — 调用 API、解析 SSE、发射 canonical 事件
+* 将一组已解析的 canonical OutputItem 包装为规范事件流。
+* 适用于非原生流式后端：adapter 拿到完整响应后，调用此函数
+* 即可产出一致的事件序列，无需自己逐事件组装。
 *
-* 支持消息流 / reasoning 流 / tool_call 流及高保真 replay。
+* 约束：
+* - 每个 item 只发一块完整 delta（不模拟逐 token）
+* - 保持 item 边界
+* - 保持后端原始顺序
+* - 不发明 reasoning
+* - 不改写工具参数
+*/
+/**
+* 将已解析的 output items 包装为完整规范事件流。
+*
+* 用法示例（在 adapter 的 runStream 中）：
+* ```ts
+* const result = parseNonStreamingResponse(data);
+* yield* syntheticStream({
+*   model: request.model,
+*   responseId: request.requestId,
+*   backend: { kind: "chat-completions" },
+*   output: result.output,
+*   stopReason: result.stopReason,
+*   usage: result.usage,
+* });
+* ```
 */
-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;
-}
-function ensureResponsesReasoningBlocks(blocks, field) {
-	return blocks.map((block, index) => {
-		if (block.type !== "text") throw new AIRequestError(`responses does not support ${field}[${index}] of type "${block.type}"; reasoning only supports text blocks`, "UNSUPPORTED_CONTENT_BLOCK");
-		return block;
+async function* syntheticStream(options) {
+	const { model, responseId, backend, output, replay, stopReason, usage, billing, providerMetadata, rawResponseId, warnings: extraWarnings } = options;
+	const factory = createEventFactory({
+		responseId,
+		backend: {
+			kind: backend.kind,
+			isSynthetic: true
+		}
+	});
+	yield factory.responseStarted(model);
+	for (const item of output) yield* emitItemEvents(item, factory);
+	if (usage || billing) yield factory.responseAuxiliary({
+		usage,
+		billing
+	});
+	const finalReplay = replay ?? replayFromOutput(output);
+	const allWarnings = [];
+	allWarnings.push("Response is synthetically streamed; delta granularity may differ from native streaming");
+	if (extraWarnings) allWarnings.push(...extraWarnings);
+	yield factory.responseCompleted({
+		replay: finalReplay,
+		stopReason,
+		usage,
+		billing,
+		auxiliary: providerMetadata ? { providerMetadata } : void 0,
+		opaqueOutput: output.filter((item) => item.type === "opaque"),
+		warnings: allWarnings.length > 0 ? allWarnings : void 0,
+		trace: {
+			requestId: responseId,
+			rawResponseId,
+			adapter: backend.kind,
+			isSyntheticStream: true,
+			warnings: allWarnings.length > 0 ? allWarnings : void 0
+		}
 	});
 }
-function instructionsToResponsesText(instructions) {
-	return typeof instructions === "string" ? instructions : contentBlocksToText(ensureResponsesTextBlocks(instructions, "instructions"));
+function* emitItemEvents(item, factory) {
+	switch (item.type) {
+		case "message":
+			yield* emitMessageEvents(item, factory);
+			break;
+		case "reasoning":
+			yield* emitReasoningEvents(item, factory);
+			break;
+		case "tool_call":
+			yield* emitToolCallEvents(item, factory);
+			break;
+		case "opaque": break;
+	}
 }
-function assertResponsesToolResultOutcome(outcome) {
-	if (outcome !== "success") throw new AIRequestError(`responses does not preserve tool_result outcome "${outcome}"; only "success" is supported`, "UNSUPPORTED_TOOL_RESULT_OUTCOME");
+function* emitMessageEvents(item, factory) {
+	const id = item.id ?? `syn-msg-${crypto.randomUUID()}`;
+	yield factory.messageStarted(id);
+	for (const block of item.content) yield factory.messageDelta(id, block);
+	yield factory.messageCompleted(id);
 }
-function parseSSE(chunk) {
-	const result = parseSSEEvents(chunk);
-	return {
-		events: result.events,
-		rest: result.rest,
-		malformedEvents: result.malformedEvents
-	};
+function* emitReasoningEvents(item, factory) {
+	const id = item.id ?? `syn-reason-${crypto.randomUUID()}`;
+	yield factory.reasoningStarted(id, item.visibility);
+	for (const block of item.content) yield factory.reasoningDelta(id, block);
+	yield factory.reasoningCompleted(id);
 }
-function isReplayCanonicalInput(item) {
-	return item.type === "message" && item.role === "assistant" || item.type === "reasoning" || item.type === "function_call";
+function* emitToolCallEvents(item, factory) {
+	yield factory.toolCallStarted(item.id, item.name);
+	if (item.argumentsText) yield factory.toolCallDelta(item.id, { argumentsText: item.argumentsText });
+	yield factory.toolCallCompleted(item.id);
 }
-function rollbackTrailingReplayCanonicalItems(input) {
-	while (input.length > 0) {
-		const last = input[input.length - 1];
-		if (!last || !isReplayCanonicalInput(last)) break;
-		input.pop();
+//#endregion
+//#region src/helpers/incremental-stream-parser.ts
+var IncrementalStreamParser = class {
+	split;
+	parse;
+	buffer = "";
+	decoder = new TextDecoder();
+	constructor(split, parse) {
+		this.split = split;
+		this.parse = parse;
+	}
+	feed(value) {
+		this.buffer += this.decoder.decode(value, { stream: true });
+		return this.consume(false);
+	}
+	flush() {
+		this.buffer += this.decoder.decode();
+		return this.consume(true);
+	}
+	getRemaining() {
+		return this.buffer;
+	}
+	consume(allowEOF) {
+		const split = this.split(this.buffer, allowEOF);
+		this.buffer = split.rest;
+		const items = [];
+		let malformed = 0;
+		for (const rawItem of split.items) {
+			const result = this.parse(rawItem);
+			if (result.status === "parsed") items.push(result.value);
+			else if (result.status === "malformed") malformed++;
+		}
+		return {
+			items,
+			malformed
+		};
 	}
-}
-function canonicalToResponsesBlock(b) {
-	if (b.type === "text") return {
-		type: "text",
-		text: b.text
+};
+function splitLines(buffer, allowEOF) {
+	const items = [];
+	let cursor = 0;
+	while (true) {
+		const lineEnd = buffer.indexOf("\n", cursor);
+		if (lineEnd === -1) break;
+		items.push(buffer.slice(cursor, lineEnd));
+		cursor = lineEnd + 1;
+	}
+	if (allowEOF && cursor < buffer.length) {
+		items.push(buffer.slice(cursor));
+		cursor = buffer.length;
+	}
+	return {
+		items,
+		rest: buffer.slice(cursor)
 	};
-	if (b.type === "json") return {
-		type: "text",
-		text: JSON.stringify(b.json)
+}
+function splitSSEFrames(buffer, allowEOF) {
+	const normalized = buffer.replaceAll("\r\n", "\n");
+	const items = [];
+	let cursor = 0;
+	while (true) {
+		const frameEnd = normalized.indexOf("\n\n", cursor);
+		if (frameEnd === -1) break;
+		items.push(normalized.slice(cursor, frameEnd));
+		cursor = frameEnd + 2;
+	}
+	if (allowEOF && cursor < normalized.length) {
+		items.push(normalized.slice(cursor));
+		cursor = normalized.length;
+	}
+	return {
+		items,
+		rest: normalized.slice(cursor)
 	};
-	throw new AIRequestError(`responses does not support content block type "${b.type}" in canonical mapping`, "UNSUPPORTED_CONTENT_BLOCK");
 }
-var ResponsesAdapter = class extends AdapterBase {
-	kind = "responses";
-	nativeStreaming = true;
-	apiKey;
-	baseUrl;
+//#endregion
+//#region src/helpers/request-mapper.ts
+var NormalizedRequestMapper = class {
+	profile;
+	constructor(profile) {
+		this.profile = profile;
+	}
+	mapInstructions(instructions) {
+		return typeof instructions === "string" ? instructions : contentBlocksToText(this.ensureTextBlocks(instructions, "instructions"));
+	}
+	ensureTextBlocks(blocks, field) {
+		return this.ensureBlocks(blocks, field, this.profile.supportedBlockTypes, "only text/json blocks are supported");
+	}
+	ensureReasoningBlocks(blocks, field) {
+		return this.ensureBlocks(blocks, field, this.profile.reasoningBlockTypes, "reasoning only supports text blocks");
+	}
+	assertToolResultOutcome(outcome) {
+		if (this.profile.capabilities.toolResultOutcomes.includes(outcome)) return;
+		const outcomes = this.profile.capabilities.toolResultOutcomes;
+		const supported = outcomes.map((value) => `"${value}"`).join(" and ");
+		const verb = outcomes.length > 1 ? "are" : "is";
+		throw new AIRequestError(`${this.profile.kind} does not preserve tool_result outcome "${outcome}"; only ${supported} ${verb} supported`, "UNSUPPORTED_TOOL_RESULT_OUTCOME");
+	}
+	rollbackTrailingAssistantMessages(messages) {
+		while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
+	}
+	ensureBlocks(blocks, field, supportedTypes, description) {
+		for (let i = 0; i < blocks.length; i++) {
+			const block = blocks[i];
+			if (block && !supportedTypes.includes(block.type)) throw new AIRequestError(`${this.profile.kind} does not support ${field}[${i}] of type "${block.type}"; ${description}`, "UNSUPPORTED_CONTENT_BLOCK");
+		}
+		return blocks;
+	}
+};
+//#endregion
+//#region src/adapters/responses.ts
+/**
+* Responses Adapter
+*
+* 接入 OpenAI Responses API (responses 端点)。
+* 职责分层：
+*   1. buildRequest — 将 NormalizedRequest 转换为 Responses API 请求
+*   2. runStream     — 调用 API、解析 SSE、发射 canonical 事件
+*
+* 支持消息流 / reasoning 流 / tool_call 流及高保真 replay。
+*/
+const profile$3 = {
+	kind: "responses",
+	instructionsMode: "instructions_field",
+	supportedBlockTypes: ["text", "json"],
+	reasoningBlockTypes: ["text"],
+	capabilities: {
+		textStreaming: "native",
+		reasoningStreaming: "native",
+		toolCallStreaming: "native",
+		replay: "opaque",
+		usage: "final",
+		toolResultOutcomes: ["success"]
+	}
+};
+const mapper$3 = new NormalizedRequestMapper(profile$3);
+/** 已处理或可安全忽略的 Responses SSE 类型（未知类型会 warning 一次）。 */
+const KNOWN_RESPONSES_SSE_TYPES = /* @__PURE__ */ new Set([
+	"response.output_item.added",
+	"response.output_item.done",
+	"response.output_text.delta",
+	"response.output_text.done",
+	"response.reasoning.delta",
+	"response.reasoning.done",
+	"response.tool_call.delta",
+	"response.tool_call.done",
+	"response.function_call_arguments.delta",
+	"response.function_call_arguments.done",
+	"response.content_part.added",
+	"response.content_part.done",
+	"response.refusal.delta",
+	"response.refusal.done",
+	"response.in_progress",
+	"response.created",
+	"response.completed",
+	"response.failed",
+	"response.incomplete",
+	"error"
+]);
+function isReplayCanonicalInput(item) {
+	return item.type === "message" && item.role === "assistant" || item.type === "reasoning" || item.type === "function_call";
+}
+function hasReplayCanonicalInput(input) {
+	return input.some(isReplayCanonicalInput);
+}
+function extractFailureMessage(response) {
+	return response.error?.message ?? response.failure?.message ?? "unknown";
+}
+function canonicalToResponsesBlock(b) {
+	if (b.type === "text") return {
+		type: "text",
+		text: b.text
+	};
+	if (b.type === "json") return {
+		type: "text",
+		text: JSON.stringify(b.json)
+	};
+	throw new AIRequestError(`responses does not support content block type "${b.type}" in canonical mapping`, "UNSUPPORTED_CONTENT_BLOCK");
+}
+var ResponsesAdapter = class extends AdapterBase {
+	kind = "responses";
+	capabilities = profile$3.capabilities;
+	apiKey;
+	baseUrl;
 	fetchFn;
 	constructor(options) {
 		super();
@@ -1211,7 +1650,7 @@ var ResponsesAdapter = class extends AdapterBase {
 		for (const item of request.input) switch (item.type) {
 			case "message":
 				if (item.role === "assistant") {
-					const blocks = ensureResponsesTextBlocks(item.content, `assistant message (${item.role}) content`).map(canonicalToResponsesBlock);
+					const blocks = mapper$3.ensureTextBlocks(item.content, `assistant message (${item.role}) content`).map(canonicalToResponsesBlock);
 					input.push({
 						type: "message",
 						role: item.role,
@@ -1220,11 +1659,11 @@ var ResponsesAdapter = class extends AdapterBase {
 				} else input.push({
 					type: "message",
 					role: item.role,
-					content: contentBlocksToText(ensureResponsesTextBlocks(item.content, `input message (${item.role}) content`))
+					content: contentBlocksToText(mapper$3.ensureTextBlocks(item.content, `input message (${item.role}) content`))
 				});
 				break;
 			case "reasoning": {
-				const blocks = ensureResponsesReasoningBlocks(item.content, "reasoning content").map((b) => ({
+				const blocks = mapper$3.ensureReasoningBlocks(item.content, "reasoning content").map((b) => ({
 					type: "reasoning",
 					text: b.text
 				}));
@@ -1243,8 +1682,8 @@ var ResponsesAdapter = class extends AdapterBase {
 				});
 				break;
 			case "tool_result": {
-				assertResponsesToolResultOutcome(item.outcome);
-				const output = ensureResponsesTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
+				mapper$3.assertToolResultOutcome(item.outcome);
+				const output = mapper$3.ensureTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
 				input.push({
 					type: "function_call_output",
 					call_id: item.callId,
@@ -1252,25 +1691,26 @@ var ResponsesAdapter = class extends AdapterBase {
 				});
 				break;
 			}
-			case "opaque":
-				if (item.source === "responses" && item.purpose === "replay" && typeof item.payload === "object" && item.payload !== null && "id" in item.payload) {
-					const { id } = item.payload;
-					if (typeof id === "string") {
-						rollbackTrailingReplayCanonicalItems(input);
-						input.push({
-							type: "item_reference",
-							id
-						});
-					}
+			case "opaque": {
+				if (item.source !== "responses" || item.purpose !== "replay") break;
+				assertOpaqueReplayEnvelope(item.payload);
+				const payload = item.payload;
+				if ("id" in payload) {
+					if (typeof payload.id !== "string" || payload.id.length === 0 || payload.id.length > 256) throw new AIRequestError("Invalid opaque replay payload: id must be a non-empty string (max 256)", "INVALID_OPAQUE_REPLAY");
+					if (!hasReplayCanonicalInput(input)) input.push({
+						type: "item_reference",
+						id: payload.id
+					});
 				}
 				break;
+			}
 		}
 		const body = {
 			model: request.model,
 			input,
 			stream: true
 		};
-		if (request.instructions) body.instructions = instructionsToResponsesText(request.instructions);
+		if (request.instructions) body.instructions = mapper$3.mapInstructions(request.instructions);
 		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
 			type: "function",
 			name: t.name,
@@ -1292,31 +1732,59 @@ var ResponsesAdapter = class extends AdapterBase {
 	}
 	async *runStream(providerRequest, factory, request) {
 		const auxiliary = this.createAuxiliaryState(request);
-		const response = await this.fetchFn(`${this.baseUrl}/responses`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.apiKey}`
-			},
-			body: JSON.stringify(providerRequest)
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${this.baseUrl}/responses`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body: JSON.stringify(providerRequest)
+			});
+		} catch (err) {
+			throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+		}
 		if (!response.ok) {
-			const errorText = await response.text().catch(() => "unknown error");
-			throw new Error(`Responses API error ${response.status}: ${errorText}`);
+			const errorBody = await response.text().catch(() => "");
+			throw providerHttpError(response.status, errorBody);
 		}
 		const reader = response.body?.getReader();
-		if (!reader) throw new Error("Response body is not readable");
+		if (!reader) throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
+		const parser = new IncrementalStreamParser(splitSSEFrames, (frame) => {
+			let eventType = "";
+			let dataStr = "";
+			for (const rawLine of frame.split("\n")) {
+				const line = rawLine.trim();
+				if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+				else if (line.startsWith("data: ")) dataStr += line.slice(6);
+			}
+			if (!eventType) return { status: "ignored" };
+			try {
+				const data = JSON.parse(dataStr);
+				return {
+					status: "parsed",
+					value: {
+						type: eventType,
+						data
+					}
+				};
+			} catch {
+				return { status: "malformed" };
+			}
+		});
 		const output = [];
-		const decoder = new TextDecoder();
-		let buffer = "";
+		let streamDone = false;
 		let completedResponse;
+		let completedEmitted = false;
+		let unknownEventsWarned = false;
+		const messageItemsWithDelta = /* @__PURE__ */ new Set();
 		try {
 			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				const { events, rest, malformedEvents } = parseSSE(buffer);
-				buffer = rest;
+				const { done, value } = await reader.read().catch((err) => {
+					throw new AIStreamError(`Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`, "STREAM_ERROR");
+				});
+				const { items: events, malformed: malformedEvents } = done ? parser.flush() : parser.feed(value);
 				const malformedWarning = emitMalformedStreamWarning(factory, {
 					count: malformedEvents,
 					providerLabel: "Responses",
@@ -1325,7 +1793,8 @@ var ResponsesAdapter = class extends AdapterBase {
 				if (malformedWarning) yield malformedWarning;
 				for (const sseEvent of events) {
 					if (sseEvent.type === "error") {
-						yield factory.responseWarning(sseEvent.data.message, sseEvent.data.code);
+						const data = sseEvent.data;
+						yield factory.responseWarning(data.message ?? "Provider error event", data.code);
 						continue;
 					}
 					if (sseEvent.type === "response.output_item.added") {
@@ -1344,40 +1813,69 @@ var ResponsesAdapter = class extends AdapterBase {
 						continue;
 					}
 					if (sseEvent.type === "response.output_text.delta") {
-						yield factory.messageDelta(sseEvent.data.item_id, sseEvent.data.delta);
+						const data = sseEvent.data;
+						yield factory.messageDelta(data.item_id, textBlock(data.delta));
+						messageItemsWithDelta.add(data.item_id);
 						continue;
 					}
 					if (sseEvent.type === "response.output_text.done") {
-						yield factory.messageCompleted(messageItem([textBlock(sseEvent.data.text)], { id: sseEvent.data.item_id }));
-						output.push(messageItem([textBlock(sseEvent.data.text)], { id: sseEvent.data.item_id }));
+						const data = sseEvent.data;
+						if (!messageItemsWithDelta.has(data.item_id) && data.text) yield factory.messageDelta(data.item_id, textBlock(data.text));
+						yield factory.messageCompleted(data.item_id);
+						output.push(messageItem([textBlock(data.text)], { id: data.item_id }));
 						continue;
 					}
 					if (sseEvent.type === "response.reasoning.delta") {
-						yield factory.reasoningDelta(sseEvent.data.item_id, textBlock(sseEvent.data.delta));
+						const data = sseEvent.data;
+						yield factory.reasoningDelta(data.item_id, textBlock(data.delta));
 						continue;
 					}
 					if (sseEvent.type === "response.reasoning.done") {
-						yield factory.reasoningCompleted(reasoningItem([textBlock(sseEvent.data.text)], "full", sseEvent.data.item_id));
-						output.push(reasoningItem([textBlock(sseEvent.data.text)], "full", sseEvent.data.item_id));
+						const data = sseEvent.data;
+						yield factory.reasoningCompleted(data.item_id);
+						output.push(reasoningItem([textBlock(data.text)], "full", data.item_id));
 						continue;
 					}
 					if (sseEvent.type === "response.tool_call.delta") {
-						if (sseEvent.data.delta.arguments) yield factory.toolCallDelta(sseEvent.data.item_id, { argumentsText: sseEvent.data.delta.arguments });
+						const data = sseEvent.data;
+						if (data.delta.arguments) yield factory.toolCallDelta(data.item_id, { argumentsText: data.delta.arguments });
 						continue;
 					}
 					if (sseEvent.type === "response.tool_call.done") {
-						const tcItem = toolCallItem(sseEvent.data.item_id, sseEvent.data.name ?? "unknown", sseEvent.data.arguments ?? "");
-						yield factory.toolCallCompleted(tcItem);
+						const data = sseEvent.data;
+						const tcItem = toolCallItem(data.item_id, data.name ?? "unknown", data.arguments ?? "");
+						yield factory.toolCallCompleted(data.item_id);
 						output.push(tcItem);
 						continue;
 					}
-					if (sseEvent.type === "response.completed") completedResponse = sseEvent.data.response;
+					if (sseEvent.type === "response.completed" || sseEvent.type === "response.failed" || sseEvent.type === "response.incomplete") {
+						const data = sseEvent.data;
+						if (completedResponse) {
+							yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+							continue;
+						}
+						completedResponse = data.response;
+						if (sseEvent.type === "response.failed") yield factory.responseWarning(`Response failed: ${extractFailureMessage(data.response)}`, "PROVIDER_FAILURE");
+						continue;
+					}
+					if (!KNOWN_RESPONSES_SSE_TYPES.has(sseEvent.type) && !unknownEventsWarned) {
+						unknownEventsWarned = true;
+						yield factory.responseWarning(`Responses API sent unknown event type "${sseEvent.type}"; this may indicate an incomplete integration`, "UNKNOWN_PROVIDER_EVENT");
+					}
+				}
+				if (done) {
+					streamDone = true;
+					break;
 				}
 			}
 		} finally {
-			reader.releaseLock();
+			try {
+				if (!streamDone) await reader.cancel().catch(() => void 0);
+			} finally {
+				reader.releaseLock();
+			}
 		}
-		if (buffer.trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Responses SSE frame", "STREAM_ERROR");
+		if (parser.getRemaining().trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Responses SSE frame", "STREAM_ERROR");
 		let rawResponseId;
 		if (completedResponse) {
 			rawResponseId = completedResponse.id;
@@ -1388,23 +1886,44 @@ var ResponsesAdapter = class extends AdapterBase {
 		const stopReason = completedResponse ? this.inferStopReason(completedResponse) : void 0;
 		const auxiliaryResult = await auxiliary.finalize(factory);
 		for (const event of auxiliaryResult.events) yield event;
-		yield factory.responseCompleted(this.buildResponse(request, {
-			output,
-			replay,
-			stopReason,
-			usage: auxiliaryResult.usage,
-			billing: auxiliaryResult.billing,
-			auxiliary: auxiliaryResult.auxiliary,
-			warnings: auxiliaryResult.warnings,
-			metadataSources: auxiliaryResult.metadataSources,
-			rawResponseId
-		}, factory));
+		if (!completedEmitted) {
+			completedEmitted = true;
+			const finalResponse = this.buildResponse(request, {
+				output,
+				replay,
+				stopReason,
+				usage: auxiliaryResult.usage,
+				billing: auxiliaryResult.billing,
+				auxiliary: auxiliaryResult.auxiliary,
+				warnings: auxiliaryResult.warnings,
+				metadataSources: auxiliaryResult.metadataSources,
+				rawResponseId
+			}, factory);
+			yield factory.responseCompleted({
+				replay: finalResponse.replay,
+				stopReason: finalResponse.stopReason,
+				trace: finalResponse.backend,
+				usage: finalResponse.usage,
+				billing: finalResponse.billing,
+				auxiliary: finalResponse.auxiliary,
+				warnings: finalResponse.warnings
+			});
+		}
 	}
 	inferStopReason(response) {
+		if (response.status === "failed") return "error";
+		if (response.status === "incomplete") {
+			const reason = response.incomplete_details?.reason;
+			if (reason === "content_filter") return "content_filter";
+			if (reason === "max_output_tokens") return "max_output_tokens";
+			return "max_output_tokens";
+		}
 		const output = response.output;
-		if (!output || output.length === 0) return "unknown";
+		if (!output || output.length === 0) return response.status === "completed" ? "end_turn" : "unknown";
 		if (output.some((item) => item.type === "function_call")) return "tool_call";
-		if (output[output.length - 1]?.status === "incomplete") return "max_output_tokens";
+		const lastItem = output[output.length - 1];
+		if (lastItem?.status === "failed") return "error";
+		if (lastItem?.status === "incomplete") return "max_output_tokens";
 		return "end_turn";
 	}
 };
@@ -1421,36 +1940,41 @@ var ResponsesAdapter = class extends AdapterBase {
 * - 高保真 replay（含 opaque continuation）
 * - 能力降级 warning
 */
-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;
-}
-function ensureMessagesReasoningBlocks(blocks, field) {
-	return blocks.map((block, index) => {
-		if (block.type !== "text") throw new AIRequestError(`messages does not support ${field}[${index}] of type "${block.type}"; reasoning only supports text blocks`, "UNSUPPORTED_CONTENT_BLOCK");
-		return block;
-	});
-}
-function instructionsToMessagesText(instructions) {
-	return typeof instructions === "string" ? instructions : contentBlocksToText(ensureMessagesTextBlocks(instructions, "instructions"));
-}
-function assertMessagesToolResultOutcome(outcome) {
-	if (outcome === "rejected") throw new AIRequestError("messages does not preserve tool_result outcome \"rejected\"; only \"success\" and \"error\" are supported", "UNSUPPORTED_TOOL_RESULT_OUTCOME");
-}
-function parseMessagesSSE(chunk) {
-	const result = parseSSEEvents(chunk);
-	return {
-		events: result.events,
-		rest: result.rest,
-		malformedEvents: result.malformedEvents
-	};
+const profile$2 = {
+	kind: "messages",
+	instructionsMode: "system_message",
+	supportedBlockTypes: ["text", "json"],
+	reasoningBlockTypes: ["text"],
+	capabilities: {
+		textStreaming: "native",
+		reasoningStreaming: "native",
+		toolCallStreaming: "synthetic",
+		replay: "opaque",
+		usage: "stream",
+		toolResultOutcomes: ["success", "error"]
+	}
+};
+const mapper$2 = new NormalizedRequestMapper(profile$2);
+function isMessagesReplayContentBlock(value) {
+	if (!value || typeof value !== "object" || !("type" in value)) return false;
+	const block = value;
+	switch (block.type) {
+		case "text": return typeof block.text === "string";
+		case "thinking": return typeof block.thinking === "string" && (block.signature === void 0 || typeof block.signature === "string");
+		case "redacted_thinking": return typeof block.data === "string";
+		case "tool_use": return typeof block.id === "string" && typeof block.name === "string" && !!block.input && typeof block.input === "object" && !Array.isArray(block.input);
+		case "tool_result":
+			if (typeof block.tool_use_id !== "string") return false;
+			if (block.is_error !== void 0 && typeof block.is_error !== "boolean") return false;
+			if (typeof block.content === "string") return true;
+			if (!Array.isArray(block.content)) return false;
+			return block.content.every(isMessagesReplayContentBlock);
+		default: return false;
+	}
 }
-function rollbackTrailingAssistantMessages$2(messages) {
-	while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
+function assertMessagesReplayContent(content) {
+	if (!Array.isArray(content)) throw new AIRequestError("Invalid opaque replay payload: content must be an array", "INVALID_OPAQUE_REPLAY");
+	for (let i = 0; i < content.length; i++) if (!isMessagesReplayContentBlock(content[i])) throw new AIRequestError(`Invalid opaque replay payload: content[${i}] is not a valid Messages content block`, "INVALID_OPAQUE_REPLAY");
 }
 /** 用 response 级别的命名空间合成 content block 的 item ID，避免多轮工具循环 ID 碰撞 */
 function synthesizeItemId(kind, blockIndex, responseId) {
@@ -1500,34 +2024,29 @@ function buildStreamMetadata(options) {
 }
 var MessagesAdapter = class extends AdapterBase {
 	kind = "messages";
-	nativeStreaming = true;
+	capabilities = profile$2.capabilities;
 	apiKey;
 	apiVersion;
 	baseUrl;
 	fetchFn;
-	warningAccumulator;
 	constructor(options) {
 		super();
 		this.apiKey = options.apiKey;
 		this.apiVersion = options.apiVersion ?? "2023-06-01";
 		this.baseUrl = options.baseUrl ?? "https://api.anthropic.com/v1";
 		this.fetchFn = options.fetch ?? globalThis.fetch;
-		this.warningAccumulator = [];
-	}
-	warn(message, _code) {
-		this.warningAccumulator.push(message);
 	}
 	buildRequest(request) {
 		const messages = [];
 		let systemPrompt;
 		let pendingToolResultMessage;
-		if (request.instructions) systemPrompt = instructionsToMessagesText(request.instructions);
+		if (request.instructions) systemPrompt = mapper$2.mapInstructions(request.instructions);
 		for (const item of request.input) {
 			if (item.type !== "tool_result") pendingToolResultMessage = void 0;
 			switch (item.type) {
 				case "message": {
 					const role = item.role === "user" ? "user" : "assistant";
-					const supportedContent = ensureMessagesTextBlocks(item.content, `input message (${item.role}) content`);
+					const supportedContent = mapper$2.ensureTextBlocks(item.content, `input message (${item.role}) content`);
 					if (supportedContent.length === 1 && supportedContent[0]?.type === "text") messages.push({
 						role,
 						content: supportedContent[0].text
@@ -1554,8 +2073,8 @@ var MessagesAdapter = class extends AdapterBase {
 					break;
 				}
 				case "tool_result": {
-					assertMessagesToolResultOutcome(item.outcome);
-					const content = ensureMessagesTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
+					mapper$2.assertToolResultOutcome(item.outcome);
+					const content = mapper$2.ensureTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
 					const block = {
 						type: "tool_result",
 						tool_use_id: item.callId,
@@ -1575,7 +2094,7 @@ var MessagesAdapter = class extends AdapterBase {
 				case "reasoning": {
 					const block = {
 						type: "thinking",
-						thinking: contentBlocksToText(ensureMessagesReasoningBlocks(item.content, "reasoning content"))
+						thinking: contentBlocksToText(mapper$2.ensureReasoningBlocks(item.content, "reasoning content"))
 					};
 					const lastMsg = messages[messages.length - 1];
 					if (lastMsg && lastMsg.role === "assistant" && typeof lastMsg.content !== "string") lastMsg.content.push(block);
@@ -1585,20 +2104,20 @@ var MessagesAdapter = class extends AdapterBase {
 					});
 					break;
 				}
-				case "opaque":
-					if (item.purpose === "replay" && typeof item.payload === "object" && item.payload !== null) {
-						const payload = item.payload;
-						if (payload.role === "assistant" && Array.isArray(payload.content)) {
-							if (payload.content.every((b) => typeof b === "object" && b !== null && "type" in b && (b.type === "text" || b.type === "thinking" || b.type === "redacted_thinking" || b.type === "tool_use" || b.type === "tool_result"))) {
-								rollbackTrailingAssistantMessages$2(messages);
-								messages.push({
-									role: "assistant",
-									content: payload.content
-								});
-							}
-						}
+				case "opaque": {
+					if (item.purpose !== "replay") break;
+					assertOpaqueReplayEnvelope(item.payload);
+					const payload = item.payload;
+					if (payload.role === "assistant" && "content" in payload) {
+						assertMessagesReplayContent(payload.content);
+						mapper$2.rollbackTrailingAssistantMessages(messages);
+						messages.push({
+							role: "assistant",
+							content: payload.content
+						});
 					}
 					break;
+				}
 			}
 		}
 		const body = {
@@ -1625,27 +2144,53 @@ var MessagesAdapter = class extends AdapterBase {
 		return body;
 	}
 	async *runStream(providerRequest, factory, request) {
-		this.warningAccumulator = [];
 		const auxiliary = this.createAuxiliaryState(request);
+		let completedEmitted = false;
 		if (request.metadata) yield factory.responseWarning("Request metadata is not supported by the Messages adapter", "UNSUPPORTED_METADATA");
-		const response = await this.fetchFn(`${this.baseUrl}/messages`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				"x-api-key": this.apiKey,
-				"anthropic-version": this.apiVersion
-			},
-			body: JSON.stringify(providerRequest)
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${this.baseUrl}/messages`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"x-api-key": this.apiKey,
+					"anthropic-version": this.apiVersion
+				},
+				body: JSON.stringify(providerRequest)
+			});
+		} catch (err) {
+			throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+		}
 		if (!response.ok) {
-			const errorText = await response.text().catch(() => "unknown error");
-			throw new Error(`Messages API error ${response.status}: ${errorText}`);
+			const errorBody = await response.text().catch(() => "");
+			throw providerHttpError(response.status, errorBody);
 		}
 		const reader = response.body?.getReader();
-		if (!reader) throw new Error("Response body is not readable");
+		if (!reader) throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
+		const parser = new IncrementalStreamParser(splitSSEFrames, (frame) => {
+			let eventType = "";
+			let dataStr = "";
+			for (const rawLine of frame.split("\n")) {
+				const line = rawLine.trim();
+				if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+				else if (line.startsWith("data: ")) dataStr += line.slice(6);
+			}
+			if (!eventType) return { status: "ignored" };
+			try {
+				const data = JSON.parse(dataStr);
+				return {
+					status: "parsed",
+					value: {
+						type: eventType,
+						data
+					}
+				};
+			} catch {
+				return { status: "malformed" };
+			}
+		});
 		const output = [];
-		const decoder = new TextDecoder();
-		let buffer = "";
+		let streamDone = false;
 		let messageResponse;
 		let currentContentBlockIndex = -1;
 		let currentItemType = null;
@@ -1667,11 +2212,10 @@ var MessagesAdapter = class extends AdapterBase {
 		}
 		try {
 			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				const { events, rest, malformedEvents } = parseMessagesSSE(buffer);
-				buffer = rest;
+				const { done, value } = await reader.read().catch((err) => {
+					throw new AIStreamError(`Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`, "STREAM_ERROR");
+				});
+				const { items: events, malformed: malformedEvents } = done ? parser.flush() : parser.feed(value);
 				const malformedWarning = emitMalformedStreamWarning(factory, {
 					count: malformedEvents,
 					providerLabel: "Messages",
@@ -1683,7 +2227,6 @@ var MessagesAdapter = class extends AdapterBase {
 					case "error": {
 						const err = sseEvent.data.error;
 						yield factory.responseWarning(err.message, err.type);
-						this.warn(err.message, err.type);
 						continue;
 					}
 					case "message_start":
@@ -1718,7 +2261,7 @@ var MessagesAdapter = class extends AdapterBase {
 								yield factory.reasoningStarted(currentItemId, "redacted");
 								yield factory.reasoningDelta(currentItemId, textBlock(data));
 								const redactedItem = reasoningItem([textBlock(data)], "redacted", currentItemId);
-								yield factory.reasoningCompleted(redactedItem);
+								yield factory.reasoningCompleted(currentItemId);
 								output.push(redactedItem);
 								rawReplayContent.push({
 									type: "redacted_thinking",
@@ -1747,7 +2290,7 @@ var MessagesAdapter = class extends AdapterBase {
 								if (currentItemType === "message" && currentItemId) {
 									const txt = delta.text;
 									textBuffer += txt;
-									yield factory.messageDelta(currentItemId, txt);
+									yield factory.messageDelta(currentItemId, textBlock(txt));
 								}
 								break;
 							case "thinking_delta":
@@ -1769,14 +2312,14 @@ var MessagesAdapter = class extends AdapterBase {
 					}
 					case "content_block_stop":
 						if (currentItemType === "message" && currentItemId) {
-							yield factory.messageCompleted(messageItem([textBlock(textBuffer)], { id: currentItemId }));
+							yield factory.messageCompleted(currentItemId);
 							output.push(messageItem([textBlock(textBuffer)], { id: currentItemId }));
 							rawReplayContent.push({
 								type: "text",
 								text: textBuffer
 							});
 						} else if (currentItemType === "reasoning" && currentItemId && currentThinkingVisibility !== "redacted") {
-							yield factory.reasoningCompleted(reasoningItem([textBlock(thinkingBuffer)], currentThinkingVisibility, currentItemId));
+							yield factory.reasoningCompleted(currentItemId);
 							output.push(reasoningItem([textBlock(thinkingBuffer)], currentThinkingVisibility, currentItemId));
 							rawReplayContent.push({
 								type: "thinking",
@@ -1784,7 +2327,7 @@ var MessagesAdapter = class extends AdapterBase {
 							});
 						} else if (currentItemType === "tool_call" && currentItemId) {
 							const tcItem = toolCallItem(currentItemId, currentToolName, currentArgsText || argsBuffer);
-							yield factory.toolCallCompleted(tcItem);
+							yield factory.toolCallCompleted(currentItemId);
 							output.push(tcItem);
 							rawReplayContent.push({
 								type: "tool_use",
@@ -1805,11 +2348,19 @@ var MessagesAdapter = class extends AdapterBase {
 					}
 					case "message_stop": break;
 				}
+				if (done) {
+					streamDone = true;
+					break;
+				}
 			}
 		} finally {
-			reader.releaseLock();
+			try {
+				if (!streamDone) await reader.cancel().catch(() => void 0);
+			} finally {
+				reader.releaseLock();
+			}
 		}
-		if (buffer.trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Messages SSE frame", "STREAM_ERROR");
+		if (parser.getRemaining().trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Messages SSE frame", "STREAM_ERROR");
 		const replay = [...replayFromOutput(output)];
 		if (messageResponse) {
 			const replayContent = rawReplayContent.length > 0 ? rawReplayContent : messageResponse.content;
@@ -1830,17 +2381,29 @@ var MessagesAdapter = class extends AdapterBase {
 		if (!hasStreamedReasoning) {}
 		const auxiliaryResult = await auxiliary.finalize(factory);
 		for (const event of auxiliaryResult.events) yield event;
-		yield factory.responseCompleted(this.buildResponse(request, {
-			output,
-			replay,
-			stopReason: stopReason ? mapStopReason(stopReason) : void 0,
-			usage: auxiliaryResult.usage,
-			billing: auxiliaryResult.billing,
-			auxiliary: auxiliaryResult.auxiliary,
-			warnings: auxiliaryResult.warnings,
-			metadataSources: auxiliaryResult.metadataSources,
-			rawResponseId
-		}, factory));
+		if (!completedEmitted) {
+			completedEmitted = true;
+			const finalResponse = this.buildResponse(request, {
+				output,
+				replay,
+				stopReason: stopReason ? mapStopReason(stopReason) : void 0,
+				usage: auxiliaryResult.usage,
+				billing: auxiliaryResult.billing,
+				auxiliary: auxiliaryResult.auxiliary,
+				warnings: auxiliaryResult.warnings,
+				metadataSources: auxiliaryResult.metadataSources,
+				rawResponseId
+			}, factory);
+			yield factory.responseCompleted({
+				replay: finalResponse.replay,
+				stopReason: finalResponse.stopReason,
+				trace: finalResponse.backend,
+				usage: finalResponse.usage,
+				billing: finalResponse.billing,
+				auxiliary: finalResponse.auxiliary,
+				warnings: finalResponse.warnings
+			});
+		}
 	}
 };
 //#endregion
@@ -1855,51 +2418,21 @@ var MessagesAdapter = class extends AdapterBase {
 * - replay fidelity 依赖 provider 是否暴露可回放的 assistant turn 字段
 */
 const REASONING_FIELDS = ["reasoning_content", "reasoning"];
-function assertChatToolResultOutcome(outcome) {
-	if (outcome !== "success") throw new AIRequestError(`chat-completions does not preserve tool_result outcome "${outcome}"; only "success" is supported`, "UNSUPPORTED_TOOL_RESULT_OUTCOME");
-}
-/**
-* Chat Completions 的简化 SSE 解析器。
-*
-* 约束：
-* - 每条 `data:` 行必须已经是一个完整 JSON 对象
-* - 允许传输层把单行拆成多个 chunk，但不接受 provider 把一个 JSON event 改写成多条 `data:` 行
-*/
-function parseChatSSE(buffer) {
-	const chunks = [];
-	let rest = buffer;
-	let malformedEvents = 0;
-	while (true) {
-		const lineEnd = rest.indexOf("\n");
-		if (lineEnd === -1) break;
-		const line = rest.slice(0, lineEnd).trim();
-		rest = rest.slice(lineEnd + 1);
-		if (!line.startsWith("data: ")) continue;
-		const data = line.slice(6).trim();
-		if (data === "[DONE]") continue;
-		try {
-			chunks.push(JSON.parse(data));
-		} catch {
-			malformedEvents++;
-		}
+const profile$1 = {
+	kind: "chat-completions",
+	instructionsMode: "system_message",
+	supportedBlockTypes: ["text", "json"],
+	reasoningBlockTypes: ["text"],
+	capabilities: {
+		textStreaming: "native",
+		reasoningStreaming: "native",
+		toolCallStreaming: "native",
+		replay: "opaque",
+		usage: "final",
+		toolResultOutcomes: ["success"]
 	}
-	return {
-		chunks,
-		rest,
-		malformedEvents
-	};
-}
-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;
-}
-function contentBlocksToChatText(blocks, field) {
-	return contentBlocksToText(ensureTextCompatibleBlocks(blocks, field));
-}
+};
+const mapper$1 = new NormalizedRequestMapper(profile$1);
 function extractReasoningText(value) {
 	if (typeof value === "string") return value;
 	if (Array.isArray(value)) return value.map(extractReasoningText).join("");
@@ -1930,8 +2463,31 @@ function extractReasoningDeltas(delta) {
 	}
 	return deltas;
 }
-function rollbackTrailingAssistantMessages$1(messages) {
-	while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
+function isChatReplayToolCall(value) {
+	if (!value || typeof value !== "object") return false;
+	const entry = value;
+	if (typeof entry.id !== "string" || entry.type !== "function") return false;
+	const fn = entry.function;
+	if (!fn || typeof fn !== "object") return false;
+	const f = fn;
+	return typeof f.name === "string" && typeof f.arguments === "string";
+}
+function isChatReplayMessage(value) {
+	if (!value || typeof value !== "object") return false;
+	const msg = value;
+	const role = msg.role;
+	if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool") return false;
+	if (!(msg.content === null || typeof msg.content === "string")) return false;
+	if (msg.tool_calls !== void 0) {
+		if (!Array.isArray(msg.tool_calls) || !msg.tool_calls.every(isChatReplayToolCall)) return false;
+	}
+	if (msg.tool_call_id !== void 0 && typeof msg.tool_call_id !== "string") return false;
+	if (msg.name !== void 0 && typeof msg.name !== "string") return false;
+	return true;
+}
+function assertChatReplayMessages(messages, field) {
+	if (!Array.isArray(messages)) throw new AIRequestError(`Invalid opaque replay payload: ${field} must be an array`, "INVALID_OPAQUE_REPLAY");
+	for (let i = 0; i < messages.length; i++) if (!isChatReplayMessage(messages[i])) throw new AIRequestError(`Invalid opaque replay payload: ${field}[${i}] is not a valid chat message`, "INVALID_OPAQUE_REPLAY");
 }
 function buildAssistantReplayMessage(params) {
 	const { content, reasoningByField, toolCalls } = params;
@@ -1953,7 +2509,7 @@ function buildAssistantReplayMessage(params) {
 }
 var ChatCompletionsAdapter = class extends AdapterBase {
 	kind = "chat-completions";
-	nativeStreaming = true;
+	capabilities = profile$1.capabilities;
 	apiKey;
 	baseUrl;
 	fetchFn;
@@ -1965,17 +2521,14 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 	}
 	buildRequest(request) {
 		const messages = [];
-		if (request.instructions) {
-			const content = typeof request.instructions === "string" ? request.instructions : contentBlocksToChatText(request.instructions, "instructions");
-			messages.push({
-				role: "system",
-				content
-			});
-		}
+		if (request.instructions) messages.push({
+			role: "system",
+			content: mapper$1.mapInstructions(request.instructions)
+		});
 		for (const item of request.input) switch (item.type) {
 			case "message": {
 				const role = item.role;
-				const text = contentBlocksToChatText(item.content, `input message (${item.role}) content`);
+				const text = contentBlocksToText(mapper$1.ensureTextBlocks(item.content, `input message (${item.role}) content`));
 				messages.push({
 					role,
 					content: text || null
@@ -2001,38 +2554,44 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 				break;
 			}
 			case "tool_result":
-				assertChatToolResultOutcome(item.outcome);
+				mapper$1.assertToolResultOutcome(item.outcome);
 				messages.push({
 					role: "tool",
 					tool_call_id: item.callId,
 					name: item.toolName,
-					content: contentBlocksToChatText(item.content, `tool_result ${item.callId} content`)
+					content: contentBlocksToText(mapper$1.ensureTextBlocks(item.content, `tool_result ${item.callId} content`))
 				});
 				break;
 			case "reasoning":
 				messages.push({
 					role: "assistant",
-					content: contentBlocksToChatText(item.content, "reasoning content")
+					content: contentBlocksToText(mapper$1.ensureTextBlocks(item.content, "reasoning content"))
 				});
 				break;
-			case "opaque":
-				if (item.purpose === "replay" && typeof item.payload === "object" && item.payload !== null) {
-					const payload = item.payload;
-					if (payload.role === "assistant" && typeof payload.content === "string") messages.push({
-						role: "assistant",
-						content: payload.content
-					});
-					else if (payload.replaceCanonical === true && Array.isArray(payload.messages)) {
-						rollbackTrailingAssistantMessages$1(messages);
-						for (const m of payload.messages) messages.push(m);
-					} else if (Array.isArray(payload.messages)) for (const m of payload.messages) messages.push(m);
+			case "opaque": {
+				if (item.purpose !== "replay") break;
+				assertOpaqueReplayEnvelope(item.payload);
+				const payload = item.payload;
+				if (payload.role === "assistant" && typeof payload.content === "string") messages.push({
+					role: "assistant",
+					content: payload.content
+				});
+				else if (payload.replaceCanonical === true && "messages" in payload) {
+					assertChatReplayMessages(payload.messages, "messages");
+					mapper$1.rollbackTrailingAssistantMessages(messages);
+					for (const m of payload.messages) messages.push(m);
+				} else if ("messages" in payload) {
+					assertChatReplayMessages(payload.messages, "messages");
+					for (const m of payload.messages) messages.push(m);
 				}
 				break;
+			}
 		}
 		const body = {
 			model: request.model,
 			messages,
-			stream: true
+			stream: true,
+			n: 1
 		};
 		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
 			type: "function",
@@ -2057,23 +2616,41 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 	}
 	async *runStream(providerRequest, factory, request) {
 		const auxiliary = this.createAuxiliaryState(request);
-		const response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${this.apiKey}`
-			},
-			body: JSON.stringify(providerRequest)
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body: JSON.stringify(providerRequest)
+			});
+		} catch (err) {
+			throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+		}
 		if (!response.ok) {
-			const errorText = await response.text().catch(() => "unknown error");
-			throw new Error(`Chat Completions API error ${response.status}: ${errorText}`);
+			const errorBody = await response.text().catch(() => "");
+			throw providerHttpError(response.status, errorBody);
 		}
 		const reader = response.body?.getReader();
-		if (!reader) throw new Error("Response body is not readable");
+		if (!reader) throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
+		const parser = new IncrementalStreamParser(splitLines, (item) => {
+			const trimmed = item.trim();
+			if (!trimmed.startsWith("data: ")) return { status: "ignored" };
+			const data = trimmed.slice(6).trim();
+			if (data === "[DONE]") return { status: "ignored" };
+			try {
+				return {
+					status: "parsed",
+					value: JSON.parse(data)
+				};
+			} catch {
+				return { status: "malformed" };
+			}
+		});
 		const output = [];
-		const decoder = new TextDecoder();
-		let buffer = "";
+		let streamDone = false;
 		let responseId;
 		let accumulatedContent = "";
 		let accumulatedReasoning = "";
@@ -2081,6 +2658,9 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 		let currentReasoningId = "";
 		let hasMessageStarted = false;
 		let hasReasoningStarted = false;
+		let completedEmitted = false;
+		let warnedNonZeroChoice = false;
+		const buildResponse = this.buildResponse.bind(this);
 		const pendingToolCalls = /* @__PURE__ */ new Map();
 		const reasoningByField = /* @__PURE__ */ new Map();
 		const finalizePendingTurn = () => {
@@ -2089,17 +2669,17 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 			const finalizedReasoningByField = new Map(reasoningByField);
 			if (hasReasoningStarted && accumulatedReasoning) {
 				const reasoning = reasoningItem([textBlock(accumulatedReasoning)], "full", currentReasoningId);
-				events.push(factory.reasoningCompleted(reasoning));
+				events.push(factory.reasoningCompleted(currentReasoningId));
 				output.push(reasoning);
 			}
-			if (hasMessageStarted && accumulatedContent) {
+			if (hasMessageStarted) {
 				const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
-				events.push(factory.messageCompleted(message));
-				output.push(message);
+				events.push(factory.messageCompleted(currentMessageId));
+				if (accumulatedContent) output.push(message);
 			}
 			for (const pending of finalizedToolCalls) {
 				const toolCall = toolCallItem(pending.id, pending.name, pending.args);
-				events.push(factory.toolCallCompleted(toolCall));
+				events.push(factory.toolCallCompleted(pending.id));
 				output.push(toolCall);
 			}
 			const assistantReplayMessage = buildAssistantReplayMessage({
@@ -2120,13 +2700,46 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 				assistantReplayMessage
 			};
 		};
+		const emitCompleted = async function* (stopReason, assistantReplayMessage, rawResponseId) {
+			if (completedEmitted) {
+				yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+				return;
+			}
+			completedEmitted = true;
+			const replay = [...replayFromOutput(output)];
+			if (assistantReplayMessage) replay.push(opaqueItem("chat.completions", "replay", {
+				replaceCanonical: true,
+				messages: [assistantReplayMessage]
+			}));
+			const auxiliaryResult = await auxiliary.finalize(factory);
+			for (const event of auxiliaryResult.events) yield event;
+			const finalResponse = buildResponse(request, {
+				output,
+				replay,
+				stopReason,
+				usage: auxiliaryResult.usage,
+				billing: auxiliaryResult.billing,
+				auxiliary: auxiliaryResult.auxiliary,
+				warnings: auxiliaryResult.warnings,
+				metadataSources: auxiliaryResult.metadataSources,
+				rawResponseId
+			}, factory);
+			yield factory.responseCompleted({
+				replay: finalResponse.replay,
+				stopReason: finalResponse.stopReason,
+				trace: finalResponse.backend,
+				usage: finalResponse.usage,
+				billing: finalResponse.billing,
+				auxiliary: finalResponse.auxiliary,
+				warnings: finalResponse.warnings
+			});
+		};
 		try {
 			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				const { chunks, rest, malformedEvents } = parseChatSSE(buffer);
-				buffer = rest;
+				const { done, value } = await reader.read().catch((err) => {
+					throw new AIStreamError(`Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`, "STREAM_ERROR");
+				});
+				const { items: chunks, malformed: malformedEvents } = done ? parser.flush() : parser.feed(value);
 				const malformedWarning = emitMalformedStreamWarning(factory, {
 					count: malformedEvents,
 					providerLabel: "Chat Completions",
@@ -2137,14 +2750,28 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 					responseId = chunk.id;
 					if (chunk.usage) auxiliary.recordUsage(usageFromChatCompletions(chunk.usage), "final", chunk.usage);
 					for (const choice of chunk.choices) {
-						if (choice.index !== 0) continue;
+						if (choice.index !== 0) {
+							if (!warnedNonZeroChoice) {
+								yield factory.responseWarning(`Chat Completions returned choice index ${choice.index}; only the first choice (index 0) is supported. This choice is ignored.`, "MULTIPLE_CHOICES_IGNORED");
+								warnedNonZeroChoice = true;
+							}
+							continue;
+						}
+						if (completedEmitted) {
+							if (choice.finish_reason) yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+							continue;
+						}
 						const delta = choice.delta;
 						const finishReason = choice.finish_reason;
 						const reasoningDeltas = extractReasoningDeltas(delta);
-						if (delta.role === "assistant" && typeof delta.content === "string" && !hasMessageStarted) {
+						const ensureMessageStarted = () => {
+							if (hasMessageStarted) return;
 							currentMessageId = `msg-${chunk.id}`;
 							hasMessageStarted = true;
 							accumulatedContent = "";
+						};
+						if (delta.role === "assistant" && !hasMessageStarted) {
+							ensureMessageStarted();
 							yield factory.messageStarted(currentMessageId);
 						}
 						if (reasoningDeltas.length > 0) {
@@ -2162,32 +2789,41 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 						}
 						if (delta.content) {
 							if (!hasMessageStarted) {
-								currentMessageId = `msg-${chunk.id}`;
-								hasMessageStarted = true;
+								ensureMessageStarted();
 								yield factory.messageStarted(currentMessageId);
 							}
 							accumulatedContent += delta.content;
-							yield factory.messageDelta(currentMessageId, delta.content);
+							yield factory.messageDelta(currentMessageId, textBlock(delta.content));
 						}
-						if (delta.tool_calls) for (const tc of delta.tool_calls) {
-							const idx = tc.index;
-							if (tc.id) {
-								pendingToolCalls.set(idx, {
-									id: tc.id,
-									name: tc.function?.name ?? "",
-									args: ""
-								});
-								yield factory.toolCallStarted(tc.id, tc.function?.name ?? "");
+						if (delta.tool_calls) {
+							if (!hasMessageStarted) {
+								ensureMessageStarted();
+								yield factory.messageStarted(currentMessageId);
 							}
-							if (tc.function?.arguments) {
-								const pending = pendingToolCalls.get(idx);
-								if (pending) {
-									pending.args += tc.function.arguments;
-									yield factory.toolCallDelta(pending.id, { argumentsText: tc.function.arguments });
+							for (const tc of delta.tool_calls) {
+								const idx = tc.index;
+								if (tc.id) {
+									pendingToolCalls.set(idx, {
+										id: tc.id,
+										name: tc.function?.name ?? "",
+										args: ""
+									});
+									yield factory.toolCallStarted(tc.id, tc.function?.name ?? "");
+								}
+								if (tc.function?.arguments) {
+									const pending = pendingToolCalls.get(idx);
+									if (pending) {
+										pending.args += tc.function.arguments;
+										yield factory.toolCallDelta(pending.id, { argumentsText: tc.function.arguments });
+									}
 								}
 							}
 						}
 						if (delta.function_call) {
+							if (!hasMessageStarted) {
+								ensureMessageStarted();
+								yield factory.messageStarted(currentMessageId);
+							}
 							if (delta.function_call.name) {
 								const fcId = `fc-${chunk.id}-0`;
 								pendingToolCalls.set(0, {
@@ -2208,54 +2844,28 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 						if (finishReason && finishReason !== null) {
 							const { events, assistantReplayMessage } = finalizePendingTurn();
 							for (const event of events) yield event;
-							const stopReason = mapStopReason(finishReason);
-							const replay = [...replayFromOutput(output)];
-							if (assistantReplayMessage) replay.push(opaqueItem("chat.completions", "replay", {
-								replaceCanonical: true,
-								messages: [assistantReplayMessage]
-							}));
-							const auxiliaryResult = await auxiliary.finalize(factory);
-							for (const event of auxiliaryResult.events) yield event;
-							yield factory.responseCompleted(this.buildResponse(request, {
-								output,
-								replay,
-								stopReason,
-								usage: auxiliaryResult.usage,
-								billing: auxiliaryResult.billing,
-								auxiliary: auxiliaryResult.auxiliary,
-								warnings: auxiliaryResult.warnings,
-								metadataSources: auxiliaryResult.metadataSources,
-								rawResponseId: chunk.id
-							}, factory));
+							yield* emitCompleted(mapStopReason(finishReason), assistantReplayMessage, chunk.id);
 						}
 					}
 				}
+				if (done) {
+					streamDone = true;
+					break;
+				}
 			}
 		} finally {
-			reader.releaseLock();
+			try {
+				if (!streamDone) await reader.cancel().catch(() => void 0);
+			} finally {
+				reader.releaseLock();
+			}
 		}
-		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) {
+		if (parser.getRemaining().trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Chat Completions SSE frame", "STREAM_ERROR");
+		if (!completedEmitted && (hasMessageStarted || hasReasoningStarted || pendingToolCalls.size > 0)) {
 			yield factory.responseWarning("Stream ended without a finish_reason", "INCOMPLETE_STREAM");
 			const { events, assistantReplayMessage } = finalizePendingTurn();
 			for (const event of events) yield event;
-			const replay = [...replayFromOutput(output)];
-			if (assistantReplayMessage) replay.push(opaqueItem("chat.completions", "replay", {
-				replaceCanonical: true,
-				messages: [assistantReplayMessage]
-			}));
-			const auxiliaryResult = await auxiliary.finalize(factory);
-			for (const event of auxiliaryResult.events) yield event;
-			yield factory.responseCompleted(this.buildResponse(request, {
-				output,
-				replay,
-				usage: auxiliaryResult.usage,
-				billing: auxiliaryResult.billing,
-				auxiliary: auxiliaryResult.auxiliary,
-				warnings: auxiliaryResult.warnings,
-				metadataSources: auxiliaryResult.metadataSources,
-				rawResponseId: responseId
-			}, factory));
+			yield* emitCompleted(void 0, assistantReplayMessage, responseId);
 		}
 	}
 };
@@ -2277,23 +2887,21 @@ var ChatCompletionsAdapter = class extends AdapterBase {
 * - tool_call 不支持逐 token 流式
 * - replay 保真度低（无 opaque continuation 机制）
 */
-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;
-}
-function ensureOllamaReasoningBlocks(blocks, field) {
-	return blocks.map((block, index) => {
-		if (block.type !== "text") throw new AIRequestError(`ollama does not support ${field}[${index}] of type "${block.type}"; reasoning only supports text blocks`, "UNSUPPORTED_CONTENT_BLOCK");
-		return block;
-	});
-}
-function instructionsToOllamaText(instructions) {
-	return typeof instructions === "string" ? instructions : contentBlocksToText(ensureOllamaTextBlocks(instructions, "instructions"));
-}
+const profile = {
+	kind: "ollama",
+	instructionsMode: "system_message",
+	supportedBlockTypes: ["text", "json"],
+	reasoningBlockTypes: ["text"],
+	capabilities: {
+		textStreaming: "native",
+		reasoningStreaming: "none",
+		toolCallStreaming: "synthetic",
+		replay: "opaque",
+		usage: "final",
+		toolResultOutcomes: ["success"]
+	}
+};
+const mapper = new NormalizedRequestMapper(profile);
 function parseOllamaToolArguments(item) {
 	if (item.argumentsJson && typeof item.argumentsJson === "object" && item.argumentsJson !== null) return item.argumentsJson;
 	try {
@@ -2302,46 +2910,24 @@ function parseOllamaToolArguments(item) {
 	} catch {}
 	throw new AIRequestError("ollama tool_call argumentsText must be valid JSON object when argumentsJson is absent", "TOOL_CALL_ARGUMENTS_INVALID");
 }
-function assertOllamaToolResultOutcome(outcome) {
-	if (outcome !== "success") throw new AIRequestError(`ollama does not preserve tool_result outcome "${outcome}"; only "success" is supported`, "UNSUPPORTED_TOOL_RESULT_OUTCOME");
-}
-function parseOllamaNDJSON(buffer) {
-	const chunks = [];
-	let rest = buffer;
-	let malformedLines = 0;
-	while (true) {
-		const lineEnd = rest.indexOf("\n");
-		if (lineEnd === -1) break;
-		const line = rest.slice(0, lineEnd).trim();
-		rest = rest.slice(lineEnd + 1);
-		if (!line) continue;
-		try {
-			const parsed = JSON.parse(line);
-			if (parsed && typeof parsed === "object" && "message" in parsed) chunks.push(parsed);
-			else malformedLines++;
-		} catch {
-			malformedLines++;
-		}
-	}
-	return {
-		chunks,
-		rest,
-		malformedLines
-	};
-}
-function rollbackTrailingAssistantMessages(messages) {
-	while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
-}
-function isOllamaToolCalls(value) {
+function isOllamaReplayToolCalls(value) {
 	return Array.isArray(value) && value.every((entry) => {
 		if (!entry || typeof entry !== "object" || !("function" in entry)) return false;
 		const fn = entry.function;
+		const id = entry.id;
+		if (id !== void 0 && typeof id !== "string") return false;
 		return !!fn && typeof fn === "object" && "name" in fn && typeof fn.name === "string" && "arguments" in fn && typeof fn.arguments === "object" && fn.arguments !== null;
 	});
 }
+function toWireOllamaToolCalls(toolCalls) {
+	return toolCalls.map((tc) => ({ function: {
+		name: tc.function.name,
+		arguments: tc.function.arguments
+	} }));
+}
 var OllamaAdapter = class extends AdapterBase {
 	kind = "ollama";
-	nativeStreaming = true;
+	capabilities = profile.capabilities;
 	baseUrl;
 	apiKey;
 	fetchFn;
@@ -2354,16 +2940,18 @@ var OllamaAdapter = class extends AdapterBase {
 	buildRequest(request) {
 		if (request.toolChoice && request.toolChoice !== "auto") throw new AIRequestError("ollama does not support explicit toolChoice", "UNSUPPORTED_TOOL_CHOICE");
 		const messages = [];
+		/** Local-only name → call id queue for best-effort tool_result association (not sent to Ollama). */
+		const callIdsByName = /* @__PURE__ */ new Map();
 		if (request.instructions) messages.push({
 			role: "system",
-			content: instructionsToOllamaText(request.instructions)
+			content: mapper.mapInstructions(request.instructions)
 		});
 		for (const item of request.input) switch (item.type) {
 			case "message": {
 				const role = item.role;
 				messages.push({
 					role,
-					content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `input message (${item.role}) content`))
+					content: contentBlocksToText(mapper.ensureTextBlocks(item.content, `input message (${item.role}) content`))
 				});
 				break;
 			}
@@ -2373,6 +2961,9 @@ var OllamaAdapter = class extends AdapterBase {
 					name: item.name,
 					arguments: parseOllamaToolArguments(item)
 				} };
+				const queue = callIdsByName.get(item.name) ?? [];
+				queue.push(item.id);
+				callIdsByName.set(item.name, queue);
 				if (lastAssistant) lastAssistant.tool_calls = [...lastAssistant.tool_calls ?? [], tc];
 				else messages.push({
 					role: "assistant",
@@ -2381,32 +2972,48 @@ var OllamaAdapter = class extends AdapterBase {
 				});
 				break;
 			}
-			case "tool_result":
-				assertOllamaToolResultOutcome(item.outcome);
+			case "tool_result": {
+				mapper.assertToolResultOutcome(item.outcome);
+				const queue = callIdsByName.get(item.toolName);
+				if (queue && queue.length > 0) queue.shift();
 				messages.push({
 					role: "tool",
-					content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `tool_result ${item.callId} content`))
+					content: contentBlocksToText(mapper.ensureTextBlocks(item.content, `tool_result ${item.callId} content`))
 				});
 				break;
+			}
 			case "reasoning":
 				messages.push({
 					role: "assistant",
-					content: contentBlocksToText(ensureOllamaReasoningBlocks(item.content, "reasoning content"))
+					content: contentBlocksToText(mapper.ensureReasoningBlocks(item.content, "reasoning content"))
 				});
 				break;
-			case "opaque":
-				if (item.source === "ollama" && item.purpose === "replay" && typeof item.payload === "object" && item.payload !== null) {
-					const payload = item.payload;
-					if (payload.role === "assistant" && typeof payload.content === "string") {
-						rollbackTrailingAssistantMessages(messages);
-						messages.push({
-							role: "assistant",
-							content: payload.content,
-							tool_calls: isOllamaToolCalls(payload.tool_calls) ? payload.tool_calls : void 0
-						});
+			case "opaque": {
+				if (item.source !== "ollama" || item.purpose !== "replay") break;
+				assertOpaqueReplayEnvelope(item.payload);
+				const payload = item.payload;
+				if (payload.role === "assistant" && typeof payload.content === "string") {
+					mapper.rollbackTrailingAssistantMessages(messages);
+					let replayToolCalls;
+					if ("tool_calls" in payload && payload.tool_calls !== void 0) {
+						if (!isOllamaReplayToolCalls(payload.tool_calls)) throw new AIRequestError("Invalid opaque replay payload: tool_calls is not a valid ollama tool_calls array", "INVALID_OPAQUE_REPLAY");
+						replayToolCalls = payload.tool_calls;
 					}
+					if (replayToolCalls) {
+						for (const tc of replayToolCalls) if (tc.id) {
+							const queue = callIdsByName.get(tc.function.name) ?? [];
+							queue.push(tc.id);
+							callIdsByName.set(tc.function.name, queue);
+						}
+					}
+					messages.push({
+						role: "assistant",
+						content: payload.content,
+						tool_calls: replayToolCalls ? toWireOllamaToolCalls(replayToolCalls) : void 0
+					});
 				}
 				break;
+			}
 		}
 		const body = {
 			model: request.model,
@@ -2430,35 +3037,96 @@ var OllamaAdapter = class extends AdapterBase {
 	}
 	async *runStream(providerRequest, factory, request) {
 		const auxiliary = this.createAuxiliaryState(request);
+		let completedEmitted = false;
 		if (request.metadata) yield factory.responseWarning("Request metadata is not supported by the Ollama adapter", "UNSUPPORTED_METADATA");
 		const headers = { "Content-Type": "application/json" };
 		if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
-		const response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(providerRequest)
-		});
+		let response;
+		try {
+			response = await this.fetchFn(`${this.baseUrl}/api/chat`, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(providerRequest)
+			});
+		} catch (err) {
+			throw new AIProviderError(err instanceof Error ? err.message : String(err), "PROVIDER_ERROR");
+		}
 		if (!response.ok) {
-			const errorText = await response.text().catch(() => "unknown error");
-			throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+			const errorBody = await response.text().catch(() => "");
+			throw providerHttpError(response.status, errorBody);
 		}
 		const reader = response.body?.getReader();
-		if (!reader) throw new Error("Response body is not readable");
+		if (!reader) throw new AIStreamError("Response body is not readable", "STREAM_ERROR");
+		const parser = new IncrementalStreamParser(splitLines, (item) => {
+			const trimmed = item.trim();
+			if (!trimmed) return { status: "ignored" };
+			try {
+				const parsed = JSON.parse(trimmed);
+				if (parsed && typeof parsed === "object" && "message" in parsed) return {
+					status: "parsed",
+					value: parsed
+				};
+				return { status: "malformed" };
+			} catch {
+				return { status: "malformed" };
+			}
+		});
 		const output = [];
-		const decoder = new TextDecoder();
-		let buffer = "";
+		let streamDone = false;
 		let responseId;
 		let accumulatedContent = "";
 		let currentMessageId = "";
 		let hasMessageStarted = false;
 		let pendingToolCalls = [];
+		let toolCallIndex = 0;
+		const buildResponse = this.buildResponse.bind(this);
+		const emitCompleted = async function* (stopReason, rawResponseId) {
+			if (completedEmitted) {
+				yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+				return;
+			}
+			completedEmitted = true;
+			const replay = replayFromOutput(output);
+			if (accumulatedContent || pendingToolCalls.length > 0) replay.push(opaqueItem("ollama", "replay", {
+				role: "assistant",
+				content: accumulatedContent,
+				tool_calls: pendingToolCalls.map((tc) => ({
+					id: tc.id,
+					function: {
+						name: tc.name,
+						arguments: tc.argumentsJson
+					}
+				}))
+			}));
+			const auxiliaryResult = await auxiliary.finalize(factory);
+			for (const event of auxiliaryResult.events) yield event;
+			const finalResponse = buildResponse(request, {
+				output,
+				replay,
+				stopReason,
+				usage: auxiliaryResult.usage,
+				billing: auxiliaryResult.billing,
+				auxiliary: auxiliaryResult.auxiliary,
+				warnings: auxiliaryResult.warnings,
+				metadataSources: auxiliaryResult.metadataSources,
+				rawResponseId
+			}, factory);
+			yield factory.responseCompleted({
+				replay: finalResponse.replay,
+				stopReason: finalResponse.stopReason,
+				trace: finalResponse.backend,
+				usage: finalResponse.usage,
+				billing: finalResponse.billing,
+				auxiliary: finalResponse.auxiliary,
+				warnings: finalResponse.warnings
+			});
+		};
 		try {
 			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				const { chunks, rest, malformedLines } = parseOllamaNDJSON(buffer);
-				buffer = rest;
+				const { done, value } = await reader.read().catch((err) => {
+					throw new AIStreamError(`Failed to read response stream: ${err instanceof Error ? err.message : String(err)}`, "STREAM_ERROR");
+				});
+				const { items: chunks, malformed: malformedLines } = done ? parser.flush() : parser.feed(value);
 				const malformedWarning = emitMalformedStreamWarning(factory, {
 					count: malformedLines,
 					providerLabel: "Ollama",
@@ -2467,6 +3135,10 @@ var OllamaAdapter = class extends AdapterBase {
 				if (malformedWarning) yield malformedWarning;
 				for (const chunk of chunks) {
 					responseId = chunk.created_at;
+					if (completedEmitted) {
+						if (chunk.done) yield factory.responseWarning("Duplicate finish signal ignored", "DUPLICATE_FINISH");
+						continue;
+					}
 					const msg = chunk.message;
 					if (msg.content) {
 						if (!hasMessageStarted) {
@@ -2475,10 +3147,10 @@ var OllamaAdapter = class extends AdapterBase {
 							yield factory.messageStarted(currentMessageId);
 						}
 						accumulatedContent += msg.content;
-						yield factory.messageDelta(currentMessageId, msg.content);
+						yield factory.messageDelta(currentMessageId, textBlock(msg.content));
 					}
 					if (msg.tool_calls && msg.tool_calls.length > 0) for (const tc of msg.tool_calls) {
-						const tcId = `tc-${chunk.created_at}-${tc.function.name}`;
+						const tcId = `ollama-tc-${request.requestId}-${toolCallIndex++}`;
 						const argsText = JSON.stringify(tc.function.arguments);
 						pendingToolCalls.push({
 							id: tcId,
@@ -2495,14 +3167,15 @@ var OllamaAdapter = class extends AdapterBase {
 						}
 						if (hasMessageStarted) {
 							const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
-							yield factory.messageCompleted(message);
+							yield factory.messageCompleted(currentMessageId);
 							if (accumulatedContent) output.push(message);
 						}
+						if (pendingToolCalls.length > 0) yield factory.responseWarning(`Ollama delivered ${pendingToolCalls.length} tool call(s) as a batch; tool_call streaming is not supported`, WarningCode.TOOL_CALL_BATCHED);
 						for (const pending of pendingToolCalls) {
 							const toolCall = toolCallItem(pending.id, pending.name, pending.argumentsText, pending.argumentsJson);
 							yield factory.toolCallStarted(pending.id, pending.name);
 							yield factory.toolCallDelta(pending.id, { argumentsText: pending.argumentsText });
-							yield factory.toolCallCompleted(toolCall);
+							yield factory.toolCallCompleted(pending.id);
 							output.push(toolCall);
 						}
 						if (request.include?.usage !== "off" && (chunk.prompt_eval_count !== void 0 || chunk.eval_count !== void 0)) auxiliary.recordUsage(usageFromOllama({
@@ -2512,67 +3185,42 @@ var OllamaAdapter = class extends AdapterBase {
 							prompt_eval_count: chunk.prompt_eval_count,
 							eval_count: chunk.eval_count
 						});
-						const stopReason = chunk.done_reason ? mapStopReason(chunk.done_reason) : void 0;
-						const replay = replayFromOutput(output);
-						if (accumulatedContent || pendingToolCalls.length > 0) replay.push(opaqueItem("ollama", "replay", {
-							role: "assistant",
-							content: accumulatedContent,
-							tool_calls: pendingToolCalls.map((tc) => ({ function: {
-								name: tc.name,
-								arguments: tc.argumentsJson
-							} }))
-						}));
-						const auxiliaryResult = await auxiliary.finalize(factory);
-						for (const event of auxiliaryResult.events) yield event;
-						yield factory.responseCompleted(this.buildResponse(request, {
-							output,
-							replay,
-							stopReason,
-							usage: auxiliaryResult.usage,
-							billing: auxiliaryResult.billing,
-							auxiliary: auxiliaryResult.auxiliary,
-							warnings: auxiliaryResult.warnings,
-							metadataSources: auxiliaryResult.metadataSources,
-							rawResponseId: chunk.created_at
-						}, factory));
+						yield* emitCompleted(chunk.done_reason ? mapStopReason(chunk.done_reason) : void 0, chunk.created_at);
 						accumulatedContent = "";
 						currentMessageId = "";
 						hasMessageStarted = false;
 						pendingToolCalls = [];
 					}
 				}
+				if (done) {
+					streamDone = true;
+					break;
+				}
 			}
 		} finally {
-			reader.releaseLock();
+			try {
+				if (!streamDone) await reader.cancel().catch(() => void 0);
+			} finally {
+				reader.releaseLock();
+			}
 		}
-		if (buffer.trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Ollama NDJSON line", "STREAM_ERROR");
-		if (hasMessageStarted || pendingToolCalls.length > 0) {
+		if (parser.getRemaining().trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Ollama NDJSON line", "STREAM_ERROR");
+		if (!completedEmitted && (hasMessageStarted || pendingToolCalls.length > 0)) {
 			yield factory.responseWarning("Stream ended without a done signal", "INCOMPLETE_STREAM");
 			if (hasMessageStarted) {
 				const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
-				yield factory.messageCompleted(message);
+				yield factory.messageCompleted(currentMessageId);
 				if (accumulatedContent) output.push(message);
 			}
+			if (pendingToolCalls.length > 0) yield factory.responseWarning(`Ollama delivered ${pendingToolCalls.length} tool call(s) as a batch; tool_call streaming is not supported`, WarningCode.TOOL_CALL_BATCHED);
 			for (const pending of pendingToolCalls) {
 				const toolCall = toolCallItem(pending.id, pending.name, pending.argumentsText, pending.argumentsJson);
 				yield factory.toolCallStarted(pending.id, pending.name);
 				yield factory.toolCallDelta(pending.id, { argumentsText: pending.argumentsText });
-				yield factory.toolCallCompleted(toolCall);
+				yield factory.toolCallCompleted(pending.id);
 				output.push(toolCall);
 			}
-			const replay = replayFromOutput(output);
-			const auxiliaryResult = await auxiliary.finalize(factory);
-			for (const event of auxiliaryResult.events) yield event;
-			yield factory.responseCompleted(this.buildResponse(request, {
-				output,
-				replay,
-				usage: auxiliaryResult.usage,
-				billing: auxiliaryResult.billing,
-				auxiliary: auxiliaryResult.auxiliary,
-				warnings: auxiliaryResult.warnings,
-				metadataSources: auxiliaryResult.metadataSources,
-				rawResponseId: responseId
-			}, factory));
+			yield* emitCompleted(void 0, responseId);
 		}
 	}
 };
@@ -2607,7 +3255,18 @@ function assertMockRequest(request, expectation, context) {
 }
 var MockAdapter = class extends AdapterBase {
 	kind = "mock";
-	nativeStreaming = false;
+	capabilities = {
+		textStreaming: "synthetic",
+		reasoningStreaming: "synthetic",
+		toolCallStreaming: "synthetic",
+		replay: "canonical",
+		usage: "final",
+		toolResultOutcomes: [
+			"success",
+			"error",
+			"rejected"
+		]
+	};
 	handler;
 	providerMetadata;
 	cursor = 0;
@@ -2679,18 +3338,34 @@ var MockAdapter = class extends AdapterBase {
 						break;
 					}
 					case "complete": {
-						const response = this.finalizeTurn(request, factory, mockRequest, output, step, stepCount);
-						yield factory.responseCompleted(response);
+						const finalResponse = this.finalizeTurn(request, factory, mockRequest, output, step, stepCount);
+						yield factory.responseCompleted({
+							replay: finalResponse.replay,
+							stopReason: finalResponse.stopReason,
+							trace: finalResponse.backend,
+							usage: finalResponse.usage,
+							billing: finalResponse.billing,
+							auxiliary: finalResponse.auxiliary,
+							warnings: finalResponse.warnings
+						});
 						return;
 					}
 					case "error": {
 						yield factory.responseWarning(step.message, step.code);
-						const response = this.finalizeTurn(request, factory, mockRequest, output, {
+						const finalResponse = this.finalizeTurn(request, factory, mockRequest, output, {
 							type: "complete",
 							stopReason: step.stopReason ?? "error",
 							providerMetadata: step.providerMetadata
 						}, stepCount);
-						yield factory.responseCompleted(response);
+						yield factory.responseCompleted({
+							replay: finalResponse.replay,
+							stopReason: finalResponse.stopReason,
+							trace: finalResponse.backend,
+							usage: finalResponse.usage,
+							billing: finalResponse.billing,
+							auxiliary: finalResponse.auxiliary,
+							warnings: finalResponse.warnings
+						});
 						return;
 					}
 					case "interrupt":
@@ -2699,8 +3374,16 @@ var MockAdapter = class extends AdapterBase {
 					case "throw": throw typeof step.error === "string" ? new Error(step.error) : step.error;
 				}
 			}
-			const response = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" }, stepCount);
-			yield factory.responseCompleted(response);
+			const finalResponse = this.finalizeTurn(request, factory, mockRequest, output, { type: "complete" }, stepCount);
+			yield factory.responseCompleted({
+				replay: finalResponse.replay,
+				stopReason: finalResponse.stopReason,
+				trace: finalResponse.backend,
+				usage: finalResponse.usage,
+				billing: finalResponse.billing,
+				auxiliary: finalResponse.auxiliary,
+				warnings: finalResponse.warnings
+			});
 		} finally {
 			this.activeStream = false;
 		}
@@ -2828,10 +3511,11 @@ async function* emitMessage(factory, item, stream) {
 	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);
+		yield factory.messageDelta(item.id, textBlock(chunk));
 		chunkIndex += 1;
 	}
-	yield factory.messageCompleted(item);
+	else yield factory.messageDelta(item.id, block);
+	yield factory.messageCompleted(item.id);
 }
 async function* emitReasoning(factory, item, stream) {
 	if (!item.id) throw new AIRequestError("Mock reasoning output requires an id after normalization", "MOCK_REASONING_ID_MISSING");
@@ -2848,7 +3532,7 @@ async function* emitReasoning(factory, item, stream) {
 			chunkIndex += 1;
 		}
 	}
-	yield factory.reasoningCompleted(item);
+	yield factory.reasoningCompleted(item.id);
 }
 async function* emitToolCall(factory, item, streamArguments, stream) {
 	yield factory.toolCallStarted(item.id, item.name);
@@ -2860,7 +3544,7 @@ async function* emitToolCall(factory, item, streamArguments, stream) {
 			chunkIndex += 1;
 		}
 	}
-	yield factory.toolCallCompleted(item);
+	yield factory.toolCallCompleted(item.id);
 }
 function resolveStepStreamOptions(defaults, override, label) {
 	if (override === false) return;
@@ -2971,108 +3655,6 @@ function cloneItem(item) {
 	return structuredClone(item);
 }
 //#endregion
-//#region src/helpers/synthetic-stream.ts
-/**
-* 模拟流式 (Synthetic Streaming)
-*
-* 将一组已解析的 canonical OutputItem 包装为规范事件流。
-* 适用于非原生流式后端：adapter 拿到完整响应后，调用此函数
-* 即可产出一致的事件序列，无需自己逐事件组装。
-*
-* 约束：
-* - 每个 item 只发一块完整 delta（不模拟逐 token）
-* - 保持 item 边界
-* - 保持后端原始顺序
-* - 不发明 reasoning
-* - 不改写工具参数
-*/
-/**
-* 将已解析的 output items 包装为完整规范事件流。
-*
-* 用法示例（在 adapter 的 runStream 中）：
-* ```ts
-* const result = parseNonStreamingResponse(data);
-* yield* syntheticStream({
-*   model: request.model,
-*   responseId: request.requestId,
-*   backend: { kind: "chat-completions" },
-*   output: result.output,
-*   stopReason: result.stopReason,
-*   usage: result.usage,
-* });
-* ```
-*/
-async function* syntheticStream(options) {
-	const { model, responseId, backend, output, replay, stopReason, usage, billing, providerMetadata, rawResponseId, warnings: extraWarnings } = options;
-	const factory = createEventFactory({
-		responseId,
-		backend: {
-			kind: backend.kind,
-			isSynthetic: true
-		}
-	});
-	yield factory.responseStarted(model);
-	for (const item of output) yield* emitItemEvents(item, factory);
-	if (usage || billing) yield factory.responseAuxiliary({
-		usage,
-		billing
-	});
-	const finalReplay = replay ?? replayFromOutput(output);
-	const allWarnings = [];
-	allWarnings.push("Response is synthetically streamed; delta granularity may differ from native streaming");
-	if (extraWarnings) allWarnings.push(...extraWarnings);
-	const response = {
-		id: responseId,
-		output,
-		replay: finalReplay,
-		text: extractText(output),
-		toolCalls: output.filter((item) => item.type === "tool_call"),
-		stopReason,
-		usage,
-		billing,
-		auxiliary: providerMetadata ? { providerMetadata } : void 0,
-		warnings: allWarnings.length > 0 ? allWarnings : void 0,
-		backend: {
-			requestId: responseId,
-			rawResponseId,
-			adapter: backend.kind,
-			isSyntheticStream: true
-		}
-	};
-	yield factory.responseCompleted(response);
-}
-function* emitItemEvents(item, factory) {
-	switch (item.type) {
-		case "message":
-			yield* emitMessageEvents(item, factory);
-			break;
-		case "reasoning":
-			yield* emitReasoningEvents(item, factory);
-			break;
-		case "tool_call":
-			yield* emitToolCallEvents(item, factory);
-			break;
-		case "opaque": break;
-	}
-}
-function* emitMessageEvents(item, factory) {
-	const id = item.id ?? `syn-msg-${crypto.randomUUID()}`;
-	yield factory.messageStarted(id);
-	for (const block of item.content) if (block.type === "text") yield factory.messageDelta(id, block.text);
-	yield factory.messageCompleted(item);
-}
-function* emitReasoningEvents(item, factory) {
-	const id = item.id ?? `syn-reason-${crypto.randomUUID()}`;
-	yield factory.reasoningStarted(id, item.visibility);
-	for (const block of item.content) if (block.type === "text") yield factory.reasoningDelta(id, block);
-	yield factory.reasoningCompleted(item);
-}
-function* emitToolCallEvents(item, factory) {
-	yield factory.toolCallStarted(item.id, item.name);
-	if (item.argumentsText) yield factory.toolCallDelta(item.id, { argumentsText: item.argumentsText });
-	yield factory.toolCallCompleted(item);
-}
-//#endregion
-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, usageFromAnthropicMessages, usageFromChatCompletions, usageFromOllama, usageFromOpenAIResponses, validateRequest, withMockStreaming };
+export { AIError, AIMappingError, AIProviderError, AIRequestError, AIStreamError, AdapterAuxiliaryState, AdapterBase, AuxiliaryCollector, ChatCompletionsAdapter, IncrementalStreamParser, MAX_OPAQUE_JSON_DEPTH, MAX_OPAQUE_PAYLOAD_BYTES, MessagesAdapter, MockAdapter, NormalizedRequestMapper, OllamaAdapter, PROVIDER_ERROR_MESSAGE_MAX_LEN, PROVIDER_ERROR_RAW_BODY_THRESHOLD, ResponsesAdapter, WarningCode, aggregateEvents, assertMockRequest, assertOpaqueReplayEnvelope, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractProviderErrorMessage, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, measureJsonDepth, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, providerHttpError, reasoningItem, replayFromOutput, splitLines, splitSSEFrames, syntheticStream, textBlock, toolCallItem, toolResultItem, usageFromAnthropicMessages, usageFromChatCompletions, usageFromOllama, usageFromOpenAIResponses, validateOpaqueReplayEnvelope, validateRequest, withMockStreaming };
 
 //# sourceMappingURL=index.mjs.map