@codehz/ai 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2758 @@
+//#region src/types/adapter.ts
+const CAPABILITY_MATRIX = {
+	responses: {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: true,
+		toolCallStreaming: true,
+		hiddenReasoningReplay: "full",
+		replayFidelity: "high",
+		tools: true,
+		usage: "full",
+		billing: "lookup",
+		providerMetadata: true
+	},
+	messages: {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: false,
+		toolCallStreaming: true,
+		hiddenReasoningReplay: "partial",
+		replayFidelity: "medium",
+		tools: true,
+		usage: "full",
+		billing: "lookup",
+		providerMetadata: true
+	},
+	"chat.completions": {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: false,
+		toolCallStreaming: false,
+		hiddenReasoningReplay: "none",
+		replayFidelity: "low",
+		tools: true,
+		usage: "full",
+		billing: "derived",
+		providerMetadata: false
+	},
+	ollama: {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: false,
+		toolCallStreaming: false,
+		hiddenReasoningReplay: "none",
+		replayFidelity: "low",
+		tools: true,
+		usage: "partial",
+		billing: "none",
+		providerMetadata: false
+	}
+};
+//#endregion
+//#region src/core/errors.ts
+var AIError = class extends Error {
+	code;
+	name;
+	constructor(message, code, name) {
+		super(message);
+		this.code = code;
+		this.name = name ?? "AIError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/** 请求构造失败 — 参数校验不通过。在进入 adapter 前同步抛错。 */
+var AIRequestError = class extends AIError {
+	constructor(message, code) {
+		super(message, code, "AIRequestError");
+	}
+};
+/** Provider 调用失败 — HTTP 非 2xx、网络错误。由 AdapterBase 捕获转为 warning。 */
+var AIProviderError = class extends AIError {
+	statusCode;
+	responseBody;
+	constructor(message, code, statusCode, responseBody) {
+		super(message, code, "AIProviderError");
+		this.statusCode = statusCode;
+		this.responseBody = responseBody;
+	}
+};
+/** 流协议损坏 — SSE 解析失败、chunk 格式异常。 */
+var AIStreamError = class extends AIError {
+	constructor(message, code) {
+		super(message, code, "AIStreamError");
+	}
+};
+/** Canonical 映射失败 — 无法将 provider 响应映射到 canonical 类型。 */
+var AIMappingError = class extends AIError {
+	constructor(message, code) {
+		super(message, code, "AIMappingError");
+	}
+};
+/**
+* 标准 warning 代码列表。
+* 用于非致命差异的记录。
+*/
+const WarningCode = {
+	/** replay fidelity 低于预期 */
+	REPLAY_FIDELITY_LOW: "REPLAY_FIDELITY_LOW",
+	/** usage 字段缺失 */
+	USAGE_MISSING: "USAGE_MISSING",
+	/** billing 字段缺失 */
+	BILLING_MISSING: "BILLING_MISSING",
+	/** billing 只能给估算值 */
+	BILLING_ESTIMATED: "BILLING_ESTIMATED",
+	/** follow-up lookup 失败 */
+	LOOKUP_FAILED: "LOOKUP_FAILED",
+	/** lookup 超时 */
+	LOOKUP_TIMEOUT: "LOOKUP_TIMEOUT",
+	/** 流提前中断 */
+	STREAM_INCOMPLETE: "STREAM_INCOMPLETE",
+	/** 能力降级 */
+	CAPABILITY_DOWNGRADE: "CAPABILITY_DOWNGRADE",
+	/** 模拟流式 */
+	SYNTHETIC_STREAM: "SYNTHETIC_STREAM"
+};
+//#endregion
+//#region src/core/validation.ts
+const MESSAGE_ROLES = /* @__PURE__ */ new Set([
+	"user",
+	"assistant",
+	"system",
+	"developer"
+]);
+const REASONING_VISIBILITIES = /* @__PURE__ */ new Set([
+	"full",
+	"summary",
+	"redacted",
+	"opaque"
+]);
+const TOOL_RESULT_OUTCOMES = /* @__PURE__ */ new Set([
+	"success",
+	"error",
+	"rejected"
+]);
+const INCLUDE_MODES = /* @__PURE__ */ new Set(["off", "best_effort"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function pushIssue(issues, field, code, message) {
+	issues.push({
+		field,
+		code,
+		message
+	});
+}
+function validateContentBlock(block, field, issues) {
+	if (!isRecord(block) || typeof block.type !== "string") {
+		pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field} must be a valid ContentBlock`);
+		return;
+	}
+	switch (block.type) {
+		case "text":
+			if (typeof block.text !== "string") pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.text must be a string`);
+			return;
+		case "json":
+			if (!("json" in block)) pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.json must be present`);
+			return;
+		case "image":
+			if (typeof block.imageUrl !== "string" || block.imageUrl.length === 0) pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.imageUrl must be a non-empty string`);
+			return;
+		case "binary_ref":
+			if (typeof block.ref !== "string" || block.ref.length === 0) pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.ref must be a non-empty string`);
+			return;
+		case "opaque":
+			if (!("payload" in block)) pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.payload must be present`);
+			return;
+		default: pushIssue(issues, field, "CONTENT_BLOCK_INVALID", `${field}.type "${block.type}" is not supported`);
+	}
+}
+function validateContentArray(content, field, issues, code) {
+	if (!Array.isArray(content)) {
+		pushIssue(issues, field, code, `${field} must be a ContentBlock[]`);
+		return;
+	}
+	for (let i = 0; i < content.length; i++) validateContentBlock(content[i], `${field}[${i}]`, issues);
+}
+function validateInputItem(item, field, issues) {
+	if (!isRecord(item)) {
+		pushIssue(issues, field, "INPUT_INVALID_ITEM", `${field} must be a valid InputItem`);
+		return;
+	}
+	if (typeof item.type !== "string") {
+		pushIssue(issues, field, "INPUT_ITEM_UNKNOWN_TYPE", `${field}.type must be a supported InputItem type`);
+		return;
+	}
+	switch (item.type) {
+		case "message":
+			if (typeof item.role !== "string" || !MESSAGE_ROLES.has(item.role)) pushIssue(issues, `${field}.role`, "MESSAGE_ROLE_INVALID", `${field}.role must be a valid message role`);
+			validateContentArray(item.content, `${field}.content`, issues, "MESSAGE_CONTENT_INVALID");
+			return;
+		case "reasoning":
+			if (typeof item.visibility !== "string" || !REASONING_VISIBILITIES.has(item.visibility)) pushIssue(issues, `${field}.visibility`, "REASONING_VISIBILITY_INVALID", `${field}.visibility must be a valid reasoning visibility`);
+			validateContentArray(item.content, `${field}.content`, issues, "REASONING_CONTENT_INVALID");
+			return;
+		case "tool_call":
+			if (typeof item.id !== "string" || item.id.length === 0) pushIssue(issues, `${field}.id`, "TOOL_CALL_ID_INVALID", `${field}.id must be a non-empty string`);
+			if (typeof item.name !== "string" || item.name.length === 0) pushIssue(issues, `${field}.name`, "TOOL_CALL_NAME_INVALID", `${field}.name must be a non-empty string`);
+			if (typeof item.argumentsText !== "string") pushIssue(issues, `${field}.argumentsText`, "TOOL_CALL_ARGUMENTS_INVALID", `${field}.argumentsText must be a string`);
+			return;
+		case "tool_result":
+			if (typeof item.callId !== "string" || item.callId.length === 0) pushIssue(issues, `${field}.callId`, "TOOL_RESULT_CALL_ID_INVALID", `${field}.callId must be a non-empty string`);
+			if (typeof item.toolName !== "string" || item.toolName.length === 0) pushIssue(issues, `${field}.toolName`, "TOOL_RESULT_NAME_INVALID", `${field}.toolName must be a non-empty string`);
+			if (typeof item.outcome !== "string" || !TOOL_RESULT_OUTCOMES.has(item.outcome)) pushIssue(issues, `${field}.outcome`, "TOOL_RESULT_OUTCOME_INVALID", `${field}.outcome must be success, error, or rejected`);
+			validateContentArray(item.content, `${field}.content`, issues, "TOOL_RESULT_CONTENT_INVALID");
+			return;
+		case "opaque":
+			if (typeof item.source !== "string" || item.source.length === 0) pushIssue(issues, `${field}.source`, "OPAQUE_SOURCE_INVALID", `${field}.source must be a non-empty string`);
+			if (typeof item.purpose !== "string" || item.purpose.length === 0) pushIssue(issues, `${field}.purpose`, "OPAQUE_PURPOSE_INVALID", `${field}.purpose must be a non-empty string`);
+			return;
+		default: pushIssue(issues, `${field}.type`, "INPUT_ITEM_UNKNOWN_TYPE", `${field}.type "${item.type}" is not supported`);
+	}
+}
+function validateTools(tools, issues) {
+	if (tools === void 0) return;
+	if (!Array.isArray(tools)) {
+		pushIssue(issues, "tools", "TOOLS_INVALID", "tools must be an array");
+		return;
+	}
+	const seenNames = /* @__PURE__ */ new Set();
+	for (let i = 0; i < tools.length; i++) {
+		const tool = tools[i];
+		const field = `tools[${i}]`;
+		if (!isRecord(tool)) {
+			pushIssue(issues, field, "TOOL_INVALID", `${field} must be a valid ToolDefinition`);
+			continue;
+		}
+		if (typeof tool.name !== "string" || tool.name.length === 0) pushIssue(issues, `${field}.name`, "TOOL_NAME_INVALID", `${field}.name must be a non-empty string`);
+		else {
+			if (seenNames.has(tool.name)) pushIssue(issues, `${field}.name`, "TOOLS_DUPLICATE_NAME", `tool name "${tool.name}" is duplicated`);
+			seenNames.add(tool.name);
+		}
+		if (tool.description !== void 0 && typeof tool.description !== "string") pushIssue(issues, `${field}.description`, "TOOL_DESCRIPTION_INVALID", `${field}.description must be a string`);
+		if (!isRecord(tool.inputSchema)) pushIssue(issues, `${field}.inputSchema`, "TOOL_INPUT_SCHEMA_INVALID", `${field}.inputSchema must be an object`);
+	}
+}
+function validateToolChoice(toolChoice, issues) {
+	if (toolChoice === void 0) return;
+	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 }");
+}
+/**
+* 校验 AIRequest，返回校验问题列表。
+* 空数组表示无问题。
+*/
+function validateRequest(request) {
+	const issues = [];
+	if (request.instructions !== void 0) if (typeof request.instructions === "string") {} else if (Array.isArray(request.instructions)) validateContentArray(request.instructions, "instructions", issues, "INSTRUCTIONS_INVALID");
+	else pushIssue(issues, "instructions", "INSTRUCTIONS_INVALID", "instructions must be a string or ContentBlock[]");
+	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({
+			field: "temperature",
+			code: "TEMPERATURE_NOT_NUMBER",
+			message: "temperature must be a number"
+		});
+		else if (request.temperature < 0 || request.temperature > 2) issues.push({
+			field: "temperature",
+			code: "TEMPERATURE_OUT_OF_RANGE",
+			message: "temperature must be between 0 and 2"
+		});
+	}
+	if (request.maxOutputTokens !== void 0) {
+		if (typeof request.maxOutputTokens !== "number" || isNaN(request.maxOutputTokens)) issues.push({
+			field: "maxOutputTokens",
+			code: "MAX_OUTPUT_TOKENS_NOT_NUMBER",
+			message: "maxOutputTokens must be a number"
+		});
+		else if (!Number.isInteger(request.maxOutputTokens) || request.maxOutputTokens < 1) issues.push({
+			field: "maxOutputTokens",
+			code: "MAX_OUTPUT_TOKENS_INVALID",
+			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.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`);
+	}
+	validateTools(request.tools, issues);
+	validateToolChoice(request.toolChoice, issues);
+	if (request.toolChoice && typeof request.toolChoice === "object" && "type" in request.toolChoice && request.toolChoice.type === "tool") {
+		const chosenName = request.toolChoice.name;
+		if (!request.tools || request.tools.length === 0) issues.push({
+			field: "toolChoice",
+			code: "TOOL_CHOICE_NO_TOOLS",
+			message: `toolChoice specifies tool "${chosenName}" but no tools are defined`
+		});
+		else if (!request.tools.some((t) => t.name === chosenName)) issues.push({
+			field: "toolChoice",
+			code: "TOOL_CHOICE_UNKNOWN_TOOL",
+			message: `toolChoice specifies tool "${chosenName}" which is not in tools array`
+		});
+	}
+	return issues;
+}
+/**
+* 校验请求并抛出首个问题。
+* 适用于客户端入口的快速失败检查。
+*/
+function assertValidRequest(request) {
+	const first = validateRequest(request)[0];
+	if (first) throw new AIRequestError(first.message, first.code);
+}
+//#endregion
+//#region src/core/normalize.ts
+const DEFAULT_INCLUDE = {
+	usage: "best_effort",
+	billing: "best_effort",
+	providerMetadata: "best_effort"
+};
+/**
+* 归一化请求：
+* 1. 合并 defaults
+* 2. 填充 include 默认值
+* 3. 生成 requestId
+* 4. 校验请求合法性
+*/
+function normalizeRequest(request, options) {
+	const { model, defaults } = options;
+	const merged = {
+		...defaults,
+		...request,
+		include: {
+			...DEFAULT_INCLUDE,
+			...defaults?.include,
+			...request.include
+		}
+	};
+	assertValidRequest(merged);
+	return {
+		...merged,
+		model,
+		requestId: crypto.randomUUID()
+	};
+}
+//#endregion
+//#region src/core/client.ts
+function createAIClient(options) {
+	const { adapter, model, defaults } = options;
+	return { stream(request) {
+		const normalized = normalizeRequest(request, {
+			model,
+			defaults
+		});
+		return adapter.stream(normalized);
+	} };
+}
+//#endregion
+//#region src/core/event-factory.ts
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createEventFactory(state) {
+	let seq = 0;
+	const warnings = [];
+	function next() {
+		return seq++;
+	}
+	function base() {
+		return {
+			responseId: state.responseId,
+			sequence: next(),
+			timestamp: timestamp(),
+			backend: { ...state.backend }
+		};
+	}
+	return {
+		responseStarted(model) {
+			return {
+				...base(),
+				type: "response.started",
+				model
+			};
+		},
+		responseWarning(message, code) {
+			warnings.push(message);
+			return {
+				...base(),
+				type: "response.warning",
+				message,
+				code
+			};
+		},
+		responseAuxiliary(data) {
+			return {
+				...base(),
+				type: "response.auxiliary",
+				...data
+			};
+		},
+		responseCompleted(response) {
+			return {
+				...base(),
+				type: "response.completed",
+				response
+			};
+		},
+		messageStarted(id) {
+			return {
+				...base(),
+				type: "message.started",
+				item: {
+					id,
+					role: "assistant"
+				}
+			};
+		},
+		messageDelta(itemId, text) {
+			return {
+				...base(),
+				type: "message.delta",
+				itemId,
+				delta: {
+					type: "text",
+					text
+				}
+			};
+		},
+		messageCompleted(item) {
+			return {
+				...base(),
+				type: "message.completed",
+				item
+			};
+		},
+		reasoningStarted(id, visibility) {
+			return {
+				...base(),
+				type: "reasoning.started",
+				item: {
+					id,
+					visibility
+				}
+			};
+		},
+		reasoningDelta(itemId, delta) {
+			return {
+				...base(),
+				type: "reasoning.delta",
+				itemId,
+				delta
+			};
+		},
+		reasoningCompleted(item) {
+			return {
+				...base(),
+				type: "reasoning.completed",
+				item
+			};
+		},
+		toolCallStarted(id, name) {
+			return {
+				...base(),
+				type: "tool_call.started",
+				item: {
+					id,
+					name
+				}
+			};
+		},
+		toolCallDelta(itemId, delta) {
+			return {
+				...base(),
+				type: "tool_call.delta",
+				itemId,
+				delta
+			};
+		},
+		toolCallCompleted(item) {
+			return {
+				...base(),
+				type: "tool_call.completed",
+				item
+			};
+		},
+		/** 返回当前已发出的 sequence 计数（用于断言） */
+		get sequence() {
+			return seq;
+		},
+		/** 返回当前已记录的 warning 副本。 */
+		get warnings() {
+			return [...warnings];
+		}
+	};
+}
+//#endregion
+//#region src/core/aggregator.ts
+function createInitialState() {
+	return {
+		pendingMessages: /* @__PURE__ */ new Map(),
+		pendingReasonings: /* @__PURE__ */ new Map(),
+		pendingToolCalls: /* @__PURE__ */ new Map(),
+		outputOrder: [],
+		completedMessages: /* @__PURE__ */ new Map(),
+		completedReasonings: /* @__PURE__ */ new Map(),
+		completedToolCalls: /* @__PURE__ */ new Map(),
+		auxiliary: {},
+		warnings: []
+	};
+}
+function handleResponseStarted(state, event) {
+	state.responseId = event.responseId;
+	state.model = event.model;
+	state.backendInfo = event.backend;
+}
+function handleResponseWarning(state, event) {
+	pushWarnings(state, [event.message]);
+}
+function handleResponseAuxiliary(state, event) {
+	if (event.usage) state.usage = {
+		...state.usage,
+		...event.usage
+	};
+	if (event.billing) state.billing = {
+		...state.billing,
+		...event.billing
+	};
+	if (event.auxiliary) state.auxiliary = mergeAuxiliary$1(state.auxiliary, event.auxiliary);
+}
+function handleMessageStarted(state, event) {
+	state.pendingMessages.set(event.item.id, {
+		role: event.item.role,
+		texts: []
+	});
+}
+function handleMessageDelta(state, event) {
+	const pending = state.pendingMessages.get(event.itemId);
+	if (pending) pending.texts.push(event.delta.text);
+}
+function handleMessageCompleted(state, event) {
+	const item = event.item;
+	const itemId = item.id ?? `msg-${state.outputOrder.length}`;
+	state.completedMessages.set(itemId, item);
+	state.outputOrder.push(itemId);
+	state.pendingMessages.delete(itemId);
+}
+function handleReasoningStarted(state, event) {
+	state.pendingReasonings.set(event.item.id, {
+		visibility: event.item.visibility,
+		blocks: []
+	});
+}
+function handleReasoningDelta(state, event) {
+	const pending = state.pendingReasonings.get(event.itemId);
+	if (pending) pending.blocks.push(event.delta);
+}
+function handleReasoningCompleted(state, event) {
+	const item = event.item;
+	const stableId = item.id ?? `reason-${state.outputOrder.length}-${Date.now()}`;
+	state.completedReasonings.set(stableId, item);
+	state.outputOrder.push(stableId);
+	state.pendingReasonings.delete(item.id ?? "");
+}
+function handleToolCallStarted(state, event) {
+	state.pendingToolCalls.set(event.item.id, {
+		name: event.item.name,
+		argsParts: []
+	});
+}
+function handleToolCallDelta(state, event) {
+	const pending = state.pendingToolCalls.get(event.itemId);
+	if (pending && event.delta.argumentsText) pending.argsParts.push(event.delta.argumentsText);
+}
+function handleToolCallCompleted(state, event) {
+	const item = event.item;
+	state.completedToolCalls.set(item.id, item);
+	state.outputOrder.push(item.id);
+	state.pendingToolCalls.delete(item.id);
+}
+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 = {
+		...state.usage,
+		...event.response.usage
+	};
+	if (event.response.billing) state.billing = {
+		...state.billing,
+		...event.response.billing
+	};
+	if (event.response.auxiliary) state.auxiliary = mergeAuxiliary$1(state.auxiliary, event.response.auxiliary);
+	if (event.response.warnings) pushWarnings(state, event.response.warnings);
+}
+function buildResponse(state) {
+	const output = [];
+	for (const id of state.outputOrder) {
+		const msg = state.completedMessages.get(id);
+		if (msg) {
+			output.push(msg);
+			continue;
+		}
+		const reason = state.completedReasonings.get(id);
+		if (reason) {
+			output.push(reason);
+			continue;
+		}
+		const tc = state.completedToolCalls.get(id);
+		if (tc) {
+			output.push(tc);
+			continue;
+		}
+	}
+	const text = output.filter((item) => item.type === "message").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("");
+	const toolCalls = output.filter((item) => item.type === "tool_call");
+	const backendFromResponse = state.backendFromAdapter;
+	const backend = {
+		adapter: backendFromResponse?.adapter ?? state.backendInfo?.kind ?? "unknown",
+		isSyntheticStream: backendFromResponse?.isSyntheticStream ?? state.backendInfo?.isSynthetic ?? false,
+		requestId: backendFromResponse?.requestId ?? state.responseId,
+		rawResponseId: backendFromResponse?.rawResponseId,
+		metadataSources: backendFromResponse?.metadataSources,
+		warnings: backendFromResponse?.warnings
+	};
+	return {
+		id: state.responseIdFromAdapter ?? state.responseId,
+		output,
+		replay: state.replayFromAdapter ?? [],
+		text,
+		toolCalls,
+		stopReason: state.stopReasonFromAdapter,
+		usage: state.usage,
+		billing: state.billing,
+		auxiliary: state.auxiliary,
+		warnings: state.warnings.length > 0 ? state.warnings : void 0,
+		backend
+	};
+}
+/**
+* 将事件数组聚合为 AIResponse。
+* 适用于测试和离线处理场景。
+*/
+function aggregateEvents(events) {
+	const state = createInitialState();
+	for (const event of events) switch (event.type) {
+		case "response.started":
+			handleResponseStarted(state, event);
+			break;
+		case "response.warning":
+			handleResponseWarning(state, event);
+			break;
+		case "response.auxiliary":
+			handleResponseAuxiliary(state, event);
+			break;
+		case "message.started":
+			handleMessageStarted(state, event);
+			break;
+		case "message.delta":
+			handleMessageDelta(state, event);
+			break;
+		case "message.completed":
+			handleMessageCompleted(state, event);
+			break;
+		case "reasoning.started":
+			handleReasoningStarted(state, event);
+			break;
+		case "reasoning.delta":
+			handleReasoningDelta(state, event);
+			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;
+		case "response.completed":
+			handleResponseCompleted(state, event);
+			break;
+	}
+	const lastEvent = events[events.length - 1];
+	if (!lastEvent || lastEvent.type !== "response.completed") throw new Error("Stream must end with response.completed event to produce a valid AIResponse");
+	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.warnings.includes(warning)) state.warnings.push(warning);
+}
+//#endregion
+//#region src/core/collect-stream.ts
+async function collectStream(stream) {
+	const events = [];
+	for await (const event of stream) events.push(event);
+	return aggregateEvents(events);
+}
+//#endregion
+//#region src/helpers/mapping.ts
+/**
+* 常见 provider stop_reason / finish_reason 到 canonical StopReason 的映射表。
+* adapter 可先查此表，未覆盖时走 fallback 规则。
+*/
+const STOP_REASON_MAP = {
+	stop: "end_turn",
+	length: "max_output_tokens",
+	content_filter: "content_filter",
+	tool_calls: "tool_call",
+	end_turn: "end_turn",
+	max_tokens: "max_output_tokens",
+	tool_use: "tool_call",
+	error: "error"
+};
+function mapStopReason(providerReason) {
+	return STOP_REASON_MAP[providerReason] ?? "unknown";
+}
+function mapReasoningVisibility(hasThinking, hasRedacted) {
+	if (hasRedacted) return "redacted";
+	if (hasThinking) return "full";
+	return "opaque";
+}
+function textBlock(text) {
+	return {
+		type: "text",
+		text
+	};
+}
+function jsonBlock(json) {
+	return {
+		type: "json",
+		json
+	};
+}
+function imageBlock(imageUrl) {
+	return {
+		type: "image",
+		imageUrl
+	};
+}
+function opaqueBlock(payload) {
+	return {
+		type: "opaque",
+		payload
+	};
+}
+function messageItem(content, overrides) {
+	return {
+		type: "message",
+		role: "assistant",
+		...overrides,
+		content
+	};
+}
+function reasoningItem(content, visibility = "full", id) {
+	return {
+		type: "reasoning",
+		id,
+		visibility,
+		content
+	};
+}
+function toolCallItem(id, name, argumentsText, argumentsJson) {
+	return {
+		type: "tool_call",
+		id,
+		name,
+		argumentsText,
+		argumentsJson
+	};
+}
+function toolResultItem(callId, toolName, outcome, content) {
+	return {
+		type: "tool_result",
+		callId,
+		toolName,
+		outcome,
+		content
+	};
+}
+function opaqueItem(source, purpose, payload, id) {
+	return {
+		type: "opaque",
+		id,
+		source,
+		purpose,
+		payload
+	};
+}
+/**
+* 从 output items 构建标准 replay items。
+* 简单场景下 replay 与 output 一致。
+* 复杂场景（需要 opaque continuation）由 adapter 自行扩展。
+*/
+function replayFromOutput(output) {
+	return output.map((item) => {
+		switch (item.type) {
+			case "message":
+			case "reasoning":
+			case "tool_call": return item;
+			case "opaque": return item;
+		}
+	});
+}
+/**
+* 将单个 ContentBlock 转为纯文本。
+* text 块直接返回文本，json 块序列化，其余返回空串。
+*/
+function blockToText(b) {
+	if (b.type === "text") return b.text;
+	if (b.type === "json") return JSON.stringify(b.json);
+	return "";
+}
+/**
+* 将 ContentBlock 数组拼接为纯文本，块间以换行符分隔。
+*/
+function contentBlocksToText(blocks) {
+	return blocks.map(blockToText).join("\n");
+}
+/**
+* 将 instructions（string | ContentBlock[]）归一化为纯文本。
+*/
+function instructionsToText(instructions) {
+	return typeof instructions === "string" ? instructions : contentBlocksToText(instructions);
+}
+/**
+* 从 OutputItem 数组中提取所有 message 类型 item 的文本内容。
+*/
+function extractText(output) {
+	return output.filter((item) => item.type === "message").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+//#endregion
+//#region src/helpers/auxiliary-collector.ts
+var AuxiliaryCollector = class {
+	usage = {};
+	usageSource;
+	billing;
+	billingSource;
+	providerMetadata = {};
+	providerUsage;
+	providerBilling;
+	warnings = [];
+	lookupAttempted = false;
+	/**
+	* 记录 usage 信息。
+	* 后调用的覆盖先调用的（优先级由调用方控制）。
+	*/
+	recordUsage(usage, source, raw) {
+		this.usage = {
+			...this.usage,
+			...usage
+		};
+		this.usageSource = source;
+		if (raw !== void 0) this.providerUsage = raw;
+		return this;
+	}
+	/**
+	* 记录 billing 信息。
+	* 后调用的覆盖先调用的。
+	*/
+	recordBilling(billing, source, raw) {
+		this.billing = {
+			...this.billing,
+			...billing
+		};
+		this.billingSource = source;
+		if (raw !== void 0) this.providerBilling = raw;
+		return this;
+	}
+	/**
+	* 记录 provider 元数据（非 canonical 的 key-value 信息）。
+	*/
+	recordMetadata(metadata) {
+		this.providerMetadata = {
+			...this.providerMetadata,
+			...metadata
+		};
+		return this;
+	}
+	/**
+	* 记录一条 warning。
+	*/
+	recordWarning(message) {
+		this.warnings.push(message);
+		return this;
+	}
+	/**
+	* 执行一次有界 follow-up lookup。
+	* 最多调用一次；后续调用被忽略。
+	* lookup 失败（抛错）仅记录 warning，不传播异常。
+	*/
+	async tryLookup(lookupFn, timeoutMs = 5e3) {
+		if (this.lookupAttempted) return;
+		this.lookupAttempted = true;
+		try {
+			const result = await withTimeout(lookupFn(), timeoutMs);
+			if (result.usage) this.recordUsage(result.usage, "lookup", result.usage);
+			if (result.billing) {
+				const bill = {
+					...result.billing,
+					source: result.billing?.source ?? "lookup"
+				};
+				this.recordBilling(bill, "lookup", result.billing);
+			}
+			if (result.providerMetadata) this.recordMetadata(result.providerMetadata);
+		} catch (err) {
+			this.recordWarning(`Auxiliary lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	/**
+	* 构建最终的 usage / billing / auxiliary。
+	* 所有字段均为可选的 — 拿不到就不给。
+	*/
+	build() {
+		const result = {};
+		if (Object.keys(this.usage).length > 0) result.usage = this.usage;
+		if (this.billing) result.billing = this.billing;
+		const aux = {};
+		if (this.usageSource) aux.usageSource = this.usageSource;
+		if (this.billingSource) aux.billingSource = this.billingSource;
+		if (this.providerUsage !== void 0) aux.providerUsage = this.providerUsage;
+		if (this.providerBilling !== void 0) aux.providerBilling = this.providerBilling;
+		if (Object.keys(this.providerMetadata).length > 0) aux.providerMetadata = this.providerMetadata;
+		if (Object.keys(aux).length > 0) result.auxiliary = aux;
+		if (this.warnings.length > 0) result.warnings = [...this.warnings];
+		return result;
+	}
+	/**
+	* 已使用的来源列表（用于 debugging）。
+	*/
+	get sources() {
+		return {
+			usage: this.usageSource,
+			billing: this.billingSource
+		};
+	}
+};
+function withTimeout(promise, ms) {
+	return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Lookup timed out after ${ms}ms`)), ms))]);
+}
+//#endregion
+//#region src/helpers/adapter-auxiliary.ts
+var AdapterAuxiliaryState = class {
+	request;
+	capabilities;
+	collector = new AuxiliaryCollector();
+	metadataSources = /* @__PURE__ */ new Set();
+	constructor(request, capabilities) {
+		this.request = request;
+		this.capabilities = capabilities;
+	}
+	recordUsage(usage, source, raw) {
+		if (this.request.include?.usage === "off" || isEmptyRecord(usage)) return;
+		this.collector.recordUsage(usage, source, raw);
+	}
+	recordBilling(billing, source, raw) {
+		if (this.request.include?.billing === "off" || isEmptyRecord(billing)) return;
+		this.collector.recordBilling(billing, source, raw);
+	}
+	recordProviderMetadata(source, metadata) {
+		if (this.request.include?.providerMetadata === "off" || !metadata || isEmptyRecord(metadata)) return;
+		this.collector.recordMetadata(metadata);
+		this.metadataSources.add(source);
+	}
+	async finalize(factory, options = {}) {
+		if (options.lookup && this.shouldAttemptLookup()) await this.collector.tryLookup(options.lookup, options.lookupTimeoutMs);
+		if (this.request.include?.billing !== "off" && options.postprocessBilling) {
+			const snapshot = this.collector.build();
+			if (!snapshot.billing) {
+				const derived = await options.postprocessBilling({
+					request: this.request,
+					usage: snapshot.usage,
+					billing: snapshot.billing,
+					auxiliary: snapshot.auxiliary,
+					capabilities: this.capabilities
+				});
+				if (derived && !isEmptyRecord(derived)) this.collector.recordBilling({
+					...derived,
+					isEstimated: derived.isEstimated ?? true,
+					source: derived.source ?? "derived"
+				}, options.postprocessBillingSource ?? "derived", derived);
+			}
+		}
+		const built = this.collector.build();
+		const events = [];
+		if (built.usage || built.billing || built.auxiliary) events.push(factory.responseAuxiliary({
+			usage: built.usage,
+			billing: built.billing,
+			auxiliary: built.auxiliary
+		}));
+		if (this.request.include?.usage !== "off" && !built.usage) events.push(factory.responseWarning("Usage information was not provided by the provider", WarningCode.USAGE_MISSING));
+		if (this.request.include?.billing !== "off") {
+			if (!built.billing) events.push(factory.responseWarning("Billing information was not provided by the provider", WarningCode.BILLING_MISSING));
+			else if (built.billing.isEstimated) events.push(factory.responseWarning("Billing amount is an estimate", WarningCode.BILLING_ESTIMATED));
+		}
+		return {
+			events,
+			usage: built.usage,
+			billing: built.billing,
+			auxiliary: built.auxiliary,
+			warnings: built.warnings,
+			metadataSources: this.metadataSources.size > 0 ? [...this.metadataSources] : void 0
+		};
+	}
+	shouldAttemptLookup() {
+		if (this.request.include?.usage === "off" && this.request.include?.billing === "off" && this.request.include?.providerMetadata === "off") return false;
+		const snapshot = this.collector.build();
+		return this.request.include?.usage !== "off" && !snapshot.usage || this.request.include?.billing !== "off" && !snapshot.billing || this.request.include?.providerMetadata !== "off" && !snapshot.auxiliary?.providerMetadata;
+	}
+};
+function emitMalformedStreamWarning(factory, options) {
+	if (options.count < 1) return void 0;
+	return factory.responseWarning(`Skipped ${options.count} malformed ${options.providerLabel} ${options.transportLabel}`, "STREAM_ERROR");
+}
+function metadataSourceList(...groups) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const group of groups) {
+		if (!group) continue;
+		for (const source of group) sources.add(source);
+	}
+	return sources.size > 0 ? [...sources] : void 0;
+}
+function isEmptyRecord(value) {
+	return Object.keys(value).length === 0;
+}
+//#endregion
+//#region src/helpers/adapter-base.ts
+var AdapterBase = class {
+	/**
+	* stream 模板方法：
+	* 1. 创建事件工厂，发射 response.started
+	* 2. 构建 provider 请求
+	* 3. 委托 runStream 发射全部流事件（含 response.completed）
+	*/
+	async *stream(request) {
+		const factory = createEventFactory({
+			responseId: request.requestId,
+			backend: {
+				kind: this.kind,
+				isSynthetic: !this.capabilities.nativeStreaming
+			}
+		});
+		yield factory.responseStarted(request.model);
+		try {
+			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));
+		}
+	}
+	/**
+	* 从 StreamResult 构建完整 AIResponse。
+	* 子类可在返回前自定义覆盖。
+	*/
+	buildResponse(request, result, _factory) {
+		const text = this.extractText(result.output);
+		const warnings = mergeWarnings(result.warnings, _factory.warnings);
+		const auxiliary = mergeAuxiliary(result.auxiliary, result.providerMetadata ? { providerMetadata: result.providerMetadata } : void 0);
+		return {
+			id: request.requestId,
+			output: result.output,
+			replay: result.replay,
+			text,
+			toolCalls: result.output.filter((item) => item.type === "tool_call"),
+			stopReason: result.stopReason,
+			usage: result.usage,
+			billing: result.billing,
+			auxiliary,
+			warnings,
+			backend: {
+				requestId: request.requestId,
+				rawResponseId: result.rawResponseId,
+				adapter: this.kind,
+				isSyntheticStream: !this.capabilities.nativeStreaming,
+				metadataSources: result.metadataSources,
+				warnings
+			}
+		};
+	}
+	/** 从 output items 中提取文本内容。 */
+	extractText(output) {
+		return extractText(output);
+	}
+	createAuxiliaryState(request) {
+		return new AdapterAuxiliaryState(request, this.capabilities);
+	}
+};
+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) {
+		if (!group) continue;
+		for (const warning of group) if (!merged.includes(warning)) merged.push(warning);
+	}
+	return merged.length > 0 ? merged : void 0;
+}
+//#endregion
+//#region src/helpers/sse-parser.ts
+/**
+* 将 SSE 文本块解析为事件数组。
+* 累积事件行直到遇到空行，支持 [DONE] 标记。
+* 返回已解析的事件和未处理的剩余 buffer（用于增量解析）。
+*
+* 关键行为：
+* - 只解析完整的 event（以空行结尾）
+* - 未完成的行保留在 rest 中，等待下次 chunk 补全
+* - 支持跨 chunk 的 event 分片
+*/
+function parseSSEEvents(chunk) {
+	const events = [];
+	let eventType = "";
+	let dataLines = [];
+	let consumedUntil = 0;
+	let cursor = 0;
+	let malformedEvents = 0;
+	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;
+	}
+	return {
+		events,
+		rest: chunk.slice(consumedUntil),
+		malformedEvents
+	};
+}
+//#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。
+*/
+function ensureResponsesTextBlocks(blocks, field) {
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		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;
+	});
+}
+function instructionsToResponsesText(instructions) {
+	return typeof instructions === "string" ? instructions : contentBlocksToText(ensureResponsesTextBlocks(instructions, "instructions"));
+}
+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 parseSSE(chunk) {
+	const result = parseSSEEvents(chunk);
+	return {
+		events: result.events,
+		rest: result.rest,
+		malformedEvents: result.malformedEvents
+	};
+}
+function isReplayCanonicalInput(item) {
+	return item.type === "message" && item.role === "assistant" || item.type === "reasoning" || item.type === "function_call";
+}
+function rollbackTrailingReplayCanonicalItems(input) {
+	while (input.length > 0) {
+		const last = input[input.length - 1];
+		if (!last || !isReplayCanonicalInput(last)) break;
+		input.pop();
+	}
+}
+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 = CAPABILITY_MATRIX.responses;
+	apiKey;
+	baseUrl;
+	fetchFn;
+	constructor(options) {
+		super();
+		this.apiKey = options.apiKey;
+		this.baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+		this.fetchFn = options.fetch ?? globalThis.fetch;
+	}
+	buildRequest(request) {
+		const input = [];
+		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);
+					input.push({
+						type: "message",
+						role: item.role,
+						content: blocks
+					});
+				} else input.push({
+					type: "message",
+					role: item.role,
+					content: contentBlocksToText(ensureResponsesTextBlocks(item.content, `input message (${item.role}) content`))
+				});
+				break;
+			case "reasoning": {
+				const blocks = ensureResponsesReasoningBlocks(item.content, "reasoning content").map((b) => ({
+					type: "reasoning",
+					text: b.text
+				}));
+				input.push({
+					type: "reasoning",
+					content: blocks
+				});
+				break;
+			}
+			case "tool_call":
+				input.push({
+					type: "function_call",
+					id: item.id,
+					name: item.name,
+					arguments: item.argumentsText
+				});
+				break;
+			case "tool_result": {
+				assertResponsesToolResultOutcome(item.outcome);
+				const output = ensureResponsesTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
+				input.push({
+					type: "function_call_output",
+					call_id: item.callId,
+					output
+				});
+				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
+						});
+					}
+				}
+				break;
+		}
+		const body = {
+			model: request.model,
+			input,
+			stream: true
+		};
+		if (request.instructions) body.instructions = instructionsToResponsesText(request.instructions);
+		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
+			type: "function",
+			name: t.name,
+			description: t.description,
+			input_schema: t.inputSchema
+		}));
+		if (request.toolChoice) {
+			if (request.toolChoice === "auto") body.tool_choice = "auto";
+			else if (request.toolChoice === "none") body.tool_choice = "none";
+			else if (request.toolChoice.type === "tool") body.tool_choice = {
+				type: "function",
+				name: request.toolChoice.name
+			};
+		}
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		if (request.maxOutputTokens !== void 0) body.max_output_tokens = request.maxOutputTokens;
+		if (request.metadata) body.metadata = request.metadata;
+		return body;
+	}
+	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)
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "unknown error");
+			throw new Error(`Responses API error ${response.status}: ${errorText}`);
+		}
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Response body is not readable");
+		const output = [];
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let completedResponse;
+		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 malformedWarning = emitMalformedStreamWarning(factory, {
+					count: malformedEvents,
+					providerLabel: "Responses",
+					transportLabel: "SSE event(s)"
+				});
+				if (malformedWarning) yield malformedWarning;
+				for (const sseEvent of events) {
+					if (sseEvent.type === "error") {
+						yield factory.responseWarning(sseEvent.data.message, sseEvent.data.code);
+						continue;
+					}
+					if (sseEvent.type === "response.output_item.added") {
+						const item = sseEvent.data.item;
+						switch (item.type) {
+							case "message":
+								yield factory.messageStarted(item.id);
+								break;
+							case "reasoning":
+								yield factory.reasoningStarted(item.id, "full");
+								break;
+							case "function_call":
+								yield factory.toolCallStarted(item.id, item.name ?? "unknown");
+								break;
+						}
+						continue;
+					}
+					if (sseEvent.type === "response.output_text.delta") {
+						yield factory.messageDelta(sseEvent.data.item_id, sseEvent.data.delta);
+						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 }));
+						continue;
+					}
+					if (sseEvent.type === "response.reasoning.delta") {
+						yield factory.reasoningDelta(sseEvent.data.item_id, textBlock(sseEvent.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));
+						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 });
+						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);
+						output.push(tcItem);
+						continue;
+					}
+					if (sseEvent.type === "response.completed") completedResponse = sseEvent.data.response;
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (buffer.trim().length > 0) yield factory.responseWarning("Stream ended with an incomplete Responses SSE frame", "STREAM_ERROR");
+		let rawResponseId;
+		if (completedResponse) {
+			rawResponseId = completedResponse.id;
+			if (completedResponse.usage) auxiliary.recordUsage({
+				inputTokens: completedResponse.usage.input_tokens,
+				outputTokens: completedResponse.usage.output_tokens,
+				totalTokens: completedResponse.usage.total_tokens
+			}, "final", completedResponse.usage);
+		}
+		const replay = [...replayFromOutput(output)];
+		if (completedResponse?.id) replay.push(opaqueItem("responses", "replay", { id: completedResponse.id }));
+		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));
+	}
+	inferStopReason(response) {
+		const output = response.output;
+		if (!output || output.length === 0) return "unknown";
+		if (output.some((item) => item.type === "function_call")) return "tool_call";
+		if (output[output.length - 1]?.status === "incomplete") return "max_output_tokens";
+		return "end_turn";
+	}
+};
+//#endregion
+//#region src/adapters/messages.ts
+/**
+* Messages Adapter
+*
+* 接入 Anthropic Messages API (messages 端点)。
+* 支持：
+* - 文本消息流 (text content block)
+* - 思维链流 (thinking content block)
+* - 工具调用流 (tool_use content block)
+* - 高保真 replay（含 opaque continuation）
+* - 能力降级 warning
+*/
+function ensureMessagesTextBlocks(blocks, field) {
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		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
+	};
+}
+function rollbackTrailingAssistantMessages$2(messages) {
+	while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
+}
+function parseToolUseInput(input) {
+	try {
+		const parsed = JSON.parse(input);
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function canonicalToMessagesBlock(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(`messages does not support content block type "${b.type}" in canonical mapping`, "UNSUPPORTED_CONTENT_BLOCK");
+}
+function pickProviderHeaders(headers) {
+	const metadata = {};
+	headers.forEach((value, key) => {
+		const normalizedKey = key.toLowerCase();
+		if (normalizedKey === "request-id" || normalizedKey === "x-request-id" || normalizedKey === "anthropic-organization-id" || normalizedKey === "anthropic-beta" || normalizedKey === "retry-after" || normalizedKey.startsWith("anthropic-ratelimit-")) metadata[normalizedKey] = value;
+	});
+	return metadata;
+}
+function buildStreamMetadata(options) {
+	const { apiVersion, message, stopReason, stopSequence } = options;
+	const metadata = { apiVersion };
+	if (message) metadata.message = {
+		id: message.id,
+		type: message.type,
+		role: message.role,
+		model: message.model
+	};
+	if (stopReason !== void 0 || stopSequence !== void 0) metadata.stop = {
+		reason: stopReason,
+		sequence: stopSequence
+	};
+	return metadata;
+}
+var MessagesAdapter = class extends AdapterBase {
+	kind = "messages";
+	capabilities = CAPABILITY_MATRIX.messages;
+	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;
+		if (request.instructions) systemPrompt = instructionsToMessagesText(request.instructions);
+		for (const item of request.input) switch (item.type) {
+			case "message": {
+				if (item.role === "system" || item.role === "developer") {
+					const text = contentBlocksToText(ensureMessagesTextBlocks(item.content, `input message (${item.role}) content`));
+					systemPrompt = systemPrompt ? `${systemPrompt}\n${text}` : text;
+					break;
+				}
+				const role = item.role === "user" ? "user" : "assistant";
+				const supportedContent = ensureMessagesTextBlocks(item.content, `input message (${item.role}) content`);
+				if (supportedContent.length === 1 && supportedContent[0]?.type === "text") messages.push({
+					role,
+					content: supportedContent[0].text
+				});
+				else messages.push({
+					role,
+					content: supportedContent.map(canonicalToMessagesBlock)
+				});
+				break;
+			}
+			case "tool_call": {
+				const lastMsg = messages[messages.length - 1];
+				const toolBlock = {
+					type: "tool_use",
+					id: item.id,
+					name: item.name,
+					input: item.argumentsJson ?? parseToolUseInput(item.argumentsText)
+				};
+				if (lastMsg && lastMsg.role === "assistant" && typeof lastMsg.content !== "string") lastMsg.content.push(toolBlock);
+				else messages.push({
+					role: "assistant",
+					content: [toolBlock]
+				});
+				break;
+			}
+			case "tool_result": {
+				assertMessagesToolResultOutcome(item.outcome);
+				const content = ensureMessagesTextBlocks(item.content, `tool_result ${item.callId} content`).map(blockToText).join("\n");
+				const block = {
+					type: "tool_result",
+					tool_use_id: item.callId,
+					content,
+					is_error: item.outcome === "error"
+				};
+				messages.push({
+					role: "user",
+					content: [block]
+				});
+				break;
+			}
+			case "reasoning": {
+				const block = {
+					type: "thinking",
+					thinking: contentBlocksToText(ensureMessagesReasoningBlocks(item.content, "reasoning content"))
+				};
+				const lastMsg = messages[messages.length - 1];
+				if (lastMsg && lastMsg.role === "assistant" && typeof lastMsg.content !== "string") lastMsg.content.push(block);
+				else messages.push({
+					role: "assistant",
+					content: [block]
+				});
+				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
+							});
+						}
+					}
+				}
+				break;
+		}
+		const body = {
+			model: request.model,
+			max_tokens: request.maxOutputTokens ?? 4096,
+			messages,
+			stream: true
+		};
+		if (systemPrompt) body.system = systemPrompt;
+		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
+			name: t.name,
+			description: t.description,
+			input_schema: t.inputSchema
+		}));
+		if (request.toolChoice) {
+			if (request.toolChoice === "auto") body.tool_choice = { type: "auto" };
+			else if (request.toolChoice === "none") body.tool_choice = { type: "none" };
+			else if (request.toolChoice.type === "tool") body.tool_choice = {
+				type: "tool",
+				name: request.toolChoice.name
+			};
+		}
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		return body;
+	}
+	async *runStream(providerRequest, factory, request) {
+		this.warningAccumulator = [];
+		const auxiliary = this.createAuxiliaryState(request);
+		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)
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "unknown error");
+			throw new Error(`Messages API error ${response.status}: ${errorText}`);
+		}
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Response body is not readable");
+		const output = [];
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let messageResponse;
+		let currentContentBlockIndex = -1;
+		let currentItemType = null;
+		let currentItemId = "";
+		let currentToolName = "";
+		let currentArgsText = "";
+		let currentThinkingVisibility = "full";
+		let hasStreamedReasoning = false;
+		const rawReplayContent = [];
+		let textBuffer = "";
+		let thinkingBuffer = "";
+		let argsBuffer = "";
+		let stopReason;
+		let stopSequence;
+		let rawResponseId;
+		if (request.include?.providerMetadata !== "off") {
+			const headerMetadata = pickProviderHeaders(response.headers);
+			auxiliary.recordProviderMetadata("header", Object.keys(headerMetadata).length > 0 ? { headers: headerMetadata } : void 0);
+		}
+		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 malformedWarning = emitMalformedStreamWarning(factory, {
+					count: malformedEvents,
+					providerLabel: "Messages",
+					transportLabel: "SSE event(s)"
+				});
+				if (malformedWarning) yield malformedWarning;
+				for (const sseEvent of events) switch (sseEvent.type) {
+					case "ping": continue;
+					case "error": {
+						const err = sseEvent.data.error;
+						yield factory.responseWarning(err.message, err.type);
+						this.warn(err.message, err.type);
+						continue;
+					}
+					case "message_start":
+						messageResponse = sseEvent.data.message;
+						rawResponseId = messageResponse.id;
+						if (messageResponse.content.some((b) => b.type === "thinking" || b.type === "redacted_thinking")) hasStreamedReasoning = true;
+						continue;
+					case "content_block_start": {
+						const block = sseEvent.data.content_block;
+						currentContentBlockIndex = sseEvent.data.index;
+						switch (block.type) {
+							case "text":
+								currentItemType = "message";
+								currentItemId = `msg-${block.type}-${currentContentBlockIndex}`;
+								textBuffer = "";
+								yield factory.messageStarted(currentItemId);
+								break;
+							case "thinking":
+								hasStreamedReasoning = true;
+								currentItemType = "reasoning";
+								currentItemId = `reason-${currentContentBlockIndex}`;
+								currentThinkingVisibility = "full";
+								thinkingBuffer = "";
+								yield factory.reasoningStarted(currentItemId, "full");
+								break;
+							case "redacted_thinking": {
+								hasStreamedReasoning = true;
+								currentItemType = "reasoning";
+								currentItemId = `reason-redacted-${currentContentBlockIndex}`;
+								currentThinkingVisibility = "redacted";
+								const data = block.data;
+								yield factory.reasoningStarted(currentItemId, "redacted");
+								yield factory.reasoningDelta(currentItemId, textBlock(data));
+								const redactedItem = reasoningItem([textBlock(data)], "redacted", currentItemId);
+								yield factory.reasoningCompleted(redactedItem);
+								output.push(redactedItem);
+								rawReplayContent.push({
+									type: "redacted_thinking",
+									data
+								});
+								currentItemType = null;
+								break;
+							}
+							case "tool_use": {
+								const tuBlock = block;
+								currentItemType = "tool_call";
+								currentItemId = tuBlock.id;
+								currentToolName = tuBlock.name;
+								currentArgsText = "";
+								argsBuffer = "";
+								yield factory.toolCallStarted(currentItemId, currentToolName);
+								break;
+							}
+						}
+						continue;
+					}
+					case "content_block_delta": {
+						const delta = sseEvent.data.delta;
+						switch (delta.type) {
+							case "text_delta":
+								if (currentItemType === "message" && currentItemId) {
+									const txt = delta.text;
+									textBuffer += txt;
+									yield factory.messageDelta(currentItemId, txt);
+								}
+								break;
+							case "thinking_delta":
+								if (currentItemType === "reasoning" && currentItemId) {
+									const txt = delta.thinking;
+									thinkingBuffer += txt;
+									yield factory.reasoningDelta(currentItemId, textBlock(txt));
+								}
+								break;
+							case "input_json_delta":
+								if (currentItemType === "tool_call" && currentItemId) {
+									const partial = delta.partial_json;
+									argsBuffer += partial;
+									yield factory.toolCallDelta(currentItemId, { argumentsText: partial });
+								}
+								break;
+						}
+						continue;
+					}
+					case "content_block_stop":
+						if (currentItemType === "message" && currentItemId) {
+							yield factory.messageCompleted(messageItem([textBlock(textBuffer)], { id: 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));
+							output.push(reasoningItem([textBlock(thinkingBuffer)], currentThinkingVisibility, currentItemId));
+							rawReplayContent.push({
+								type: "thinking",
+								thinking: thinkingBuffer
+							});
+						} else if (currentItemType === "tool_call" && currentItemId) {
+							const tcItem = toolCallItem(currentItemId, currentToolName, currentArgsText || argsBuffer);
+							yield factory.toolCallCompleted(tcItem);
+							output.push(tcItem);
+							rawReplayContent.push({
+								type: "tool_use",
+								id: currentItemId,
+								name: currentToolName,
+								input: parseToolUseInput(currentArgsText || argsBuffer)
+							});
+						}
+						currentItemType = null;
+						currentItemId = "";
+						continue;
+					case "message_delta": {
+						stopReason = sseEvent.data.delta.stop_reason;
+						stopSequence = sseEvent.data.delta.stop_sequence;
+						const u = sseEvent.data.usage;
+						if (u) auxiliary.recordUsage({
+							inputTokens: u.input_tokens,
+							outputTokens: u.output_tokens,
+							totalTokens: u.input_tokens + u.output_tokens
+						}, "stream", u);
+						continue;
+					}
+					case "message_stop": break;
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (buffer.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;
+			replay.push(opaqueItem("messages", "replay", {
+				replaceCanonical: true,
+				role: messageResponse.role,
+				content: replayContent,
+				messageId: messageResponse.id,
+				stopReason: stopReason ?? messageResponse.stop_reason
+			}));
+		}
+		if (request.include?.providerMetadata !== "off") auxiliary.recordProviderMetadata("stream", buildStreamMetadata({
+			apiVersion: this.apiVersion,
+			message: messageResponse,
+			stopReason,
+			stopSequence
+		}));
+		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));
+	}
+};
+//#endregion
+//#region src/adapters/chat-completions.ts
+/**
+* Chat Completions Adapter
+*
+* 接入 OpenAI Chat Completions API (chat/completions 端点)。
+* 弱能力兼容层：
+* - third-party reasoning 字段仅做 best-effort 提取
+* - 工具调用通常整块到达（非逐 token 流）
+* - 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++;
+		}
+	}
+	return {
+		chunks,
+		rest,
+		malformedEvents
+	};
+}
+function ensureTextCompatibleBlocks(blocks, field) {
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		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));
+}
+function extractReasoningText(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(extractReasoningText).join("");
+	if (value && typeof value === "object") {
+		const record = value;
+		for (const key of [
+			"text",
+			"content",
+			"reasoning",
+			"reasoning_content",
+			"thinking",
+			"value"
+		]) {
+			const nested = extractReasoningText(record[key]);
+			if (nested) return nested;
+		}
+	}
+	return "";
+}
+function extractReasoningDeltas(delta) {
+	const deltas = [];
+	for (const field of REASONING_FIELDS) {
+		const text = extractReasoningText(delta[field]);
+		if (text) deltas.push({
+			field,
+			text
+		});
+	}
+	return deltas;
+}
+function rollbackTrailingAssistantMessages$1(messages) {
+	while (messages.length > 0 && messages[messages.length - 1]?.role === "assistant") messages.pop();
+}
+function buildAssistantReplayMessage(params) {
+	const { content, reasoningByField, toolCalls } = params;
+	if (!content && reasoningByField.size === 0 && toolCalls.length === 0) return null;
+	const replayMessage = {
+		role: "assistant",
+		content: content || null
+	};
+	for (const [field, text] of reasoningByField) replayMessage[field] = text;
+	if (toolCalls.length > 0) replayMessage.tool_calls = toolCalls.map((toolCall) => ({
+		id: toolCall.id,
+		type: "function",
+		function: {
+			name: toolCall.name,
+			arguments: toolCall.args
+		}
+	}));
+	return replayMessage;
+}
+var ChatCompletionsAdapter = class extends AdapterBase {
+	kind = "chat-completions";
+	capabilities = {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: false,
+		toolCallStreaming: false,
+		hiddenReasoningReplay: "none",
+		replayFidelity: "low",
+		tools: true,
+		usage: "full",
+		billing: "derived",
+		providerMetadata: false
+	};
+	apiKey;
+	baseUrl;
+	fetchFn;
+	markReasoningCompatibility() {
+		this.capabilities.reasoningStreaming = true;
+		this.capabilities.hiddenReasoningReplay = "partial";
+		this.capabilities.replayFidelity = "medium";
+	}
+	constructor(options) {
+		super();
+		this.apiKey = options.apiKey;
+		this.baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+		this.fetchFn = options.fetch ?? globalThis.fetch;
+	}
+	buildRequest(request) {
+		const messages = [];
+		if (request.instructions) {
+			const content = typeof request.instructions === "string" ? request.instructions : contentBlocksToChatText(request.instructions, "instructions");
+			messages.push({
+				role: "system",
+				content
+			});
+		}
+		for (const item of request.input) switch (item.type) {
+			case "message": {
+				const role = item.role === "developer" ? "system" : item.role === "system" ? "system" : item.role === "user" ? "user" : "assistant";
+				const text = contentBlocksToChatText(item.content, `input message (${item.role}) content`);
+				messages.push({
+					role,
+					content: text || null
+				});
+				break;
+			}
+			case "tool_call": {
+				const lastAssistant = messages.length > 0 && messages[messages.length - 1]?.role === "assistant" ? messages[messages.length - 1] : null;
+				const tc = {
+					id: item.id,
+					type: "function",
+					function: {
+						name: item.name,
+						arguments: item.argumentsText
+					}
+				};
+				if (lastAssistant) lastAssistant.tool_calls = [...lastAssistant.tool_calls ?? [], tc];
+				else messages.push({
+					role: "assistant",
+					content: null,
+					tool_calls: [tc]
+				});
+				break;
+			}
+			case "tool_result":
+				assertChatToolResultOutcome(item.outcome);
+				messages.push({
+					role: "tool",
+					tool_call_id: item.callId,
+					name: item.toolName,
+					content: contentBlocksToChatText(item.content, `tool_result ${item.callId} content`)
+				});
+				break;
+			case "reasoning":
+				messages.push({
+					role: "assistant",
+					content: contentBlocksToChatText(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);
+				}
+				break;
+		}
+		const body = {
+			model: request.model,
+			messages,
+			stream: true
+		};
+		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
+			type: "function",
+			function: {
+				name: t.name,
+				description: t.description,
+				parameters: t.inputSchema
+			}
+		}));
+		if (request.toolChoice) {
+			if (request.toolChoice === "auto") body.tool_choice = "auto";
+			else if (request.toolChoice === "none") body.tool_choice = "none";
+			else if (request.toolChoice.type === "tool") body.tool_choice = {
+				type: "function",
+				function: { name: request.toolChoice.name }
+			};
+		}
+		if (request.temperature !== void 0) body.temperature = request.temperature;
+		if (request.maxOutputTokens !== void 0) body.max_tokens = request.maxOutputTokens;
+		if (request.metadata) body.metadata = request.metadata;
+		return body;
+	}
+	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)
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "unknown error");
+			throw new Error(`Chat Completions API error ${response.status}: ${errorText}`);
+		}
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Response body is not readable");
+		const output = [];
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let responseId;
+		let accumulatedContent = "";
+		let accumulatedReasoning = "";
+		let currentMessageId = "";
+		let currentReasoningId = "";
+		let hasMessageStarted = false;
+		let hasReasoningStarted = false;
+		let hasStreamedReasoning = false;
+		const pendingToolCalls = /* @__PURE__ */ new Map();
+		const reasoningByField = /* @__PURE__ */ new Map();
+		const finalizePendingTurn = () => {
+			const events = [];
+			const finalizedToolCalls = [...pendingToolCalls.values()];
+			const finalizedReasoningByField = new Map(reasoningByField);
+			if (hasReasoningStarted && accumulatedReasoning) {
+				const reasoning = reasoningItem([textBlock(accumulatedReasoning)], "full", currentReasoningId);
+				events.push(factory.reasoningCompleted(reasoning));
+				output.push(reasoning);
+			}
+			if (hasMessageStarted && accumulatedContent) {
+				const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
+				events.push(factory.messageCompleted(message));
+				output.push(message);
+			}
+			for (const pending of finalizedToolCalls) {
+				const toolCall = toolCallItem(pending.id, pending.name, pending.args);
+				events.push(factory.toolCallCompleted(toolCall));
+				output.push(toolCall);
+			}
+			const assistantReplayMessage = buildAssistantReplayMessage({
+				content: accumulatedContent,
+				reasoningByField: finalizedReasoningByField,
+				toolCalls: finalizedToolCalls
+			});
+			accumulatedContent = "";
+			accumulatedReasoning = "";
+			currentMessageId = "";
+			currentReasoningId = "";
+			hasMessageStarted = false;
+			hasReasoningStarted = false;
+			pendingToolCalls.clear();
+			reasoningByField.clear();
+			return {
+				events,
+				assistantReplayMessage
+			};
+		};
+		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 malformedWarning = emitMalformedStreamWarning(factory, {
+					count: malformedEvents,
+					providerLabel: "Chat Completions",
+					transportLabel: "SSE event(s)"
+				});
+				if (malformedWarning) yield malformedWarning;
+				for (const chunk of chunks) {
+					responseId = chunk.id;
+					if (chunk.usage) auxiliary.recordUsage({
+						inputTokens: chunk.usage.prompt_tokens,
+						outputTokens: chunk.usage.completion_tokens,
+						totalTokens: chunk.usage.total_tokens
+					}, "final", chunk.usage);
+					for (const choice of chunk.choices) {
+						if (choice.index !== 0) continue;
+						const delta = choice.delta;
+						const finishReason = choice.finish_reason;
+						const reasoningDeltas = extractReasoningDeltas(delta);
+						if (delta.role === "assistant" && typeof delta.content === "string" && !hasMessageStarted) {
+							currentMessageId = `msg-${chunk.id}`;
+							hasMessageStarted = true;
+							accumulatedContent = "";
+							yield factory.messageStarted(currentMessageId);
+						}
+						if (reasoningDeltas.length > 0) {
+							if (!hasReasoningStarted) {
+								currentReasoningId = `reason-${chunk.id}`;
+								hasReasoningStarted = true;
+								hasStreamedReasoning = true;
+								accumulatedReasoning = "";
+								yield factory.reasoningStarted(currentReasoningId, "full");
+							}
+							for (const reasoningDelta of reasoningDeltas) {
+								accumulatedReasoning += reasoningDelta.text;
+								reasoningByField.set(reasoningDelta.field, (reasoningByField.get(reasoningDelta.field) ?? "") + reasoningDelta.text);
+								yield factory.reasoningDelta(currentReasoningId, textBlock(reasoningDelta.text));
+							}
+						}
+						if (delta.content) {
+							if (!hasMessageStarted) {
+								currentMessageId = `msg-${chunk.id}`;
+								hasMessageStarted = true;
+								yield factory.messageStarted(currentMessageId);
+							}
+							accumulatedContent += delta.content;
+							yield factory.messageDelta(currentMessageId, 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 (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 (delta.function_call.name) {
+								const fcId = `fc-${chunk.id}-0`;
+								pendingToolCalls.set(0, {
+									id: fcId,
+									name: delta.function_call.name,
+									args: ""
+								});
+								yield factory.toolCallStarted(fcId, delta.function_call.name);
+							}
+							if (delta.function_call.arguments) {
+								const pending = pendingToolCalls.get(0);
+								if (pending) {
+									pending.args += delta.function_call.arguments;
+									yield factory.toolCallDelta(pending.id, { argumentsText: delta.function_call.arguments });
+								}
+							}
+						}
+						if (finishReason && finishReason !== null) {
+							const { events, assistantReplayMessage } = finalizePendingTurn();
+							for (const event of events) yield event;
+							if (hasStreamedReasoning) this.markReasoningCompatibility();
+							const stopReason = mapStopReason(finishReason);
+							const replay = [...replayFromOutput(output)];
+							if (assistantReplayMessage) replay.push(opaqueItem("chat.completions", "replay", {
+								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));
+						}
+					}
+				}
+			}
+		} 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) {
+			yield factory.responseWarning("Stream ended without a finish_reason", "INCOMPLETE_STREAM");
+			if (hasStreamedReasoning) this.markReasoningCompatibility();
+			const { events, assistantReplayMessage } = finalizePendingTurn();
+			for (const event of events) yield event;
+			const replay = [...replayFromOutput(output)];
+			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));
+		}
+	}
+};
+//#endregion
+//#region src/adapters/ollama.ts
+/**
+* Ollama Adapter
+*
+* 接入 Ollama 原生 Chat API (/api/chat)。
+* 与 Chat Completions 兼容层不同，此处直接使用 Ollama 的 NDJSON 流格式。
+*
+* 能力:
+* - 消息流（完整 content 逐块到达）
+* - 工具调用（整块到达，非逐 token）
+* - 用量信息（仅 prompt_eval_count / eval_count）
+*
+* 限制：
+* - 不流式输出 reasoning（Ollama 原生 API 无独立思考字段）
+* - tool_call 不支持逐 token 流式
+* - replay 保真度低（无 opaque continuation 机制）
+*/
+function ensureOllamaTextBlocks(blocks, field) {
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		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"));
+}
+function parseOllamaToolArguments(item) {
+	if (item.argumentsJson && typeof item.argumentsJson === "object" && item.argumentsJson !== null) return item.argumentsJson;
+	try {
+		const parsed = JSON.parse(item.argumentsText);
+		if (parsed && typeof parsed === "object") return parsed;
+	} 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) {
+	return Array.isArray(value) && value.every((entry) => {
+		if (!entry || typeof entry !== "object" || !("function" in entry)) return false;
+		const fn = entry.function;
+		return !!fn && typeof fn === "object" && "name" in fn && typeof fn.name === "string" && "arguments" in fn && typeof fn.arguments === "object" && fn.arguments !== null;
+	});
+}
+var OllamaAdapter = class extends AdapterBase {
+	kind = "ollama";
+	capabilities = {
+		nativeStreaming: true,
+		messageStreaming: true,
+		reasoningStreaming: false,
+		toolCallStreaming: false,
+		hiddenReasoningReplay: "none",
+		replayFidelity: "low",
+		tools: true,
+		usage: "partial",
+		billing: "none",
+		providerMetadata: false
+	};
+	baseUrl;
+	apiKey;
+	fetchFn;
+	constructor(options = {}) {
+		super();
+		this.baseUrl = options.baseUrl ?? "http://localhost:11434";
+		this.apiKey = options.apiKey;
+		this.fetchFn = options.fetch ?? globalThis.fetch;
+	}
+	buildRequest(request) {
+		if (request.toolChoice && request.toolChoice !== "auto") throw new AIRequestError("ollama does not support explicit toolChoice", "UNSUPPORTED_TOOL_CHOICE");
+		const messages = [];
+		if (request.instructions) messages.push({
+			role: "system",
+			content: instructionsToOllamaText(request.instructions)
+		});
+		for (const item of request.input) switch (item.type) {
+			case "message": {
+				const role = item.role === "developer" ? "system" : item.role === "system" ? "system" : item.role === "user" ? "user" : "assistant";
+				messages.push({
+					role,
+					content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `input message (${item.role}) content`))
+				});
+				break;
+			}
+			case "tool_call": {
+				const lastAssistant = messages.findLast((m) => m.role === "assistant");
+				const tc = { function: {
+					name: item.name,
+					arguments: parseOllamaToolArguments(item)
+				} };
+				if (lastAssistant) lastAssistant.tool_calls = [...lastAssistant.tool_calls ?? [], tc];
+				else messages.push({
+					role: "assistant",
+					content: "",
+					tool_calls: [tc]
+				});
+				break;
+			}
+			case "tool_result":
+				assertOllamaToolResultOutcome(item.outcome);
+				messages.push({
+					role: "tool",
+					content: contentBlocksToText(ensureOllamaTextBlocks(item.content, `tool_result ${item.callId} content`))
+				});
+				break;
+			case "reasoning":
+				messages.push({
+					role: "assistant",
+					content: contentBlocksToText(ensureOllamaReasoningBlocks(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
+						});
+					}
+				}
+				break;
+		}
+		const body = {
+			model: request.model,
+			messages,
+			stream: true
+		};
+		if (request.tools && request.tools.length > 0) body.tools = request.tools.map((t) => ({
+			type: "function",
+			function: {
+				name: t.name,
+				description: t.description,
+				parameters: t.inputSchema
+			}
+		}));
+		if (request.temperature !== void 0 || request.maxOutputTokens !== void 0) {
+			body.options = {};
+			if (request.temperature !== void 0) body.options.temperature = request.temperature;
+			if (request.maxOutputTokens !== void 0) body.options.num_predict = request.maxOutputTokens;
+		}
+		return body;
+	}
+	async *runStream(providerRequest, factory, request) {
+		const auxiliary = this.createAuxiliaryState(request);
+		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)
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "unknown error");
+			throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+		}
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Response body is not readable");
+		const output = [];
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let responseId;
+		let accumulatedContent = "";
+		let currentMessageId = "";
+		let hasMessageStarted = false;
+		let pendingToolCalls = [];
+		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 malformedWarning = emitMalformedStreamWarning(factory, {
+					count: malformedLines,
+					providerLabel: "Ollama",
+					transportLabel: "NDJSON line(s)"
+				});
+				if (malformedWarning) yield malformedWarning;
+				for (const chunk of chunks) {
+					responseId = chunk.created_at;
+					const msg = chunk.message;
+					if (msg.content) {
+						if (!hasMessageStarted) {
+							currentMessageId = `msg-${chunk.created_at}`;
+							hasMessageStarted = true;
+							yield factory.messageStarted(currentMessageId);
+						}
+						accumulatedContent += msg.content;
+						yield factory.messageDelta(currentMessageId, 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 argsText = JSON.stringify(tc.function.arguments);
+						pendingToolCalls.push({
+							id: tcId,
+							name: tc.function.name,
+							argumentsText: argsText,
+							argumentsJson: tc.function.arguments
+						});
+					}
+					if (chunk.done) {
+						if (accumulatedContent === "" && pendingToolCalls.length > 0 && !hasMessageStarted) {
+							currentMessageId = `msg-${chunk.created_at}`;
+							hasMessageStarted = true;
+							yield factory.messageStarted(currentMessageId);
+						}
+						if (hasMessageStarted) {
+							const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
+							yield factory.messageCompleted(message);
+							if (accumulatedContent) output.push(message);
+						}
+						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);
+							output.push(toolCall);
+						}
+						if (request.include?.usage !== "off" && (chunk.prompt_eval_count !== void 0 || chunk.eval_count !== void 0)) auxiliary.recordUsage({
+							inputTokens: chunk.prompt_eval_count,
+							outputTokens: chunk.eval_count,
+							totalTokens: chunk.prompt_eval_count !== void 0 && chunk.eval_count !== void 0 ? chunk.prompt_eval_count + chunk.eval_count : void 0
+						}, "final", {
+							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));
+						accumulatedContent = "";
+						currentMessageId = "";
+						hasMessageStarted = false;
+						pendingToolCalls = [];
+					}
+				}
+			}
+		} 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) {
+			yield factory.responseWarning("Stream ended without a done signal", "INCOMPLETE_STREAM");
+			if (hasMessageStarted) {
+				const message = messageItem([textBlock(accumulatedContent)], { id: currentMessageId });
+				yield factory.messageCompleted(message);
+				if (accumulatedContent) output.push(message);
+			}
+			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);
+				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));
+		}
+	}
+};
+//#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, CAPABILITY_MATRIX, ChatCompletionsAdapter, MessagesAdapter, OllamaAdapter, ResponsesAdapter, WarningCode, aggregateEvents, assertValidRequest, blockToText, collectStream, contentBlocksToText, createAIClient, createEventFactory, emitMalformedStreamWarning, extractText, imageBlock, instructionsToText, jsonBlock, mapReasoningVisibility, mapStopReason, messageItem, metadataSourceList, normalizeRequest, opaqueBlock, opaqueItem, parseSSEEvents, reasoningItem, replayFromOutput, syntheticStream, textBlock, toolCallItem, toolResultItem, validateRequest };
+
+//# sourceMappingURL=index.mjs.map