@openclaw/ai 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/transports.mjs

@@ -0,0 +1,4069 @@
+import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
+import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, l as resolveClaudeNativeThinkingLevelMap, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./src-QkygScBs.mjs";
+import { r as createAssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { C as extractToolResultBlockText, E as isImageWithMediaPayload, O as isRecord, S as describeToolResultMediaPlaceholder, _ as usesClaudeStreamingRefusalContract, a as splitSystemPromptCacheBoundary, d as applyClaudeRequestContract, f as defaultsClaudeAdaptiveThinking, g as usesClaudeFable5MessagesContract, l as sortPromptCacheToolsByName, m as requiresClaudeAdaptiveThinking, o as stripSystemPromptCacheBoundary, p as prepareClaudeNoPrefillRequestContext, v as hasNonEmptyString, w as extractToolResultText, x as readStringValue, y as normalizeLowercaseStringOrEmpty } from "./shared-CdjNZd35.mjs";
+import { C as transformTransportMessages, S as resolveProviderRequestPolicyConfig, _ as buildGuardedModelFetch, a as projectOpenAITools, b as resolveProviderEndpoint, c as mapOpenAIStopReason, d as resolveOpenAICompletionsCompat, f as resolveOpenAICompletionsResponseFormat, g as tagPendingCommentaryText, h as rememberPendingCommentaryTags, l as resolveOpenAIReasoningEffortMap, m as clearPendingCommentaryText, o as reconcileOpenAICompletionsToolChoice, p as shouldOmitOllamaCompatResponseFormat, s as reconcileOpenAIResponsesToolChoice, t as convertMessages, u as detectOpenAICompletionsCompat, v as resolveModelRequestTimeoutMs, x as resolveProviderRequestCapabilities, y as resolveOpenAIStrictToolSetting } from "./openai-completions-CiSutyu0.mjs";
+import { t as toErrorObject } from "./error-coercion-DgxlWC0n.mjs";
+import { C as normalizeAnthropicInlineContent, S as createAnthropicInlineImageBudget, T as canonicalizeBase64, _ as readAnthropicFallbackBoundary, a as readAnthropicPromptUsageSnapshot, b as omitFoundryBearerCredentialHeaders, c as projectAnthropicTools, d as ANTHROPIC_OMITTED_REASONING_TEXT, f as findActiveAnthropicToolTurnAssistantIndex, g as applyAnthropicFallbackBoundary, l as reconcileAnthropicToolChoice, m as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, o as readAnthropicUsageTokenCount, p as ANTHROPIC_SERVER_SIDE_FALLBACKS, s as readLastAnthropicIterationUsage, u as resolveOriginalAnthropicToolName, v as resolveAnthropicFallbackServingModelCost, w as resolveAnthropicImageMediaType, x as usesFoundryBearerAuth, y as applyAnthropicRefusal } from "./anthropic-CQVj3le6.mjs";
+import { a as parseStrictPositiveInteger, c as calculateCost, l as clampThinkingLevel, s as applyProviderReportedUsageCost } from "./number-coercion-DvG7SNMg.mjs";
+import { C as resolveSecretSentinel, S as resolveModelHeaderSentinels$1, T as supportsModelTools, _ as isGoogleGemini3ProModel, a as failTransportStream, c as mergeTransportMetadata, d as transportAbortError, f as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, g as isGoogleGemini3FlashModel, h as isCodeModeModelVisibleToolName, i as createWritableTransportEventStream, l as sanitizeNonEmptyTransportPayloadText, m as estimateStringChars, n as coerceTransportToolCallArguments, o as finalizeTransportStream, p as createAbortError$1, r as createEmptyTransportUsage, s as mergeTransportHeaders, t as assignTransportErrorDetails, u as sanitizeTransportPayloadText, v as parseRetryAfterSeconds, w as sha256Hex, y as readResponseTextSnippet } from "./transport-stream-shared-BbMELSI4.mjs";
+import { r as createDeferredEventBuffer, t as notifyLlmRequestActivity } from "./llm-request-activity-CehVkZP-.mjs";
+import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
+import "./internal/anthropic.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, o as createReasoningTagTextPartitioner, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C3OgBjIk.mjs";
+import "./internal/runtime.mjs";
+import { A as resolveAzureOpenAIApiVersion, At as emitModelTransportDebug, B as stringifyRedactedPayload, C as observeResponsesStream, D as createResponsesStreamWithEncryptedContentRetry, E as convertResponsesMessages, F as buildResponsesFailedNoDetailsObservation, G as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, H as summarizeResponsesFailedNoDetailsObservation, I as logResponsesFailedNoDetails, J as resolveCacheRetention, K as createModelStreamCooperativeScheduler, L as normalizeResponsesFailedEvent, M as tagOpenAIResponsesReasoningReplayItem, Mt as resolveModelSseDebugMode, N as resolveReplayableResponsesMessageId, O as isInvalidEncryptedContentError, P as applyServiceTierPricing, Q as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, R as safeDebugValue, T as buildResponsesInputMessage, U as summarizeResponsesPayload, V as summarizeOpenAITransportError, W as summarizeResponsesTools, X as throwIfModelStreamAborted, Y as resolvePromptCacheKey, Z as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, d as findOpenAIStrictToolProjectionDiagnostics, dt as isOpenAIGpt55Model, ft as isOpenAIGpt56Model, gt as supportsOpenAIReasoningEffort, h as resolveOpenAIProjectedToolsStrictToolFlag, j as stripResponsesRequestEncryptedContent, jt as resolveModelPayloadDebugMode, k as prepareOpenAIResponsesReasoningItemForReplay, kt as uniqueStrings, mt as resolveOpenAIReasoningEffortForModel, p as normalizeOpenAIStrictToolParameters, pt as normalizeOpenAIReasoningEffort, q as log, ut as isOpenAIGpt54MiniModel, v as ResponsesStreamFailure, vt as isOpenAICompatibleAzureResponsesBaseUrl, w as buildOpenAIResponsesReasoningReplayMetadata, xt as resolveAzureDeploymentNameFromMap, y as processResponsesStream, z as stringifyRedactedEvent } from "./openai-D3PD6PE-.mjs";
+import { randomUUID } from "node:crypto";
+import OpenAI, { AzureOpenAI } from "openai";
+//#region packages/ai/src/transports/anthropic-payload-policy.ts
+/**
+* Anthropic-family request payload policy helpers.
+* Applies service-tier and cache-control markers only when provider endpoint
+* capabilities allow them.
+*/
+const ANTHROPIC_CACHE_CONTROL_LIMIT = 4;
+function resolveBaseUrlHostname(baseUrl) {
+	try {
+		return new URL(baseUrl).hostname;
+	} catch {
+		return;
+	}
+}
+function isLongTtlEligibleEndpoint(baseUrl) {
+	if (typeof baseUrl !== "string") return false;
+	const hostname = resolveBaseUrlHostname(baseUrl);
+	if (!hostname) return false;
+	return hostname === "api.anthropic.com" || hostname === "aiplatform.googleapis.com" || hostname.endsWith("-aiplatform.googleapis.com");
+}
+/** Resolve Anthropic cache-control marker retention for a request endpoint. */
+function resolveAnthropicEphemeralCacheControl(baseUrl, cacheRetention) {
+	const retention = cacheRetention ?? (process.env.OPENCLAW_CACHE_RETENTION === "long" ? "long" : "short");
+	if (retention === "none") return;
+	const ttl = retention === "long" && (cacheRetention === "long" || isLongTtlEligibleEndpoint(baseUrl)) ? "1h" : void 0;
+	return {
+		type: "ephemeral",
+		...ttl ? { ttl } : {}
+	};
+}
+function applyAnthropicCacheControlToSystem(system, cacheControl) {
+	if (!Array.isArray(system)) return;
+	const normalizedBlocks = [];
+	for (const block of system) {
+		if (!block || typeof block !== "object") {
+			normalizedBlocks.push(block);
+			continue;
+		}
+		const record = block;
+		if (record.type !== "text" || typeof record.text !== "string") {
+			normalizedBlocks.push(block);
+			continue;
+		}
+		const split = splitSystemPromptCacheBoundary(record.text);
+		if (!split) {
+			if (record.cache_control === void 0) record.cache_control = cacheControl;
+			normalizedBlocks.push(record);
+			continue;
+		}
+		const { cache_control: existingCacheControl, ...rest } = record;
+		if (split.stablePrefix) normalizedBlocks.push({
+			...rest,
+			text: split.stablePrefix,
+			cache_control: existingCacheControl ?? cacheControl
+		});
+		if (split.dynamicSuffix) normalizedBlocks.push({
+			...rest,
+			text: split.dynamicSuffix
+		});
+	}
+	system.splice(0, system.length, ...normalizedBlocks);
+}
+function stripAnthropicSystemPromptBoundary(system) {
+	if (!Array.isArray(system)) return;
+	for (const block of system) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type === "text" && typeof record.text === "string") record.text = stripSystemPromptCacheBoundary(record.text);
+	}
+}
+function applyAnthropicCacheControlToMessages(messages, cacheControl, markerLimit, cacheBreakpointOptOutMessageIndexes) {
+	if (!Array.isArray(messages) || messages.length === 0 || markerLimit <= 0) return;
+	let fallbackToolResult;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (!message || typeof message !== "object") continue;
+		const record = message;
+		if (record.role !== "user" || cacheBreakpointOptOutMessageIndexes.has(i)) continue;
+		const content = record.content;
+		if (typeof content === "string") {
+			if (fallbackToolResult && markerLimit === 1) {
+				fallbackToolResult.cache_control = cacheControl;
+				return;
+			}
+			record.content = [{
+				type: "text",
+				text: content,
+				cache_control: cacheControl
+			}];
+			if (fallbackToolResult && markerLimit > 1) fallbackToolResult.cache_control = cacheControl;
+			return;
+		}
+		if (!Array.isArray(content)) continue;
+		for (let j = content.length - 1; j >= 0; j--) {
+			const block = content[j];
+			if (!block || typeof block !== "object") continue;
+			const blockRecord = block;
+			if (blockRecord.type === "text" || blockRecord.type === "image") {
+				if (fallbackToolResult && markerLimit === 1) {
+					fallbackToolResult.cache_control = cacheControl;
+					return;
+				}
+				blockRecord.cache_control = cacheControl;
+				if (fallbackToolResult && markerLimit > 1) fallbackToolResult.cache_control = cacheControl;
+				return;
+			}
+			if (blockRecord.type === "tool_result" && fallbackToolResult === void 0) fallbackToolResult = blockRecord;
+		}
+	}
+	if (fallbackToolResult) fallbackToolResult.cache_control = cacheControl;
+}
+function countAnthropicCacheControlMarkers(blocks) {
+	if (!Array.isArray(blocks)) return 0;
+	let count = 0;
+	for (const block of blocks) if (block && typeof block === "object" && "cache_control" in block) count += 1;
+	return count;
+}
+/** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
+function resolveAnthropicPayloadPolicy(input) {
+	return {
+		allowsServiceTier: resolveProviderRequestCapabilities({
+			provider: input.provider,
+			api: input.api,
+			baseUrl: input.baseUrl,
+			capability: "llm",
+			transport: "stream"
+		}).allowsAnthropicServiceTier,
+		cacheControl: input.enableCacheControl === true ? resolveAnthropicEphemeralCacheControl(input.baseUrl, input.cacheRetention) : void 0,
+		serviceTier: input.serviceTier
+	};
+}
+/** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
+function applyAnthropicPayloadPolicyToParams(payloadObj, policy, cacheBreakpointOptOutMessageIndexes) {
+	if (policy.allowsServiceTier && policy.serviceTier !== void 0 && payloadObj.service_tier === void 0) payloadObj.service_tier = policy.serviceTier;
+	if (policy.cacheControl) applyAnthropicCacheControlToSystem(payloadObj.system, policy.cacheControl);
+	else stripAnthropicSystemPromptBoundary(payloadObj.system);
+	if (!policy.cacheControl) return;
+	const usedMarkers = countAnthropicCacheControlMarkers(payloadObj.system) + countAnthropicCacheControlMarkers(payloadObj.tools);
+	applyAnthropicCacheControlToMessages(payloadObj.messages, policy.cacheControl, ANTHROPIC_CACHE_CONTROL_LIMIT - usedMarkers, cacheBreakpointOptOutMessageIndexes);
+}
+/** @deprecated Anthropic-family provider payload helper; do not use from third-party plugins. */
+function applyAnthropicEphemeralCacheControlMarkers(payloadObj, cacheControl = { type: "ephemeral" }) {
+	const messages = payloadObj.messages;
+	if (!Array.isArray(messages)) return;
+	for (const message of messages) {
+		if (message.role === "system" || message.role === "developer") {
+			if (!cacheControl) continue;
+			if (typeof message.content === "string") {
+				message.content = [{
+					type: "text",
+					text: message.content,
+					cache_control: cacheControl
+				}];
+				continue;
+			}
+			if (Array.isArray(message.content) && message.content.length > 0) {
+				const last = message.content[message.content.length - 1];
+				if (last && typeof last === "object") {
+					const record = last;
+					if (record.type !== "thinking" && record.type !== "redacted_thinking") record.cache_control = cacheControl;
+				}
+			}
+			continue;
+		}
+		if (message.role === "assistant" && Array.isArray(message.content)) for (const block of message.content) {
+			if (!block || typeof block !== "object") continue;
+			const record = block;
+			if (record.type === "thinking" || record.type === "redacted_thinking") delete record.cache_control;
+		}
+	}
+}
+//#endregion
+//#region packages/ai/src/transports/json-unsafe-integers.ts
+/**
+* JSON parsing helpers that preserve integer literals larger than
+* Number.MAX_SAFE_INTEGER as strings before JSON.parse can round them.
+*/
+const MAX_SAFE_INTEGER_ABS_STR = String(Number.MAX_SAFE_INTEGER);
+function isAsciiDigit(ch) {
+	return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function parseJsonNumberToken(input, start) {
+	let idx = start;
+	if (input[idx] === "-") idx += 1;
+	if (idx >= input.length) return null;
+	if (input[idx] === "0") idx += 1;
+	else if (isAsciiDigit(input[idx]) && input[idx] !== "0") while (isAsciiDigit(input[idx])) idx += 1;
+	else return null;
+	let isInteger = true;
+	if (input[idx] === ".") {
+		isInteger = false;
+		idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	if (input[idx] === "e" || input[idx] === "E") {
+		isInteger = false;
+		idx += 1;
+		if (input[idx] === "+" || input[idx] === "-") idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	return {
+		token: input.slice(start, idx),
+		end: idx,
+		isInteger
+	};
+}
+function isUnsafeIntegerLiteral(token) {
+	const digits = token[0] === "-" ? token.slice(1) : token;
+	if (digits.length < MAX_SAFE_INTEGER_ABS_STR.length) return false;
+	if (digits.length > MAX_SAFE_INTEGER_ABS_STR.length) return true;
+	return digits > MAX_SAFE_INTEGER_ABS_STR;
+}
+/** Quotes integer literals above Number.MAX_SAFE_INTEGER before JSON.parse. */
+function quoteUnsafeIntegerLiterals(input) {
+	let out = "";
+	let inString = false;
+	let escaped = false;
+	let idx = 0;
+	while (idx < input.length) {
+		const ch = input[idx] ?? "";
+		if (inString) {
+			out += ch;
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			idx += 1;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			idx += 1;
+			continue;
+		}
+		if (ch === "-" || isAsciiDigit(ch)) {
+			const parsed = parseJsonNumberToken(input, idx);
+			if (parsed) {
+				if (parsed.isInteger && isUnsafeIntegerLiteral(parsed.token)) out += `"${parsed.token}"`;
+				else out += parsed.token;
+				idx = parsed.end;
+				continue;
+			}
+		}
+		out += ch;
+		idx += 1;
+	}
+	return out;
+}
+/** Parses JSON while preserving unsafe integer literals as strings. */
+function parseJsonPreservingUnsafeIntegers(input) {
+	return JSON.parse(quoteUnsafeIntegerLiterals(input));
+}
+/** Parses or accepts an object while preserving unsafe integer literals in string input. */
+function parseJsonObjectPreservingUnsafeIntegers(value) {
+	if (typeof value === "string") {
+		try {
+			const parsed = parseJsonPreservingUnsafeIntegers(value);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	return null;
+}
+//#endregion
+//#region packages/ai/src/transports/anthropic-transport-stream.ts
+/**
+* Native Anthropic Messages streaming transport.
+* Converts OpenClaw contexts/tools into Anthropic payloads, streams SSE events
+* back into runtime output blocks, and applies provider request policy.
+*/
+const CLAUDE_CODE_VERSION = "2.1.75";
+const CLAUDE_CODE_BILLING_SYSTEM_BLOCK = `x-anthropic-billing-header: cc_version=${CLAUDE_CODE_VERSION}; cc_entrypoint=sdk-cli;`;
+const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES = 8 * 1024;
+const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS = 400;
+const ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS = 1e4;
+const ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS = 4096;
+const ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR = 4;
+const ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS = 16 * 1024 * 1024;
+const CLAUDE_CODE_TOOL_LOOKUP = new Map([
+	"Read",
+	"Write",
+	"Edit",
+	"Bash",
+	"Grep",
+	"Glob",
+	"AskUserQuestion",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"KillShell",
+	"NotebookEdit",
+	"Skill",
+	"Task",
+	"TaskOutput",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch"
+].map((tool) => [normalizeLowercaseStringOrEmpty(tool), tool]));
+function resolveAnthropicRequestModelId(model) {
+	if (isDirectAnthropicModel(model) && /^anthropic\//i.test(model.id)) return model.id.replace(/^anthropic\//i, "");
+	return model.id;
+}
+const EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT = ".";
+function normalizeAnthropicToolChoice(thinkingEnabled, toolChoice) {
+	if (thinkingEnabled && (toolChoice === "any" || typeof toolChoice === "object" && toolChoice.type === "tool")) return { type: "auto" };
+	return typeof toolChoice === "string" ? { type: toolChoice } : toolChoice;
+}
+function supportsNativeXhighEffort(model) {
+	return supportsClaudeNativeXhighEffort(model);
+}
+function supportsAdaptiveThinking(model) {
+	return supportsClaudeAdaptiveThinking(model);
+}
+function mapThinkingLevelToEffort(level, model) {
+	const thinkingLevelMap = resolveClaudeNativeThinkingLevelMap(model);
+	const resolvedLevel = clampThinkingLevel({
+		...model,
+		...typeof model.params?.canonicalModelId === "string" ? { reasoning: true } : {},
+		...thinkingLevelMap ? { thinkingLevelMap } : {}
+	}, level);
+	const mapped = thinkingLevelMap?.[resolvedLevel];
+	if (typeof mapped === "string") return mapped;
+	switch (resolvedLevel) {
+		case "off":
+		case "minimal":
+		case "low": return "low";
+		case "medium": return "medium";
+		case "xhigh": return supportsNativeXhighEffort(model) ? "xhigh" : "high";
+		case "max": return supportsClaudeNativeMaxEffort(model) ? "max" : "high";
+		default: return "high";
+	}
+}
+function clampReasoningLevel(level) {
+	return level === "xhigh" || level === "max" ? "high" : level;
+}
+function resolvePositiveAnthropicTokenLimit(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	const floored = Math.floor(value);
+	return floored > 0 ? floored : void 0;
+}
+function resolveAnthropicMessagesMaxTokens(params) {
+	const requested = resolvePositiveAnthropicTokenLimit(params.requestedMaxTokens);
+	if (requested !== void 0) return requested;
+	const modelMax = resolvePositiveAnthropicTokenLimit(params.modelMaxTokens);
+	if (modelMax !== void 0) return params.useModelDefault ? modelMax : Math.min(modelMax, 32e3);
+	if (params.modelMaxTokens !== void 0) return;
+	const contextWindow = resolvePositiveAnthropicTokenLimit(params.modelContextWindow);
+	return contextWindow === void 0 ? ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS : Math.max(1, Math.min(ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS, Math.floor(contextWindow / ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR)));
+}
+function adjustMaxTokensForThinking(params) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		...params.customBudgets
+	};
+	const minOutputTokens = 1024;
+	let thinkingBudget = budgets[clampReasoningLevel(params.reasoningLevel)];
+	const maxTokens = Math.min(params.baseMaxTokens + thinkingBudget, params.modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+function isAnthropicOAuthToken(apiKey) {
+	return (resolveSecretSentinel(apiKey) ?? apiKey).includes("sk-ant-oat");
+}
+function isDirectAnthropicModel(model) {
+	if (normalizeLowercaseStringOrEmpty(model.provider) !== "anthropic") return false;
+	const endpointClass = resolveProviderEndpoint(model.baseUrl).endpointClass;
+	return endpointClass === "default" || endpointClass === "anthropic-public";
+}
+function isKimiAnthropicProvider(provider) {
+	return /^kimi(?:-|$)/.test(normalizeLowercaseStringOrEmpty(provider ?? ""));
+}
+/**
+* Server-side refusal fallback is a first-party Claude API beta: proxies and
+* Bedrock/Vertex/Foundry reject the `fallbacks` param, and OAuth (Claude Code
+* identity) requests are excluded until the beta is verified there.
+*/
+function useAnthropicServerSideFallback(model) {
+	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
+}
+function supportsReasoningContentReplay(model) {
+	return resolveProviderEndpoint(model.baseUrl).endpointClass === "xiaomi-native";
+}
+function buildAnthropicBetaHeader(model, betaFeatures, params) {
+	if (!isDirectAnthropicModel(model)) return;
+	return params.oauth ? `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}` : betaFeatures.join(",");
+}
+function toClaudeCodeName(name) {
+	return CLAUDE_CODE_TOOL_LOOKUP.get(normalizeLowercaseStringOrEmpty(name)) ?? name;
+}
+const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+async function convertContentBlocks(content, model, imageBudget) {
+	const text = extractToolResultText(content);
+	const mediaPlaceholder = describeToolResultMediaPlaceholder(content);
+	if (!(model.input.includes("image") && content.some(isImageWithMediaPayload))) return sanitizeNonEmptyTransportPayloadText(text, mediaPlaceholder ?? "(no output)");
+	const blocks = [];
+	let hasTextBlock = false;
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		const blockText = extractToolResultBlockText(block);
+		if (blockText) {
+			blocks.push({
+				type: "text",
+				text: sanitizeTransportPayloadText(blockText)
+			});
+			hasTextBlock = true;
+		}
+		if (!isImageWithMediaPayload(record)) continue;
+		const [normalizedImage] = await normalizeAnthropicInlineContent([{
+			type: "image",
+			data: typeof record.data === "string" ? record.data : "",
+			mimeType: typeof record.mimeType === "string" ? record.mimeType : "image/png"
+		}], imageBudget);
+		if (normalizedImage?.type !== "image") continue;
+		blocks.push({
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: resolveAnthropicImageMediaType(normalizedImage.mimeType),
+				data: normalizedImage.data
+			}
+		});
+	}
+	if (!hasTextBlock) blocks.unshift({
+		type: "text",
+		text: mediaPlaceholder ?? "(see attached image)"
+	});
+	return blocks;
+}
+function normalizeToolCallId(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+async function convertAnthropicMessages(messages, model, isOAuthToken, options) {
+	const params = [];
+	const imageBudget = createAnthropicInlineImageBudget();
+	const allowReasoningContentReplay = options.allowReasoningContentReplay === true;
+	const replayThinkingEnabled = options.replayThinkingEnabled !== false;
+	const transformedMessages = transformTransportMessages(messages, model, normalizeToolCallId);
+	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
+	for (let i = 0; i < transformedMessages.length; i += 1) {
+		const msg = transformedMessages[i];
+		if (!msg) continue;
+		if (msg.role === "user") {
+			const isRuntimeContextCarrier = msg.runtimeContextCarrier === true;
+			if (typeof msg.content === "string") {
+				if (msg.content.trim().length > 0) {
+					const userParam = {
+						role: "user",
+						content: sanitizeTransportPayloadText(msg.content)
+					};
+					if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
+					params.push(userParam);
+				}
+				continue;
+			}
+			const blocks = (model.input.includes("image") ? await normalizeAnthropicInlineContent(msg.content, imageBudget) : msg.content.map((item) => item.type === "image" ? {
+				type: "text",
+				text: NON_VISION_USER_IMAGE_PLACEHOLDER
+			} : item)).map((item) => item.type === "text" ? {
+				type: "text",
+				text: sanitizeTransportPayloadText(item.text)
+			} : {
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: resolveAnthropicImageMediaType(item.mimeType),
+					data: item.data
+				}
+			});
+			let filteredBlocks = model.input.includes("image") ? blocks : blocks.filter((block) => block.type !== "image");
+			filteredBlocks = filteredBlocks.filter((block) => block.type !== "text" || block.text.trim().length > 0);
+			if (filteredBlocks.length === 0) continue;
+			const userParam = {
+				role: "user",
+				content: filteredBlocks
+			};
+			if (isRuntimeContextCarrier) options.cacheBreakpointOptOutMessageIndexes.add(params.length);
+			params.push(userParam);
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const blocks = [];
+			const reasoningContent = [];
+			let omittedThinking = false;
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (block.text.trim().length > 0) blocks.push({
+						type: "text",
+						text: sanitizeTransportPayloadText(block.text)
+					});
+					continue;
+				}
+				if (block.type === "thinking") {
+					const thinkingSignature = block.thinkingSignature?.trim();
+					const isReasoningContent = thinkingSignature === "reasoning_content";
+					if (!replayThinkingEnabled && i !== activeToolTurnAssistantIndex && !isReasoningContent) {
+						omittedThinking = true;
+						continue;
+					}
+					if (block.redacted) {
+						blocks.push({
+							type: "redacted_thinking",
+							data: block.thinkingSignature
+						});
+						continue;
+					}
+					const hasNativeThinkingSignature = Boolean(thinkingSignature) && !isReasoningContent;
+					if (block.thinking.trim().length === 0 && !hasNativeThinkingSignature) continue;
+					if (!thinkingSignature) blocks.push({
+						type: "text",
+						text: sanitizeTransportPayloadText(block.thinking)
+					});
+					else {
+						const thinking = thinkingSignature === "reasoning_content" ? sanitizeTransportPayloadText(block.thinking) : block.thinking;
+						if (thinkingSignature === "reasoning_content") {
+							if (allowReasoningContentReplay) {
+								blocks.push({
+									type: "thinking",
+									thinking,
+									signature: thinkingSignature
+								});
+								reasoningContent.push(thinking);
+							}
+							continue;
+						}
+						blocks.push({
+							type: "thinking",
+							thinking,
+							signature: thinkingSignature
+						});
+					}
+					continue;
+				}
+				if (block.type === "toolCall") blocks.push({
+					type: "tool_use",
+					id: block.id,
+					name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
+					input: coerceTransportToolCallArguments(block.arguments)
+				});
+			}
+			if (blocks.length === 0 && omittedThinking) blocks.push({
+				type: "text",
+				text: ANTHROPIC_OMITTED_REASONING_TEXT
+			});
+			if (blocks.length > 0) {
+				const assistantMsg = {
+					role: "assistant",
+					content: blocks
+				};
+				if (reasoningContent.length > 0) assistantMsg.reasoning_content = reasoningContent.join("\n");
+				else if (allowReasoningContentReplay) blocks.unshift({
+					type: "thinking",
+					thinking: "",
+					signature: "reasoning_content"
+				});
+				params.push(assistantMsg);
+			}
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			const toolResult = msg;
+			const toolResults = [{
+				type: "tool_result",
+				tool_use_id: toolResult.toolCallId,
+				content: await convertContentBlocks(toolResult.content, model, imageBudget),
+				is_error: toolResult.isError
+			}];
+			let j = i + 1;
+			while (j < transformedMessages.length) {
+				const nextMsg = transformedMessages.at(j);
+				if (nextMsg?.role !== "toolResult") break;
+				toolResults.push({
+					type: "tool_result",
+					tool_use_id: nextMsg.toolCallId,
+					content: await convertContentBlocks(nextMsg.content, model, imageBudget),
+					is_error: nextMsg.isError
+				});
+				j += 1;
+			}
+			i = j - 1;
+			params.push({
+				role: "user",
+				content: toolResults
+			});
+		}
+	}
+	return params;
+}
+function ensureNonEmptyAnthropicMessages(messages) {
+	return messages.length > 0 ? messages : [{
+		role: "user",
+		content: EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT
+	}];
+}
+function convertAnthropicTools(tools, isOAuthToken) {
+	const projection = projectAnthropicTools(tools ?? [], (name) => isOAuthToken ? toClaudeCodeName(name) : name);
+	const converted = [];
+	for (const tool of projection.tools) converted.push({
+		name: tool.wireName,
+		description: tool.description,
+		input_schema: tool.inputSchema
+	});
+	return {
+		projection,
+		tools: converted
+	};
+}
+function parseAnthropicToolCallArguments(inputJson) {
+	return parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson);
+}
+function mapStopReason(reason) {
+	switch (reason) {
+		case "end_turn": return "stop";
+		case "max_tokens": return "length";
+		case "tool_use": return "toolUse";
+		case "pause_turn": return "stop";
+		case "refusal":
+		case "sensitive": return "error";
+		case "stop_sequence": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(reason)}`);
+	}
+}
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+/** Resolve the effective Anthropic API base URL from model or environment. */
+function resolveAnthropicBaseUrl(baseUrl) {
+	return baseUrl?.trim() || process.env.ANTHROPIC_BASE_URL?.trim() || DEFAULT_ANTHROPIC_BASE_URL;
+}
+/** Resolve the Anthropic Messages endpoint URL for the effective base URL. */
+function resolveAnthropicMessagesUrl(baseUrl) {
+	const normalized = resolveAnthropicBaseUrl(baseUrl).replace(/\/+$/, "");
+	return normalized.endsWith("/v1") ? `${normalized}/messages` : `${normalized}/v1/messages`;
+}
+function withEffectiveAnthropicBaseUrl(model) {
+	const baseUrl = resolveAnthropicBaseUrl(model.baseUrl);
+	return baseUrl === model.baseUrl ? model : {
+		...model,
+		baseUrl
+	};
+}
+function createAbortError(signal) {
+	const reason = signal.reason;
+	if (reason instanceof Error) return reason;
+	return createAbortError$1("Request was aborted", reason === void 0 ? void 0 : { cause: reason });
+}
+function readAnthropicSseChunk(reader, signal) {
+	if (!signal) return reader.read();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			reader.cancel(signal.reason).catch(() => void 0);
+			reject(createAbortError(signal));
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		reader.read().then((result) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			resolve(result);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			reject(toErrorObject(error, "Non-Error rejection"));
+		});
+	});
+}
+function parseAnthropicSseEventData(data) {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { cause: error });
+		throw error;
+	}
+}
+function assertAnthropicSsePendingBufferWithinLimit(pendingChars) {
+	if (pendingChars <= ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS) return;
+	throw new Error(`Anthropic Messages SSE response exceeded max pending buffer size (${ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS} chars) without event boundary`);
+}
+async function* parseAnthropicSseBody(body, signal) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let completed = false;
+	try {
+		while (true) {
+			const { done, value } = await readAnthropicSseChunk(reader, signal);
+			if (done) {
+				completed = true;
+				break;
+			}
+			buffer = `${buffer}${decoder.decode(value, { stream: true })}`.replaceAll("\r\n", "\n");
+			let frameEnd = buffer.indexOf("\n\n");
+			while (frameEnd >= 0) {
+				assertAnthropicSsePendingBufferWithinLimit(frameEnd);
+				const frame = buffer.slice(0, frameEnd);
+				buffer = buffer.slice(frameEnd + 2);
+				const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+				if (data && data !== "[DONE]") yield parseAnthropicSseEventData(data);
+				frameEnd = buffer.indexOf("\n\n");
+			}
+			assertAnthropicSsePendingBufferWithinLimit(buffer.length);
+		}
+		const tailBuffer = `${buffer}${decoder.decode()}`.replaceAll("\r\n", "\n");
+		assertAnthropicSsePendingBufferWithinLimit(tailBuffer.length);
+		const tail = tailBuffer.trim();
+		if (tail) {
+			const data = tail.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+			if (data && data !== "[DONE]") yield parseAnthropicSseEventData(data);
+		}
+	} finally {
+		if (!completed) await reader.cancel(signal?.reason).catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+function createAnthropicMessagesClient(params) {
+	const url = resolveAnthropicMessagesUrl(params.baseURL);
+	return { messages: { async *stream(body, options) {
+		const headers = mergeTransportHeaders({
+			"content-type": "application/json",
+			"anthropic-version": "2023-06-01",
+			...params.apiKey ? { "x-api-key": params.apiKey } : {},
+			...params.authToken ? { authorization: `Bearer ${params.authToken}` } : {}
+		}, params.defaultHeaders);
+		const response = await params.fetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal: options?.signal
+		});
+		if (!response.ok) {
+			const detail = await readAnthropicMessagesErrorBodySnippet(response);
+			throw new Error(formatAnthropicMessagesHttpError(response, detail));
+		}
+		if (!response.body) return;
+		yield* parseAnthropicSseBody(response.body, options?.signal);
+	} } };
+}
+function formatAnthropicMessagesHttpError(response, detail) {
+	const retryAfterSeconds = parseRetryAfterSeconds(response.headers);
+	const retryAfterSuffix = Number.isFinite(retryAfterSeconds) ? `; Retry-After: ${Math.ceil(retryAfterSeconds ?? 0)} seconds` : "";
+	return `HTTP ${response.status}: ${detail || "Anthropic Messages request failed"}${retryAfterSuffix}`;
+}
+async function readAnthropicMessagesErrorBodySnippet(response) {
+	try {
+		return await readResponseTextSnippet(response, {
+			maxBytes: ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES,
+			maxChars: ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS,
+			chunkTimeoutMs: ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS,
+			onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Anthropic Messages error response stalled: no data received for ${chunkTimeoutMs}ms`)
+		}) ?? "";
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("Anthropic Messages error response stalled:")) return error.message;
+		return "";
+	}
+}
+function createAnthropicTransportClient(params) {
+	const { model, context, apiKey, options } = params;
+	const needsInterleavedBeta = (options?.interleavedThinking ?? true) && !supportsAdaptiveThinking(model);
+	const fetch = isKimiAnthropicProvider(model.provider) && options?.thinkingEnabled === true ? buildGuardedModelFetch(model, void 0, { sanitizeSse: false }) : buildGuardedModelFetch(model);
+	if (model.provider === "github-copilot") {
+		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
+		return {
+			client: createAnthropicMessagesClient({
+				apiKey: null,
+				authToken: apiKey,
+				baseURL: model.baseUrl,
+				defaultHeaders: mergeTransportHeaders({
+					accept: "application/json",
+					"anthropic-dangerous-direct-browser-access": "true",
+					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
+				}, model.headers, getAiTransportHost().buildCopilotDynamicHeaders(context.messages), options?.headers),
+				fetch
+			}),
+			isOAuthToken: false
+		};
+	}
+	if (usesFoundryBearerAuth(resolveModelHeaderSentinels$1(model))) {
+		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
+		return {
+			client: createAnthropicMessagesClient({
+				apiKey: null,
+				authToken: apiKey,
+				baseURL: model.baseUrl,
+				defaultHeaders: mergeTransportHeaders({
+					accept: "application/json",
+					"anthropic-dangerous-direct-browser-access": "true",
+					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
+				}, omitFoundryBearerCredentialHeaders(model.headers), options?.headers),
+				fetch
+			}),
+			isOAuthToken: false
+		};
+	}
+	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
+	if (needsInterleavedBeta) betaFeatures.push("interleaved-thinking-2025-05-14");
+	if (isAnthropicOAuthToken(apiKey)) {
+		const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: true });
+		return {
+			client: createAnthropicMessagesClient({
+				apiKey: null,
+				authToken: apiKey,
+				baseURL: model.baseUrl,
+				defaultHeaders: mergeTransportHeaders({
+					accept: "application/json",
+					"anthropic-dangerous-direct-browser-access": "true",
+					...betaHeader ? { "anthropic-beta": betaHeader } : {},
+					"user-agent": `claude-cli/${CLAUDE_CODE_VERSION}`,
+					"x-app": "cli"
+				}, model.headers, options?.headers),
+				fetch
+			}),
+			isOAuthToken: true
+		};
+	}
+	if (useAnthropicServerSideFallback(model)) betaFeatures.push(ANTHROPIC_SERVER_SIDE_FALLBACK_BETA);
+	const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: false });
+	return {
+		client: createAnthropicMessagesClient({
+			apiKey,
+			baseURL: model.baseUrl,
+			defaultHeaders: mergeTransportHeaders({
+				accept: "application/json",
+				"anthropic-dangerous-direct-browser-access": "true",
+				...betaHeader ? { "anthropic-beta": betaHeader } : {}
+			}, model.headers, options?.headers),
+			fetch
+		}),
+		isOAuthToken: false
+	};
+}
+async function buildAnthropicParams(model, context, isOAuthToken, options) {
+	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
+	const replayThinkingEnabled = mandatoryAdaptiveThinking || options?.thinkingEnabled === true;
+	const maxTokens = resolveAnthropicMessagesMaxTokens({
+		modelContextWindow: model.contextWindow,
+		modelMaxTokens: model.maxTokens,
+		requestedMaxTokens: options?.maxTokens
+	});
+	if (maxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
+	const payloadPolicy = resolveAnthropicPayloadPolicy({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		cacheRetention: options?.cacheRetention,
+		enableCacheControl: true
+	});
+	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
+	const messages = await convertAnthropicMessages(context.messages, model, isOAuthToken, {
+		allowReasoningContentReplay: supportsReasoningContentReplay(model),
+		cacheBreakpointOptOutMessageIndexes,
+		replayThinkingEnabled
+	});
+	const params = {
+		model: resolveAnthropicRequestModelId(model),
+		messages: ensureNonEmptyAnthropicMessages(messages),
+		max_tokens: maxTokens,
+		stream: true
+	};
+	if (!isOAuthToken && useAnthropicServerSideFallback(model)) params.fallbacks = ANTHROPIC_SERVER_SIDE_FALLBACKS;
+	if (isOAuthToken) params.system = [
+		{
+			type: "text",
+			text: CLAUDE_CODE_BILLING_SYSTEM_BLOCK
+		},
+		{
+			type: "text",
+			text: "You are Claude Code, Anthropic's official CLI for Claude."
+		},
+		...context.systemPrompt ? [{
+			type: "text",
+			text: sanitizeTransportPayloadText(context.systemPrompt)
+		}] : []
+	];
+	else if (context.systemPrompt) params.system = [{
+		type: "text",
+		text: sanitizeTransportPayloadText(context.systemPrompt)
+	}];
+	if (options?.temperature !== void 0 && !options.thinkingEnabled && !supportsNativeXhighEffort(model)) params.temperature = options.temperature;
+	if (options?.stop !== void 0 && options.stop.length > 0) params.stop_sequences = options.stop;
+	let toolProjection;
+	if (context.tools) {
+		const convertedTools = convertAnthropicTools(context.tools, isOAuthToken);
+		toolProjection = convertedTools.projection;
+		if (convertedTools.tools.length > 0) params.tools = convertedTools.tools;
+	}
+	if (mandatoryAdaptiveThinking || model.reasoning || supportsAdaptiveThinking(model)) {
+		if (mandatoryAdaptiveThinking || options?.thinkingEnabled) if (supportsAdaptiveThinking(model)) {
+			params.thinking = {
+				type: "adaptive",
+				display: options?.thinkingDisplay ?? "summarized"
+			};
+			const effort = options?.effort ?? (mandatoryAdaptiveThinking ? "high" : void 0);
+			if (effort) params.output_config = { effort };
+		} else params.thinking = {
+			type: "enabled",
+			budget_tokens: options?.thinkingBudgetTokens ?? 1024
+		};
+		else if (options?.thinkingEnabled === false) params.thinking = { type: "disabled" };
+	}
+	if (options?.metadata && typeof options.metadata.user_id === "string") params.metadata = { user_id: options.metadata.user_id };
+	if (options?.toolChoice) {
+		const normalizedToolChoice = normalizeAnthropicToolChoice(replayThinkingEnabled, options.toolChoice);
+		const projectedToolChoice = toolProjection ? reconcileAnthropicToolChoice(normalizedToolChoice, toolProjection) : normalizedToolChoice;
+		if (projectedToolChoice) params.tool_choice = projectedToolChoice;
+	}
+	applyAnthropicPayloadPolicyToParams(params, payloadPolicy, cacheBreakpointOptOutMessageIndexes);
+	return {
+		params,
+		toolProjection
+	};
+}
+function resolveAnthropicTransportOptions(model, options, apiKey) {
+	const baseMaxTokens = resolveAnthropicMessagesMaxTokens({
+		modelContextWindow: model.contextWindow,
+		modelMaxTokens: model.maxTokens,
+		requestedMaxTokens: options?.maxTokens,
+		useModelDefault: resolveClaudeSonnet5ModelIdentity(model) !== void 0 || resolveClaudeOpus5ModelIdentity(model) !== void 0
+	});
+	if (baseMaxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
+	const reasoningModelMaxTokens = resolvePositiveAnthropicTokenLimit(model.maxTokens) ?? baseMaxTokens;
+	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
+	const reasoning = options?.reasoning === "off" && mandatoryAdaptiveThinking ? "low" : options?.reasoning;
+	const resolved = {
+		temperature: options?.temperature,
+		stop: options?.stop,
+		maxTokens: baseMaxTokens,
+		signal: options?.signal,
+		apiKey,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata,
+		interleavedThinking: options?.interleavedThinking,
+		toolChoice: options?.toolChoice,
+		thinkingBudgets: options?.thinkingBudgets,
+		reasoning
+	};
+	if (reasoning === "off") {
+		resolved.thinkingEnabled = false;
+		return resolved;
+	}
+	if (!reasoning) {
+		resolved.thinkingEnabled = defaultsClaudeAdaptiveThinking(model);
+		if (resolved.thinkingEnabled) resolved.effort = "high";
+		return resolved;
+	}
+	if (supportsAdaptiveThinking(model)) {
+		resolved.thinkingEnabled = true;
+		resolved.effort = mapThinkingLevelToEffort(reasoning, model);
+		return resolved;
+	}
+	const adjusted = adjustMaxTokensForThinking({
+		baseMaxTokens,
+		modelMaxTokens: reasoningModelMaxTokens,
+		reasoningLevel: reasoning,
+		customBudgets: options?.thinkingBudgets
+	});
+	const thinkingEnabled = adjusted.thinkingBudget >= 1024;
+	resolved.maxTokens = adjusted.maxTokens;
+	resolved.thinkingEnabled = thinkingEnabled;
+	resolved.thinkingBudgetTokens = thinkingEnabled ? adjusted.thinkingBudget : void 0;
+	return resolved;
+}
+/** Create the stream function used by Anthropic Messages transport models. */
+function createAnthropicMessagesTransportStreamFn() {
+	return (rawModel, context, rawOptions) => {
+		const model = withEffectiveAnthropicBaseUrl(rawModel);
+		const options = rawOptions;
+		const { eventStream, stream } = createWritableTransportEventStream();
+		(async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: "anthropic-messages",
+				provider: model.provider,
+				model: model.id,
+				usage: createEmptyTransportUsage(),
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			const refusalBuffer = usesClaudeStreamingRefusalContract(model) ? createDeferredEventBuffer(stream, () => notifyLlmRequestActivity(options?.signal)) : void 0;
+			const eventSink = refusalBuffer ?? stream;
+			let costModel = model;
+			let messageStartPromptUsage;
+			try {
+				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+				if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+				const transportOptions = resolveAnthropicTransportOptions(model, options, apiKey);
+				const requestContext = prepareClaudeNoPrefillRequestContext(model, context);
+				const { client, isOAuthToken } = createAnthropicTransportClient({
+					model,
+					context: requestContext,
+					apiKey,
+					options: transportOptions
+				});
+				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions);
+				let params = builtParams.params;
+				const toolProjection = builtParams.toolProjection;
+				const nextParams = await transportOptions.onPayload?.(params, model);
+				if (nextParams !== void 0) params = nextParams;
+				applyClaudeRequestContract(params, model);
+				const anthropicStream = client.messages.stream({
+					...params,
+					stream: true
+				}, transportOptions.signal ? { signal: transportOptions.signal } : void 0);
+				const blocks = output.content;
+				const blockIndexes = /* @__PURE__ */ new Map();
+				const pendingThinkingSignatures = /* @__PURE__ */ new Map();
+				const allowReasoningContentReplay = supportsReasoningContentReplay(model);
+				const reasoningContentThinkingBlocks = /* @__PURE__ */ new Map();
+				const reasoningContentTextBlocks = /* @__PURE__ */ new Map();
+				let sawMessageStop = false;
+				const pendingTextEnds = [];
+				const flushPendingTextEnds = () => {
+					for (const event of pendingTextEnds) eventSink.push(event);
+					pendingTextEnds.length = 0;
+				};
+				const eventIndexKey = (eventIndex) => typeof eventIndex === "number" ? eventIndex : -1;
+				const appendReasoningContentThinkingDelta = (eventIndex, rawText) => {
+					if (typeof rawText !== "string") return false;
+					const text = sanitizeTransportPayloadText(rawText);
+					if (text.length === 0) return false;
+					const key = eventIndexKey(eventIndex);
+					let contentIndex = reasoningContentThinkingBlocks.get(key);
+					let block = contentIndex === void 0 ? void 0 : output.content[contentIndex];
+					if (!block || block.type !== "thinking") {
+						block = {
+							type: "thinking",
+							thinking: "",
+							thinkingSignature: "reasoning_content"
+						};
+						output.content.push(block);
+						contentIndex = output.content.length - 1;
+						reasoningContentThinkingBlocks.set(key, contentIndex);
+						eventSink.push({
+							type: "thinking_start",
+							contentIndex,
+							partial: output
+						});
+					}
+					block.thinking += text;
+					block.thinkingSignature = "reasoning_content";
+					eventSink.push({
+						type: "thinking_delta",
+						contentIndex,
+						delta: text,
+						partial: output
+					});
+					return true;
+				};
+				const appendReasoningContentTextDelta = (eventIndex, rawText) => {
+					if (typeof rawText !== "string") return false;
+					const text = sanitizeTransportPayloadText(rawText);
+					if (text.length === 0) return false;
+					const key = eventIndexKey(eventIndex);
+					let contentIndex = reasoningContentTextBlocks.get(key);
+					let block = contentIndex === void 0 ? void 0 : output.content[contentIndex];
+					if (!block || block.type !== "text") {
+						block = {
+							type: "text",
+							text: ""
+						};
+						output.content.push(block);
+						contentIndex = output.content.length - 1;
+						reasoningContentTextBlocks.set(key, contentIndex);
+						eventSink.push({
+							type: "text_start",
+							contentIndex,
+							partial: output
+						});
+					}
+					block.text += text;
+					eventSink.push({
+						type: "text_delta",
+						contentIndex,
+						delta: text,
+						partial: output
+					});
+					return true;
+				};
+				const finishReasoningContentSidecars = (eventIndex) => {
+					const key = eventIndexKey(eventIndex);
+					const thinkingContentIndex = reasoningContentThinkingBlocks.get(key);
+					if (thinkingContentIndex !== void 0) {
+						reasoningContentThinkingBlocks.delete(key);
+						const block = output.content[thinkingContentIndex];
+						if (block?.type === "thinking") eventSink.push({
+							type: "thinking_end",
+							contentIndex: thinkingContentIndex,
+							content: block.thinking,
+							partial: output
+						});
+					}
+					const textContentIndex = reasoningContentTextBlocks.get(key);
+					if (textContentIndex === void 0) return;
+					reasoningContentTextBlocks.delete(key);
+					const block = output.content[textContentIndex];
+					if (block?.type === "text") eventSink.push({
+						type: "text_end",
+						contentIndex: textContentIndex,
+						content: block.text,
+						partial: output
+					});
+				};
+				for await (const event of anthropicStream) {
+					if (event.type === "error") {
+						const error = event.error;
+						throw new Error(error?.message || "Anthropic Messages stream failed");
+					}
+					if (event.type === "message_start") {
+						const message = event.message;
+						const usage = message?.usage ?? {};
+						output.responseId = typeof message?.id === "string" ? message.id : void 0;
+						output.responseModel = typeof message?.model === "string" ? message.model : void 0;
+						const promptUsage = readAnthropicPromptUsageSnapshot(usage);
+						const messageStartPromptTokens = promptUsage ? promptUsage.input + promptUsage.cacheRead + promptUsage.cacheWrite : 0;
+						messageStartPromptUsage = messageStartPromptTokens > 0 ? promptUsage : void 0;
+						const inputTokens = readAnthropicUsageTokenCount(usage.input_tokens);
+						if (inputTokens !== void 0) output.usage.input = inputTokens;
+						const outputTokens = readAnthropicUsageTokenCount(usage.output_tokens);
+						if (outputTokens !== void 0) output.usage.output = outputTokens;
+						const cacheReadTokens = usage.cache_read_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_read_input_tokens);
+						if (cacheReadTokens !== void 0) output.usage.cacheRead = cacheReadTokens;
+						const cacheWriteTokens = usage.cache_creation_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_creation_input_tokens);
+						if (cacheWriteTokens !== void 0) output.usage.cacheWrite = cacheWriteTokens;
+						output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+						if (messageStartPromptUsage && outputTokens !== void 0) output.usage.contextUsage = {
+							state: "available",
+							promptTokens: messageStartPromptTokens,
+							totalTokens: messageStartPromptTokens + output.usage.output
+						};
+						calculateCost(costModel, output.usage);
+						eventSink.push({
+							type: "start",
+							partial: output
+						});
+						continue;
+					}
+					if (event.type === "message_stop") {
+						sawMessageStop = true;
+						continue;
+					}
+					if (event.type === "content_block_start") {
+						const contentBlock = event.content_block;
+						const index = typeof event.index === "number" ? event.index : -1;
+						const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(contentBlock) : null;
+						if (fallbackBoundary) {
+							refusalBuffer?.discard();
+							pendingTextEnds.length = 0;
+							blockIndexes.clear();
+							pendingThinkingSignatures.clear();
+							applyAnthropicFallbackBoundary({
+								output,
+								boundary: fallbackBoundary,
+								provider: model.provider
+							});
+							costModel = {
+								...model,
+								cost: resolveAnthropicFallbackServingModelCost({
+									requestedModelId: model.id,
+									servingModelId: fallbackBoundary.toModel,
+									requestedCost: model.cost
+								})
+							};
+							calculateCost(costModel, output.usage);
+							eventSink.push({
+								type: "start",
+								partial: output
+							});
+							for (const [i, block] of output.content.entries()) {
+								if (block.type !== "text") continue;
+								delete block.index;
+								eventSink.push({
+									type: "text_start",
+									contentIndex: i,
+									partial: output
+								});
+								if (block.text) eventSink.push({
+									type: "text_delta",
+									contentIndex: i,
+									delta: block.text,
+									partial: output
+								});
+								pendingTextEnds.push({
+									type: "text_end",
+									contentIndex: i,
+									content: block.text,
+									partial: output
+								});
+							}
+							continue;
+						}
+						pendingThinkingSignatures.delete(index);
+						if (contentBlock?.type === "text") {
+							const text = typeof contentBlock.text === "string" ? sanitizeTransportPayloadText(contentBlock.text) : "";
+							const block = {
+								type: "text",
+								text,
+								index
+							};
+							output.content.push(block);
+							const contentIndex = output.content.length - 1;
+							blockIndexes.set(index, contentIndex);
+							eventSink.push({
+								type: "text_start",
+								contentIndex,
+								partial: output
+							});
+							if (text.length > 0) eventSink.push({
+								type: "text_delta",
+								contentIndex,
+								delta: text,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "thinking") {
+							const thinking = typeof contentBlock.thinking === "string" ? contentBlock.thinking : "";
+							const block = {
+								type: "thinking",
+								thinking,
+								thinkingSignature: typeof contentBlock.signature === "string" ? contentBlock.signature : "",
+								index
+							};
+							output.content.push(block);
+							const contentIndex = output.content.length - 1;
+							blockIndexes.set(index, contentIndex);
+							eventSink.push({
+								type: "thinking_start",
+								contentIndex,
+								partial: output
+							});
+							if (thinking.length > 0) eventSink.push({
+								type: "thinking_delta",
+								contentIndex,
+								delta: thinking,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "redacted_thinking") {
+							const block = {
+								type: "thinking",
+								thinking: "[Reasoning redacted]",
+								thinkingSignature: typeof contentBlock.data === "string" ? contentBlock.data : "",
+								redacted: true,
+								index
+							};
+							output.content.push(block);
+							blockIndexes.set(index, output.content.length - 1);
+							eventSink.push({
+								type: "thinking_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+							continue;
+						}
+						if (contentBlock?.type === "tool_use") {
+							tagPendingCommentaryText(output.content);
+							flushPendingTextEnds();
+							const block = {
+								type: "toolCall",
+								id: typeof contentBlock.id === "string" ? contentBlock.id : "",
+								name: typeof contentBlock.name === "string" ? isOAuthToken ? resolveOriginalAnthropicToolName(contentBlock.name, toolProjection) : contentBlock.name : "",
+								arguments: contentBlock.input && typeof contentBlock.input === "object" ? contentBlock.input : {},
+								partialJson: "",
+								index
+							};
+							output.content.push(block);
+							blockIndexes.set(index, output.content.length - 1);
+							eventSink.push({
+								type: "toolcall_start",
+								contentIndex: output.content.length - 1,
+								partial: output
+							});
+						}
+						continue;
+					}
+					if (event.type === "content_block_delta") {
+						const delta = event.delta;
+						const eventIndex = typeof event.index === "number" ? event.index : void 0;
+						let index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
+						let block = index === void 0 ? void 0 : blocks[index];
+						if (allowReasoningContentReplay) {
+							const appendedThinking = appendReasoningContentThinkingDelta(event.index, delta?.reasoning_content);
+							const hasNativeAnthropicDelta = delta?.type === "text_delta" && typeof delta.text === "string" || delta?.type === "thinking_delta" && typeof delta.thinking === "string" || delta?.type === "input_json_delta" && typeof delta.partial_json === "string" || delta?.type === "signature_delta" && typeof delta.signature === "string";
+							let appendedContent = false;
+							if (!hasNativeAnthropicDelta && typeof delta?.content === "string" && delta.content.length > 0) {
+								const text = sanitizeTransportPayloadText(delta.content);
+								if (text.length > 0) if (block?.type === "text") {
+									block.text += text;
+									eventSink.push({
+										type: "text_delta",
+										contentIndex: index,
+										delta: text,
+										partial: output
+									});
+									appendedContent = true;
+								} else appendedContent = appendReasoningContentTextDelta(event.index, text);
+							}
+							if ((appendedThinking || appendedContent) && !hasNativeAnthropicDelta) continue;
+						}
+						if (!block && delta?.type === "text_delta" && typeof delta.text === "string") {
+							block = {
+								type: "text",
+								text: "",
+								index: typeof event.index === "number" ? event.index : blocks.length
+							};
+							output.content.push(block);
+							index = output.content.length - 1;
+							if (typeof event.index === "number") blockIndexes.set(event.index, index);
+							eventSink.push({
+								type: "text_start",
+								contentIndex: index,
+								partial: output
+							});
+						}
+						if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
+							block.text += delta.text;
+							eventSink.push({
+								type: "text_delta",
+								contentIndex: index,
+								delta: delta.text,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "thinking" && delta?.type === "thinking_delta" && typeof delta.thinking === "string") {
+							block.thinking += delta.thinking;
+							eventSink.push({
+								type: "thinking_delta",
+								contentIndex: index,
+								delta: delta.thinking,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "toolCall" && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+							const partialJson = `${block.partialJson ?? ""}${delta.partial_json}`;
+							block.partialJson = partialJson;
+							block.arguments = parseAnthropicToolCallArguments(partialJson);
+							eventSink.push({
+								type: "toolcall_delta",
+								contentIndex: index,
+								delta: delta.partial_json,
+								partial: output
+							});
+							continue;
+						}
+						if (block?.type === "thinking" && delta?.type === "signature_delta" && typeof delta.signature === "string") {
+							const signatureIndex = eventIndexKey(event.index);
+							const pendingSignature = pendingThinkingSignatures.get(signatureIndex);
+							if (pendingSignature === void 0) {
+								block.thinkingSignature = "";
+								pendingThinkingSignatures.set(signatureIndex, delta.signature);
+							} else pendingThinkingSignatures.set(signatureIndex, pendingSignature + delta.signature);
+						}
+						continue;
+					}
+					if (event.type === "content_block_stop") {
+						const eventIndex = typeof event.index === "number" ? event.index : void 0;
+						const pendingSignature = eventIndex === void 0 ? void 0 : pendingThinkingSignatures.get(eventIndex);
+						if (eventIndex !== void 0) pendingThinkingSignatures.delete(eventIndex);
+						const index = eventIndex === void 0 ? void 0 : blockIndexes.get(eventIndex);
+						const block = index === void 0 ? void 0 : blocks[index];
+						if (eventIndex === void 0 || index === void 0 || !block) {
+							finishReasoningContentSidecars(event.index);
+							continue;
+						}
+						blockIndexes.delete(eventIndex);
+						delete block.index;
+						if (block.type === "text") {
+							pendingTextEnds.push({
+								type: "text_end",
+								contentIndex: index,
+								content: block.text,
+								partial: output
+							});
+							finishReasoningContentSidecars(event.index);
+							continue;
+						}
+						if (block.type === "thinking") {
+							if (pendingSignature !== void 0) block.thinkingSignature = pendingSignature;
+							eventSink.push({
+								type: "thinking_end",
+								contentIndex: index,
+								content: block.thinking,
+								partial: output
+							});
+							finishReasoningContentSidecars(event.index);
+							continue;
+						}
+						if (block.type === "toolCall") {
+							delete block.partialJson;
+							eventSink.push({
+								type: "toolcall_end",
+								contentIndex: index,
+								toolCall: block,
+								partial: output
+							});
+							finishReasoningContentSidecars(event.index);
+						}
+						continue;
+					}
+					if (event.type === "message_delta") {
+						const delta = event.delta;
+						const usage = event.usage;
+						if (delta?.stop_reason) if (delta.stop_reason === "refusal") applyAnthropicRefusal(output, delta.stop_details, model.provider);
+						else output.stopReason = mapStopReason(delta.stop_reason);
+						const inputTokens = readAnthropicUsageTokenCount(usage?.input_tokens);
+						if (inputTokens !== void 0) output.usage.input = inputTokens;
+						const outputTokens = readAnthropicUsageTokenCount(usage?.output_tokens);
+						if (outputTokens !== void 0) output.usage.output = outputTokens;
+						const cacheReadTokens = readAnthropicUsageTokenCount(usage?.cache_read_input_tokens);
+						if (cacheReadTokens !== void 0) output.usage.cacheRead = cacheReadTokens;
+						const cacheWriteTokens = readAnthropicUsageTokenCount(usage?.cache_creation_input_tokens);
+						if (cacheWriteTokens !== void 0) output.usage.cacheWrite = cacheWriteTokens;
+						output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+						const iterationUsage = readLastAnthropicIterationUsage(usage ?? {});
+						if (iterationUsage.state === "valid") output.usage.contextUsage = {
+							state: "available",
+							promptTokens: iterationUsage.usage.contextPromptTokens,
+							totalTokens: iterationUsage.usage.totalTokens
+						};
+						else if (iterationUsage.state === "invalid") output.usage.contextUsage = { state: "unavailable" };
+						else if (outputTokens !== void 0 && (messageStartPromptUsage !== void 0 || inputTokens !== void 0 && cacheReadTokens !== void 0 && cacheWriteTokens !== void 0)) {
+							const promptTokens = output.usage.input + output.usage.cacheRead + output.usage.cacheWrite;
+							output.usage.contextUsage = {
+								state: "available",
+								promptTokens,
+								totalTokens: promptTokens + output.usage.output
+							};
+						} else output.usage.contextUsage = { state: "unavailable" };
+						calculateCost(costModel, output.usage);
+						if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
+						flushPendingTextEnds();
+					}
+				}
+				if (refusalBuffer && !sawMessageStop) throw new Error("Anthropic stream ended before message_stop");
+				if (transportOptions.signal?.aborted) throw transportAbortError(transportOptions.signal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+				refusalBuffer?.flush();
+				if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
+				flushPendingTextEnds();
+				finalizeTransportStream({
+					stream,
+					output
+				});
+			} catch (error) {
+				if (refusalBuffer) {
+					refusalBuffer.discard();
+					output.content = [];
+				}
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error,
+					cleanup: () => {
+						for (const block of output.content) delete block.index;
+					}
+				});
+			}
+		})();
+		return eventStream;
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/deepseek-text-filter.ts
+/**
+* DeepSeek DSML streaming text filter.
+* Removes provider-emitted DSML tool markup while buffering split tag prefixes
+* across streamed chunks.
+*/
+const DSML_KINDS = [
+	"tool_use_error",
+	"tool_calls",
+	"tool_call",
+	"function_calls"
+];
+const DSML_BARS = ["|", "｜"];
+const DSML_OPEN_TOKENS = DSML_BARS.flatMap((bar) => DSML_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
+const DSML_CLOSE_TOKENS = DSML_BARS.flatMap((bar) => DSML_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
+const MAX_OPEN_TOKEN_LEN = Math.max(...DSML_OPEN_TOKENS.map((token) => token.length));
+const MAX_CLOSE_TOKEN_LEN = Math.max(...DSML_CLOSE_TOKENS.map((token) => token.length));
+/** Create an incremental text filter that strips DeepSeek DSML tool blocks. */
+function createDeepSeekTextFilter() {
+	let buffer = "";
+	let insideDsml = false;
+	const consume = (final) => {
+		const output = [];
+		const emit = (text) => {
+			if (text) output.push(text);
+		};
+		while (buffer) {
+			if (insideDsml) {
+				const close = findEarliestToken(buffer, DSML_CLOSE_TOKENS);
+				if (close) {
+					buffer = buffer.slice(close.index + close.token.length);
+					insideDsml = false;
+					continue;
+				}
+				const keep = final ? 0 : Math.min(buffer.length, MAX_CLOSE_TOKEN_LEN - 1);
+				buffer = buffer.slice(buffer.length - keep);
+				if (final) insideDsml = false;
+				return output;
+			}
+			const open = findEarliestToken(buffer, DSML_OPEN_TOKENS);
+			if (open) {
+				emit(buffer.slice(0, open.index));
+				buffer = buffer.slice(open.index + open.token.length);
+				insideDsml = true;
+				continue;
+			}
+			if (final) {
+				emit(buffer);
+				buffer = "";
+				return output;
+			}
+			const keep = longestDsmlOpenPrefixSuffixLength(buffer);
+			const emitLength = buffer.length - keep;
+			if (emitLength <= 0) return output;
+			emit(buffer.slice(0, emitLength));
+			buffer = buffer.slice(emitLength);
+			return output;
+		}
+		return output;
+	};
+	return {
+		push(chunk) {
+			buffer += chunk;
+			return consume(false);
+		},
+		flush() {
+			return consume(true);
+		}
+	};
+}
+function findEarliestToken(text, tokens) {
+	let best = null;
+	for (const token of tokens) {
+		const index = text.indexOf(token);
+		if (index !== -1 && (!best || index < best.index)) best = {
+			index,
+			token
+		};
+	}
+	return best;
+}
+function longestDsmlOpenPrefixSuffixLength(text) {
+	const maxLength = Math.min(text.length, MAX_OPEN_TOKEN_LEN - 1);
+	for (let length = maxLength; length > 0; length--) {
+		const suffix = text.slice(text.length - length);
+		if (DSML_OPEN_TOKENS.some((token) => token.startsWith(suffix))) return length;
+	}
+	return 0;
+}
+//#endregion
+//#region packages/ai/src/transports/model-max-tokens-params.ts
+/**
+* Max-token parameter normalization across provider/native naming variants.
+* Callers canonicalize aliases before dispatch so payloads cannot carry
+* conflicting limits.
+*/
+const MAX_TOKENS_PARAM_KEYS = [
+	"maxTokens",
+	"max_completion_tokens",
+	"max_tokens"
+];
+/** Return a finite non-negative max-token value, or undefined for invalid input. */
+function resolveNonNegativeMaxTokensParam(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+/** Resolve the first supported max-token parameter present in a params object. */
+function resolveMaxTokensParam(params) {
+	if (!params) return;
+	for (const key of MAX_TOKENS_PARAM_KEYS) {
+		const resolved = resolveNonNegativeMaxTokensParam(params[key]);
+		if (resolved !== void 0) return resolved;
+	}
+}
+/**
+* Canonicalize merged params to `maxTokens`, preserving source precedence from
+* left to right across the provided source objects.
+*/
+function canonicalizeMaxTokensParam(params) {
+	let resolved;
+	for (const source of params.sources) {
+		const sourceValue = resolveMaxTokensParam(source);
+		if (sourceValue !== void 0) resolved = sourceValue;
+	}
+	if (resolved === void 0) return;
+	for (const key of MAX_TOKENS_PARAM_KEYS) delete params.merged[key];
+	params.merged.maxTokens = resolved;
+}
+//#endregion
+//#region packages/ai/src/transports/model-transport-url.ts
+/**
+* Debug formatting helpers for model transport endpoints.
+* Keeps logs useful without exposing credentials, request params, or fragments.
+*/
+/** Return a sanitized URL suitable for logs and diagnostics. */
+function formatModelTransportDebugUrl(rawUrl) {
+	try {
+		const parsed = new URL(rawUrl);
+		parsed.username = "";
+		parsed.password = "";
+		parsed.search = "";
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return "<invalid-url>";
+	}
+}
+/** Format a configured base URL for debug output, or the implicit default. */
+function formatModelTransportDebugBaseUrl(rawUrl) {
+	return rawUrl ? formatModelTransportDebugUrl(rawUrl) : "default";
+}
+//#endregion
+//#region packages/ai/src/transports/openai-compatible-conversation-turn.ts
+/**
+* OpenAI-compatible conversation turn detector.
+*
+* Some providers reject requests without a non-empty user/assistant turn; this
+* helper checks the loose message payload shape before transport submission.
+*/
+function hasNonEmptyContentPart(part) {
+	if (!part || typeof part !== "object") return false;
+	const record = part;
+	if (record.type === "text") return hasNonEmptyString(record.text);
+	return true;
+}
+function hasNonEmptyMessageContent(content) {
+	if (hasNonEmptyString(content)) return true;
+	if (!Array.isArray(content)) return false;
+	return content.some(hasNonEmptyContentPart);
+}
+function hasAssistantToolCall(message) {
+	const toolCalls = message.tool_calls;
+	return Array.isArray(toolCalls) && toolCalls.some((toolCall) => {
+		return Boolean(toolCall && typeof toolCall === "object");
+	});
+}
+/** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
+function hasOpenAICompatibleConversationTurn(messages) {
+	if (!Array.isArray(messages)) return false;
+	return messages.some((message) => {
+		if (!message || typeof message !== "object") return false;
+		const record = message;
+		if (record.role === "user") return hasNonEmptyMessageContent(record.content);
+		if (record.role === "assistant") return hasNonEmptyMessageContent(record.content) || hasAssistantToolCall(record);
+		return false;
+	});
+}
+//#endregion
+//#region packages/ai/src/transports/openai-completions-string-content.ts
+/**
+* OpenAI Chat Completions compatibility helpers. Some providers only accept
+* role/content messages with plain string content instead of text block arrays.
+*/
+function flattenStringOnlyCompletionContent(content) {
+	if (!Array.isArray(content)) return content;
+	const textParts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object" || item.type !== "text" || typeof item.text !== "string") return content;
+		textParts.push(item.text);
+	}
+	return textParts.join("\n");
+}
+/** Flatten string-only text block content arrays into newline-joined strings. */
+function flattenCompletionMessagesToStringContent(messages) {
+	return messages.map((message) => {
+		if (!message || typeof message !== "object") return message;
+		const content = message.content;
+		const flattenedContent = flattenStringOnlyCompletionContent(content);
+		if (flattenedContent === content) return message;
+		return {
+			...message,
+			content: flattenedContent
+		};
+	});
+}
+/** Strip completion messages to role/content fields for strict providers. */
+function stripCompletionMessagesToRoleContent(messages) {
+	return messages.map((message) => {
+		if (!message || typeof message !== "object" || Array.isArray(message)) return message;
+		const record = message;
+		const stripped = {};
+		if (Object.hasOwn(record, "role")) stripped.role = record.role;
+		if (Object.hasOwn(record, "content")) stripped.content = record.content;
+		return stripped;
+	});
+}
+//#endregion
+//#region packages/ai/src/transports/openai-transport-params.ts
+const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
+const OPENAI_CODEX_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
+const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
+function readToolPayloadField(record, field) {
+	try {
+		return record[field];
+	} catch {
+		return;
+	}
+}
+function transportPayloadToolName(tool) {
+	if (!isRecord(tool)) return;
+	const name = readToolPayloadField(tool, "name");
+	if (typeof name === "string") return name;
+	const fn = readToolPayloadField(tool, "function");
+	if (!isRecord(fn)) return;
+	const fnName = readToolPayloadField(fn, "name");
+	return typeof fnName === "string" ? fnName : void 0;
+}
+function enforceCodeModeResponsesToolSurface(payload) {
+	if (!isRecord(payload) || !Array.isArray(payload.tools)) return;
+	payload.tools = payload.tools.filter((tool) => {
+		const name = transportPayloadToolName(tool);
+		return typeof name === "string" && isCodeModeModelVisibleToolName(name);
+	});
+}
+function assertCodeModeResponsesToolSurface(payload) {
+	if (!isRecord(payload) || !Array.isArray(payload.tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
+	const names = payload.tools.map(transportPayloadToolName).filter((name) => typeof name === "string" && name.length > 0).toSorted((left, right) => left.localeCompare(right));
+	if (names.length >= 2 && new Set(names).size === names.length && names.filter((name) => name === "exec").length === 1 && names.filter((name) => name === "wait").length === 1 && names.every(isCodeModeModelVisibleToolName)) return;
+	throw new Error(`Code mode payload tool surface violation: expected exec,wait plus direct-only tools; got ${names.length > 0 ? names.join(",") : "none"}`);
+}
+function buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context) {
+	return sha256Hex(JSON.stringify({
+		transport: context.transport,
+		provider: context.model.provider ?? null,
+		model: context.model.id ?? null,
+		diagnostics: diagnostics.map((entry) => ({
+			toolIndex: entry.toolIndex,
+			toolName: entry.toolName ?? null,
+			violations: entry.violations
+		}))
+	}));
+}
+function shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context) {
+	const key = buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context);
+	if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.has(key)) return false;
+	if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.size >= MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedOpenAIStrictToolDowngradeDiagnosticKeys.clear();
+	loggedOpenAIStrictToolDowngradeDiagnosticKeys.add(key);
+	return true;
+}
+function resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, context) {
+	const strict = resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
+	if (strictSetting === true && strict === false) {
+		const diagnostics = findOpenAIStrictToolProjectionDiagnostics(projection);
+		getAiTransportHost().logDebug("openai-transport", () => {
+			if (!shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context)) return null;
+			const sample = diagnostics.slice(0, 5).map((entry) => ({
+				tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
+				violations: entry.violations.slice(0, 8)
+			}));
+			return {
+				message: `OpenAI ${context.transport} tool schema strict mode downgraded to strict=false for ${context.model.provider ?? "unknown"}/${context.model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`,
+				data: {
+					transport: context.transport,
+					provider: context.model.provider,
+					model: context.model.id,
+					incompatibleToolCount: diagnostics.length,
+					sample
+				}
+			};
+		});
+	}
+	return strict;
+}
+function isOpenAICodexResponsesModel(model) {
+	return OPENAI_CODEX_RESPONSES_PROVIDERS.has(model.provider) && (model.api === "openai-chatgpt-responses" || model.api === "openclaw-openai-chatgpt-responses-transport");
+}
+function isNativeOpenAICodexResponsesBaseUrl(baseUrl) {
+	const trimmed = typeof baseUrl === "string" ? baseUrl.trim() : "";
+	if (!trimmed) return false;
+	try {
+		const url = new URL(trimmed);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+		if (url.hostname.toLowerCase() !== "chatgpt.com") return false;
+		const pathname = url.pathname.replace(/\/+$/u, "").toLowerCase();
+		return [
+			"/backend-api",
+			"/backend-api/v1",
+			"/backend-api/codex",
+			"/backend-api/codex/v1"
+		].includes(pathname);
+	} catch {
+		return false;
+	}
+}
+function usesNativeOpenAICodexResponsesBackend(model) {
+	return isOpenAICodexResponsesModel(model) && isNativeOpenAICodexResponsesBaseUrl(model.baseUrl);
+}
+function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId) {
+	const providerHeaders = { ...model.headers };
+	if (model.provider === "github-copilot") Object.assign(providerHeaders, getAiTransportHost().buildCopilotDynamicHeaders(context.messages));
+	const callerHeaders = {
+		...optionHeaders,
+		...turnHeaders
+	};
+	const resolvedHeaders = resolveProviderRequestPolicyConfig({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		capability: "llm",
+		transport: "stream",
+		providerHeaders,
+		callerHeaders: Object.keys(callerHeaders).length > 0 ? callerHeaders : void 0,
+		precedence: "caller-wins"
+	}).headers ?? {};
+	if (sessionId && !Object.keys(resolvedHeaders).some((key) => normalizeLowercaseStringOrEmpty(key) === "session_id") && usesNativeOpenAICodexResponsesBackend(model)) resolvedHeaders.session_id = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
+	return resolvedHeaders;
+}
+function resolveOpenAISdkTimeoutMs(model) {
+	return resolveModelRequestTimeoutMs(model, void 0);
+}
+function buildOpenAISdkClientOptions(model) {
+	const timeout = resolveOpenAISdkTimeoutMs(model);
+	return timeout === void 0 ? {} : { timeout };
+}
+function buildOpenAISdkRequestOptions(model, signal, options) {
+	const timeout = resolveOpenAISdkTimeoutMs(model);
+	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
+	if (timeout === void 0 && !signal && !headers) return;
+	return {
+		...headers ? { headers } : {},
+		...signal ? { signal } : {},
+		...timeout !== void 0 ? { timeout } : {}
+	};
+}
+function getCompat(model) {
+	const resolved = resolveOpenAICompletionsCompat(model);
+	const compat = model.compat ?? {};
+	return {
+		...resolved,
+		cacheControlFormat: resolved.cacheControlFormat,
+		reasoningEffortMap: resolveOpenAIReasoningEffortMap(model, {}),
+		openRouterRouting: resolved.openRouterRouting ?? {},
+		vercelGatewayRouting: resolved.vercelGatewayRouting,
+		requiresStringContent: compat.requiresStringContent ?? false,
+		strictMessageKeys: compat.strictMessageKeys === true
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-completions-transport.ts
+function hasToolHistory(messages) {
+	return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall"));
+}
+function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
+	const messages = params.messages;
+	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
+	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
+}
+const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
+const SSE_DONE_MAX_LINE_CHARS = 1024;
+function createSseDoneDetector() {
+	const decoder = new TextDecoder();
+	let line = "";
+	let lineOverflowed = false;
+	let sawDone = false;
+	const finishLine = () => {
+		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
+		line = "";
+		lineOverflowed = false;
+	};
+	const observeText = (text) => {
+		for (const char of text) {
+			if (char === "\n" || char === "\r") {
+				finishLine();
+				continue;
+			}
+			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
+			else lineOverflowed = true;
+		}
+	};
+	return {
+		observe(chunk) {
+			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
+		},
+		finish() {
+			if (sawDone) return;
+			observeText(decoder.decode());
+			if (line || lineOverflowed) finishLine();
+		},
+		sawDone: () => sawDone
+	};
+}
+function createOpenAICompletionsClient(model, context, apiKey, optionHeaders, opts) {
+	const clientConfig = buildOpenAICompletionsClientConfig(model, context, optionHeaders);
+	return new OpenAI({
+		apiKey,
+		baseURL: clientConfig.baseURL,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: clientConfig.defaultHeaders,
+		defaultQuery: clientConfig.defaultQuery,
+		fetch: opts?.fetch ?? buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	});
+}
+function isAzureOpenAICompatibleHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+function isKnownOpenAICompletionsEndpoint(model) {
+	if (!model.baseUrl.trim()) return true;
+	const endpointClass = resolveProviderEndpoint(model.baseUrl).endpointClass;
+	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
+	try {
+		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
+	} catch {
+		return false;
+	}
+}
+function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
+	const headers = buildOpenAIClientHeaders(model, context, optionHeaders);
+	const defaultQuery = {};
+	let baseURL = model.baseUrl;
+	let isAzureHost = false;
+	try {
+		const parsed = new URL(model.baseUrl);
+		isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
+		parsed.searchParams.forEach((value, key) => {
+			if (value) defaultQuery[key] = value;
+		});
+		parsed.search = "";
+		baseURL = parsed.toString().replace(/\/$/, "");
+	} catch {}
+	if (isAzureHost) {
+		const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
+		if (apiVersionHeader) {
+			const apiVersion = headers[apiVersionHeader]?.trim();
+			delete headers[apiVersionHeader];
+			if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
+		}
+	}
+	return {
+		baseURL,
+		defaultHeaders: headers,
+		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
+	};
+}
+function createOpenAICompletionsTransportStreamFn() {
+	return (model, context, options) => {
+		const eventStream = createAssistantMessageEventStream();
+		const stream = eventStream;
+		(async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			let firstEventAbort;
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const doneDetector = createSseDoneDetector();
+				const baseFetch = buildGuardedModelFetch(model);
+				const doneDetectingFetch = async (url, init) => {
+					const response = await baseFetch(url, init);
+					if (!response.body || !response.ok) return response;
+					if (typeof TransformStream === "undefined" || !response.body.pipeThrough) return response;
+					const transformed = response.body.pipeThrough(new TransformStream({
+						transform(chunk, controller) {
+							doneDetector.observe(chunk);
+							controller.enqueue(chunk);
+						},
+						flush() {
+							doneDetector.finish();
+						}
+					}));
+					return new Response(transformed, {
+						headers: response.headers,
+						status: response.status,
+						statusText: response.statusText
+					});
+				};
+				const client = createOpenAICompletionsClient(model, context, apiKey, options?.headers, { fetch: doneDetectingFetch });
+				let params = buildOpenAICompletionsParams(model, context, options);
+				const nextParams = await options?.onPayload?.(params, model);
+				if (nextParams !== void 0) params = nextParams;
+				if (options?.openclawCodeModeToolSurface === true) {
+					enforceCodeModeResponsesToolSurface(params);
+					assertCodeModeResponsesToolSurface(params);
+				}
+				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
+				const emitReasoning = shouldEmitOpenAICompletionsReasoning(model, options);
+				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
+				const responseStream = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, firstEventAbort.signal));
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				await processOpenAICompletionsStream(responseStream, output, model, stream, {
+					signal: options?.signal,
+					emitReasoning,
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+					sawStreamDONE: doneDetector.sawDone
+				});
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: options?.signal
+				});
+			} catch (error) {
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error
+				});
+			} finally {
+				firstEventAbort?.dispose();
+			}
+		})();
+		return eventStream;
+	};
+}
+async function processOpenAICompletionsStream(responseStream, output, model, stream, options) {
+	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
+	const MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES = 256e3;
+	const emitReasoning = options?.emitReasoning ?? true;
+	const compat = getCompat(model);
+	const deepSeekTextFilter = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekTextFilter() : null;
+	const deepSeekToolCallRecoverer = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekDsmlToolCallRecoverer() : null;
+	const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
+	let currentBlock = null;
+	let pendingPostToolCallDeltas = [];
+	let pendingPostToolCallBytes = 0;
+	let isFlushingPendingPostToolCallDeltas = false;
+	const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
+	const toolCallBlocksById = /* @__PURE__ */ new Map();
+	const provisionalCommentaryTags = /* @__PURE__ */ new Map();
+	const toolCallBlockBytes = /* @__PURE__ */ new WeakMap();
+	const toolCallBlockIndices = /* @__PURE__ */ new WeakMap();
+	let sawStopFinishReason = false;
+	let sawNativeToolCallDelta = false;
+	const blockIndex = () => output.content.length - 1;
+	const measureUtf8Bytes = (text) => Buffer.byteLength(text, "utf8");
+	let chunkPushedEvent = false;
+	const pushStreamEvent = (event) => {
+		chunkPushedEvent = true;
+		stream.push(event);
+	};
+	const queuePostToolCallDelta = (next) => {
+		const nextBytes = measureUtf8Bytes(next.text);
+		if (pendingPostToolCallBytes + nextBytes > MAX_POST_TOOL_CALL_BUFFER_BYTES) throw new Error("Exceeded post-tool-call delta buffer limit");
+		pendingPostToolCallBytes += nextBytes;
+		const previous = pendingPostToolCallDeltas[pendingPostToolCallDeltas.length - 1];
+		if (!previous || previous.kind !== next.kind) {
+			pendingPostToolCallDeltas.push(next);
+			return;
+		}
+		if (next.kind === "thinking" && previous.kind === "thinking") {
+			if (previous.signature !== next.signature) {
+				pendingPostToolCallDeltas.push(next);
+				return;
+			}
+			previous.text += next.text;
+			return;
+		}
+		previous.text += next.text;
+	};
+	const appendThinkingDeltaInternal = (reasoningDelta) => {
+		if (!currentBlock || currentBlock.type !== "thinking") {
+			currentBlock = {
+				type: "thinking",
+				thinking: "",
+				...reasoningDelta.signature ? { thinkingSignature: reasoningDelta.signature } : {}
+			};
+			output.content.push(currentBlock);
+			pushStreamEvent({
+				type: "thinking_start",
+				contentIndex: blockIndex(),
+				partial: output
+			});
+		}
+		currentBlock.thinking += reasoningDelta.text;
+		pushStreamEvent({
+			type: "thinking_delta",
+			contentIndex: blockIndex(),
+			delta: reasoningDelta.text,
+			partial: output
+		});
+	};
+	const appendTextDeltaInternal = (text) => {
+		if (!currentBlock || currentBlock.type !== "text") {
+			currentBlock = {
+				type: "text",
+				text: ""
+			};
+			output.content.push(currentBlock);
+			pushStreamEvent({
+				type: "text_start",
+				contentIndex: blockIndex(),
+				partial: output
+			});
+		}
+		currentBlock.text += text;
+		pushStreamEvent({
+			type: "text_delta",
+			contentIndex: blockIndex(),
+			delta: text
+		});
+	};
+	const flushPendingPostToolCallDeltas = () => {
+		if (isFlushingPendingPostToolCallDeltas || currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
+		isFlushingPendingPostToolCallDeltas = true;
+		const bufferedDeltas = pendingPostToolCallDeltas;
+		pendingPostToolCallDeltas = [];
+		pendingPostToolCallBytes = 0;
+		for (const delta of bufferedDeltas) if (delta.kind === "text") appendTextDeltaInternal(delta.text);
+		else if (emitReasoning) appendThinkingDeltaInternal(delta);
+		isFlushingPendingPostToolCallDeltas = false;
+	};
+	const appendThinkingDelta = (reasoningDelta) => {
+		flushPendingPostToolCallDeltas();
+		appendThinkingDeltaInternal(reasoningDelta);
+	};
+	const appendTextDelta = (text) => {
+		flushPendingPostToolCallDeltas();
+		appendTextDeltaInternal(text);
+	};
+	const appendVisibleTextDelta = (text) => {
+		if (!text) return;
+		if (currentBlock?.type === "toolCall") queuePostToolCallDelta({
+			kind: "text",
+			text
+		});
+		else appendTextDelta(text);
+	};
+	const appendRecoveredToolCall = (toolCall) => {
+		if (currentBlock?.type === "toolCall") {
+			currentBlock = null;
+			flushPendingPostToolCallDeltas();
+		}
+		rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
+		const block = {
+			type: "toolCall",
+			id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+			name: toolCall.name,
+			arguments: toolCall.arguments,
+			partialArgs: toolCall.partialArgs
+		};
+		currentBlock = block;
+		output.content.push(block);
+		toolCallBlockIndices.set(block, output.content.length - 1);
+		pushStreamEvent({
+			type: "toolcall_start",
+			contentIndex: toolCallBlockIndices.get(block) ?? -1,
+			partial: output
+		});
+		pushStreamEvent({
+			type: "toolcall_delta",
+			contentIndex: toolCallBlockIndices.get(block) ?? -1,
+			delta: toolCall.partialArgs,
+			partial: output
+		});
+	};
+	const appendFilteredVisibleTextDelta = (text) => {
+		const recoveredParts = deepSeekToolCallRecoverer?.push(text) ?? [{
+			kind: "text",
+			text
+		}];
+		for (const recoveredPart of recoveredParts) {
+			if (recoveredPart.kind === "toolCall") {
+				appendRecoveredToolCall(recoveredPart);
+				continue;
+			}
+			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
+			for (const part of parts) appendVisibleTextDelta(part);
+		}
+	};
+	const flushDeepSeekToolCallRecovererAtEnd = () => {
+		const recoveredParts = deepSeekToolCallRecoverer?.flush();
+		if (!recoveredParts) return;
+		for (const recoveredPart of recoveredParts) {
+			if (recoveredPart.kind === "toolCall") {
+				appendRecoveredToolCall(recoveredPart);
+				continue;
+			}
+			const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
+			for (const part of parts) appendVisibleTextDelta(part);
+		}
+	};
+	const flushDeepSeekTextFilterAtEnd = () => {
+		const parts = deepSeekTextFilter?.flush();
+		if (!parts) return;
+		for (const part of parts) appendVisibleTextDelta(part);
+	};
+	const appendRoutedContentDelta = (delta) => {
+		if (delta.kind === "text") {
+			appendFilteredVisibleTextDelta(delta.text);
+			return;
+		}
+		if (!emitReasoning) return;
+		if (currentBlock?.type === "toolCall") queuePostToolCallDelta(delta);
+		else appendThinkingDelta(delta);
+	};
+	const appendPartitionedVisibleDelta = (delta) => {
+		if (delta.kind === "text") appendFilteredVisibleTextDelta(delta.text);
+	};
+	const emitReasoningUsageActivity = (hasReasoningUsageActivity) => {
+		if (!hasReasoningUsageActivity || chunkPushedEvent || !emitReasoning) return;
+		const latestBlock = output.content[output.content.length - 1];
+		if (currentBlock?.type === "text" || currentBlock?.type === "toolCall") return;
+		if (latestBlock?.type === "text" || latestBlock?.type === "toolCall") return;
+		appendThinkingDelta({
+			signature: "",
+			text: ""
+		});
+	};
+	const flushReasoningTagTextPartitionerAtEnd = () => {
+		for (const delta of reasoningTagTextPartitioner.flush()) appendPartitionedVisibleDelta(delta);
+	};
+	const cooperativeScheduler = createModelStreamCooperativeScheduler(options?.signal);
+	const guardedStream = withFirstStreamEventTimeout(responseStream, {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		timeoutMs: options?.firstEventTimeoutMs ?? 0,
+		stage: "completions",
+		abort: options?.abortFirstEventStream,
+		onTimeout: options?.onFirstEventTimeout,
+		hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
+	});
+	for await (const rawChunk of guardedStream) {
+		throwIfModelStreamAborted(options?.signal);
+		chunkPushedEvent = false;
+		if (!rawChunk || typeof rawChunk !== "object") {
+			await cooperativeScheduler.afterEvent();
+			continue;
+		}
+		const chunk = rawChunk;
+		output.responseId ||= chunk.id;
+		let hasReasoningUsageActivity = false;
+		if (chunk.usage) {
+			output.usage = parseTransportChunkUsage(chunk.usage, model);
+			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(chunk.usage);
+		}
+		const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
+		if (!choice) {
+			emitReasoningUsageActivity(hasReasoningUsageActivity);
+			await cooperativeScheduler.afterEvent();
+			continue;
+		}
+		const choiceUsage = choice.usage;
+		if (!chunk.usage && choiceUsage) {
+			output.usage = parseTransportChunkUsage(choiceUsage, model);
+			hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(choiceUsage);
+		}
+		if (choice.finish_reason) {
+			const finishReasonResult = mapOpenAIStopReason(choice.finish_reason, { allowSingularToolCall: true });
+			output.stopReason = finishReasonResult.stopReason;
+			if (finishReasonResult.stopReason === "stop") sawStopFinishReason = true;
+			if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
+		}
+		const choiceDelta = choice.delta ?? choice.message;
+		if (!choiceDelta) {
+			emitReasoningUsageActivity(hasReasoningUsageActivity);
+			await cooperativeScheduler.afterEvent();
+			continue;
+		}
+		const reasoningDeltas = getCompletionsReasoningDeltas(choiceDelta, compat.visibleReasoningDetailTypes);
+		const hasMirroredReasoning = reasoningDeltas.some((delta) => delta.kind === "thinking");
+		if (hasMirroredReasoning) reasoningTagTextPartitioner.markStrict();
+		if (choiceDelta.content) {
+			const contentDeltas = getCompletionsContentDeltas(choiceDelta.content);
+			for (const contentDelta of contentDeltas) if (contentDelta.kind === "text") {
+				const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(contentDelta.text) : reasoningTagTextPartitioner.pushVisible(contentDelta.text);
+				for (const routedDelta of routedDeltas) appendPartitionedVisibleDelta(routedDelta);
+			} else {
+				reasoningTagTextPartitioner.markStrict();
+				appendRoutedContentDelta(contentDelta);
+			}
+		}
+		const refusalText = typeof choiceDelta.refusal === "string" ? choiceDelta.refusal : "";
+		if (refusalText) {
+			const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(refusalText) : reasoningTagTextPartitioner.pushVisible(refusalText);
+			for (const routedDelta of routedDeltas) appendPartitionedVisibleDelta(routedDelta);
+		}
+		for (const reasoningDelta of reasoningDeltas) {
+			if (reasoningDelta.kind === "thinking" && !emitReasoning) continue;
+			if (currentBlock?.type === "toolCall") {
+				queuePostToolCallDelta({ ...reasoningDelta });
+				continue;
+			}
+			if (reasoningDelta.kind === "text") appendTextDelta(reasoningDelta.text);
+			else if (emitReasoning) appendThinkingDelta(reasoningDelta);
+		}
+		if (choiceDelta.tool_calls && choiceDelta.tool_calls.length > 0) {
+			sawNativeToolCallDelta = true;
+			flushReasoningTagTextPartitionerAtEnd();
+			rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
+			for (const toolCall of choiceDelta.tool_calls) {
+				const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
+				let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
+				if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
+				if (!block) {
+					if (currentBlock?.type === "toolCall") {
+						currentBlock = null;
+						flushPendingPostToolCallDeltas();
+					}
+					const initialSig = extractGoogleThoughtSignature(toolCall);
+					block = {
+						type: "toolCall",
+						id: toolCall.id || "",
+						name: toolCall.function?.name || "",
+						arguments: {},
+						partialArgs: "",
+						...initialSig ? { thoughtSignature: initialSig } : {}
+					};
+					output.content.push(block);
+					toolCallBlockIndices.set(block, output.content.length - 1);
+					pushStreamEvent({
+						type: "toolcall_start",
+						contentIndex: toolCallBlockIndices.get(block) ?? -1,
+						partial: output
+					});
+				}
+				if (streamIndex !== void 0 && !toolCallBlocksByIndex.has(streamIndex)) toolCallBlocksByIndex.set(streamIndex, block);
+				if (toolCall.id) {
+					block.id = toolCall.id;
+					toolCallBlocksById.set(toolCall.id, block);
+				}
+				currentBlock = block;
+				if (toolCall.function?.name) block.name = toolCall.function.name;
+				const deltaSig = extractGoogleThoughtSignature(toolCall);
+				if (deltaSig) block.thoughtSignature = deltaSig;
+				if (toolCall.function?.arguments) {
+					const nextArgumentBytes = measureUtf8Bytes(toolCall.function.arguments);
+					const currentBlockArgBytes = toolCallBlockBytes.get(block) ?? 0;
+					if (currentBlockArgBytes + nextArgumentBytes > MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+					toolCallBlockBytes.set(block, currentBlockArgBytes + nextArgumentBytes);
+					block.partialArgs += toolCall.function.arguments;
+					block.arguments = parseStreamingJson(block.partialArgs);
+					pushStreamEvent({
+						type: "toolcall_delta",
+						contentIndex: toolCallBlockIndices.get(block) ?? -1,
+						delta: toolCall.function.arguments,
+						partial: output
+					});
+				}
+			}
+		}
+		flushPendingPostToolCallDeltas();
+		emitReasoningUsageActivity(hasReasoningUsageActivity);
+		await cooperativeScheduler.afterEvent();
+	}
+	flushReasoningTagTextPartitionerAtEnd();
+	flushDeepSeekToolCallRecovererAtEnd();
+	flushDeepSeekTextFilterAtEnd();
+	currentBlock = null;
+	flushPendingPostToolCallDeltas();
+	const hasToolCalls = output.content.some((block) => block.type === "toolCall");
+	const hasVisibleText = output.content.some((block) => block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0);
+	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
+	if (output.stopReason === "stop" && hasToolCalls && !hasVisibleText && (sawStopFinishReason || sawNativeToolCallDelta && (options?.sawStreamDONE?.() ?? false))) output.stopReason = "toolUse";
+	if (hasToolCalls && output.stopReason !== "toolUse") output.content = output.content.filter((block) => block.type !== "toolCall");
+	if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
+	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
+}
+function shouldFilterDeepSeekDsmlText(compat) {
+	return compat.thinkingFormat === "deepseek";
+}
+const DEEPSEEK_DSML_BARS = ["|", "｜"];
+const DEEPSEEK_DSML_TOOL_KINDS = [
+	"tool_calls",
+	"tool_call",
+	"function_calls"
+];
+const DEEPSEEK_DSML_TOOL_OPEN_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
+const DEEPSEEK_DSML_TOOL_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
+const DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length));
+function createDeepSeekDsmlToolCallRecoverer() {
+	let buffer = "";
+	const consume = (final) => {
+		const output = [];
+		while (buffer) {
+			const open = findEarliestStringToken(buffer, DEEPSEEK_DSML_TOOL_OPEN_TOKENS);
+			if (!open) {
+				if (final) {
+					output.push({
+						kind: "text",
+						text: buffer
+					});
+					buffer = "";
+					return output;
+				}
+				const keep = longestDeepSeekDsmlToolOpenPrefixSuffixLength(buffer);
+				const emitLength = buffer.length - keep;
+				if (emitLength > 0) {
+					output.push({
+						kind: "text",
+						text: buffer.slice(0, emitLength)
+					});
+					buffer = buffer.slice(emitLength);
+				}
+				return output;
+			}
+			if (open.index > 0) {
+				output.push({
+					kind: "text",
+					text: buffer.slice(0, open.index)
+				});
+				buffer = buffer.slice(open.index);
+			}
+			const afterOpen = buffer.slice(open.token.length);
+			const close = findEarliestStringToken(afterOpen, DEEPSEEK_DSML_TOOL_CLOSE_TOKENS);
+			if (!close) {
+				if (final) {
+					output.push({
+						kind: "text",
+						text: buffer
+					});
+					buffer = "";
+				}
+				return output;
+			}
+			const body = afterOpen.slice(0, close.index);
+			const blockLength = open.token.length + close.index + close.token.length;
+			const recoveredToolCalls = parseDeepSeekDsmlToolCallBlock(body);
+			if (recoveredToolCalls.length > 0) output.push(...recoveredToolCalls);
+			else output.push({
+				kind: "text",
+				text: buffer.slice(0, blockLength)
+			});
+			buffer = buffer.slice(blockLength);
+		}
+		return output;
+	};
+	return {
+		push(chunk) {
+			buffer += chunk;
+			return consume(false);
+		},
+		flush() {
+			return consume(true);
+		}
+	};
+}
+function parseDeepSeekDsmlToolCallBlock(body) {
+	const toolCalls = [];
+	const invokeOpenRegex = /<[|｜]DSML[|｜]invoke\b([^>]*)>/g;
+	let openMatch;
+	while ((openMatch = invokeOpenRegex.exec(body)) !== null) {
+		const invokeName = parseXmlAttribute(openMatch[1] ?? "", "name");
+		if (!invokeName) continue;
+		const invokeBodyStart = openMatch.index + openMatch[0].length;
+		const invokeClose = findEarliestStringToken(body.slice(invokeBodyStart), ["</|DSML|invoke>", "</｜DSML｜invoke>"]);
+		if (!invokeClose) continue;
+		const invokeBody = body.slice(invokeBodyStart, invokeBodyStart + invokeClose.index);
+		invokeOpenRegex.lastIndex = invokeBodyStart + invokeClose.index + invokeClose.token.length;
+		const parsedArguments = parseDeepSeekDsmlInvokeArguments(invokeBody);
+		if (!parsedArguments) continue;
+		toolCalls.push({
+			kind: "toolCall",
+			name: invokeName,
+			arguments: parsedArguments,
+			partialArgs: JSON.stringify(parsedArguments)
+		});
+	}
+	return toolCalls;
+}
+function parseDeepSeekDsmlInvokeArguments(body) {
+	const args = {};
+	const parameterRegex = /<[|｜]DSML[|｜]parameter\b([^>]*)>([\s\S]*?)<\/[|｜]DSML[|｜]parameter>/g;
+	let parameterMatch;
+	while ((parameterMatch = parameterRegex.exec(body)) !== null) {
+		const name = parseXmlAttribute(parameterMatch[1] ?? "", "name");
+		if (!name) continue;
+		const rawValue = parameterMatch[2] ?? "";
+		if (rawValue.length === 0) continue;
+		args[name] = decodeDeepSeekDsmlText(rawValue);
+	}
+	if (Object.keys(args).length > 0) return args;
+	const trimmed = body.trim();
+	if (!trimmed.startsWith("{")) return null;
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (isRecord(parsed) && Object.keys(parsed).length > 0) return parsed;
+	} catch {
+		return null;
+	}
+	return null;
+}
+const xmlAttributeRegexCache = /* @__PURE__ */ new Map();
+function xmlAttributeRegex(name) {
+	const cached = xmlAttributeRegexCache.get(name);
+	if (cached) return cached;
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const pattern = new RegExp(`\\b${escaped}=("([^"]*)"|'([^']*)'|([^\\s>]+))`);
+	xmlAttributeRegexCache.set(name, pattern);
+	return pattern;
+}
+function parseXmlAttribute(attributes, name) {
+	const match = xmlAttributeRegex(name).exec(attributes);
+	const value = match?.[2] ?? match?.[3] ?? match?.[4];
+	return value ? decodeDeepSeekDsmlText(value) : null;
+}
+function decodeDeepSeekDsmlText(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+function findEarliestStringToken(text, tokens) {
+	let best = null;
+	for (const token of tokens) {
+		const index = text.indexOf(token);
+		if (index !== -1 && (!best || index < best.index)) best = {
+			index,
+			token
+		};
+	}
+	return best;
+}
+function longestDeepSeekDsmlToolOpenPrefixSuffixLength(text) {
+	const maxLength = Math.min(text.length, DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN - 1);
+	for (let length = maxLength; length > 0; length -= 1) {
+		const suffix = text.slice(text.length - length);
+		if (DEEPSEEK_DSML_TOOL_OPEN_TOKENS.some((token) => token.startsWith(suffix))) return length;
+	}
+	return 0;
+}
+function getCompletionsContentDeltas(content) {
+	if (typeof content === "string") return content ? [{
+		kind: "text",
+		text: content
+	}] : [];
+	if (Array.isArray(content)) return content.flatMap((item) => getCompletionsContentDeltas(item));
+	if (!content || typeof content !== "object") return [];
+	const record = content;
+	const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+	const extractText = (value) => {
+		if (typeof value === "string") return value;
+		if (Array.isArray(value)) return value.map((item) => extractText(item)).join("");
+		if (value && typeof value === "object") {
+			const nested = value;
+			return extractText(nested.text ?? nested.content ?? nested.thinking);
+		}
+		return "";
+	};
+	const text = extractText(record.text ?? record.content ?? record.thinking);
+	if (!text) return [];
+	if (type.includes("thinking") || type.includes("reasoning")) return [{
+		kind: "thinking",
+		signature: "content",
+		text
+	}];
+	if (type === "text" || type === "output_text" || type.endsWith(".output_text")) return [{
+		kind: "text",
+		text
+	}];
+	return [];
+}
+function getCompletionsReasoningDeltas(delta, visibleReasoningDetailTypes) {
+	const output = [];
+	const pushDelta = (next) => {
+		const previous = output[output.length - 1];
+		if (!previous || previous.kind !== next.kind) {
+			output.push(next);
+			return;
+		}
+		if (next.kind === "thinking" && previous.kind === "thinking") {
+			if (previous.signature !== next.signature) {
+				output.push(next);
+				return;
+			}
+			previous.text += next.text;
+			return;
+		}
+		previous.text += next.text;
+	};
+	const reasoningDetails = delta.reasoning_details;
+	let usedReasoningThinkingDetails = false;
+	if (Array.isArray(reasoningDetails)) {
+		const visibleTypes = new Set(visibleReasoningDetailTypes);
+		for (const item of reasoningDetails) {
+			const detail = item;
+			if (typeof detail.text !== "string" || !detail.text) continue;
+			if (detail.type === "reasoning.text") {
+				usedReasoningThinkingDetails = true;
+				pushDelta({
+					kind: "thinking",
+					signature: "reasoning_details",
+					text: detail.text
+				});
+				continue;
+			}
+			if (typeof detail.type === "string" && visibleTypes.has(detail.type)) pushDelta({
+				kind: "text",
+				text: detail.text
+			});
+		}
+	}
+	if (!usedReasoningThinkingDetails) for (const field of [
+		"reasoning_content",
+		"reasoning",
+		"reasoning_text"
+	]) {
+		const value = delta[field];
+		if (typeof value === "string" && value.length > 0) {
+			pushDelta({
+				kind: "thinking",
+				signature: field,
+				text: value
+			});
+			break;
+		}
+	}
+	return output;
+}
+function resolveOpenAICompletionsReasoningEffort(options) {
+	return options?.reasoningEffort ?? options?.reasoning ?? "high";
+}
+function shouldEmitOpenAICompletionsReasoning(model, options) {
+	if (!model.reasoning) return false;
+	const effort = resolveOpenAICompletionsReasoningEffort(options);
+	if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
+	return true;
+}
+function shouldEmitOpenAICompletionsReasoningForModel(model, options) {
+	return shouldEmitOpenAICompletionsReasoning(model, options);
+}
+function resolveOpenAICompletionsMaxTokens(model, options) {
+	if (options?.maxTokens) return {
+		maxTokens: options.maxTokens,
+		clampToModelMaxTokens: true
+	};
+	const paramsMaxTokens = resolveMaxTokensParam(model.params);
+	if (paramsMaxTokens) return {
+		maxTokens: paramsMaxTokens,
+		clampToModelMaxTokens: false
+	};
+	return {
+		maxTokens: model.maxTokens,
+		clampToModelMaxTokens: false
+	};
+}
+function resolveOpenAICompletionsModelMaxTokens(model) {
+	return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
+}
+const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
+const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
+function estimateOpenAICompletionsInputTokens(payload) {
+	let adjustedChars = 0;
+	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
+	if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
+	} catch {
+		adjustedChars += 1024;
+	}
+	if (payload.response_format !== void 0) try {
+		adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
+	} catch {
+		adjustedChars += 256;
+	}
+	return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
+}
+function estimateOpenAICompletionsMessagesChars(messages) {
+	if (!Array.isArray(messages)) return 0;
+	let adjustedChars = 0;
+	for (const message of messages) {
+		if (!message || typeof message !== "object") continue;
+		const record = message;
+		adjustedChars += estimateOpenAICompletionsContentChars(record.content);
+		for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
+		if (record.tool_calls !== void 0) try {
+			adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
+		} catch {
+			adjustedChars += 256;
+		}
+	}
+	return adjustedChars;
+}
+function estimateOpenAICompletionsContentChars(value) {
+	if (typeof value === "string") return estimateStringChars(value);
+	if (!Array.isArray(value)) return 0;
+	let adjustedChars = 0;
+	for (const block of value) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if (record.type === "image_url" || record.type === "input_image") {
+			adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
+			continue;
+		}
+		const text = record.text;
+		if (typeof text === "string") {
+			adjustedChars += estimateStringChars(text);
+			continue;
+		}
+		try {
+			adjustedChars += estimateStringChars(JSON.stringify(block));
+		} catch {
+			adjustedChars += 256;
+		}
+	}
+	return adjustedChars;
+}
+function resolveOpenAICompletionsEffectiveContextTokens(model) {
+	const contextTokens = model.contextTokens;
+	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
+	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
+}
+function isQwenOpenAICompletionsThinkingFormat(format) {
+	return format === "qwen" || format === "qwen-chat-template";
+}
+function isOpenAICompletionsThinkingEnabled(effort) {
+	const normalized = effort.trim().toLowerCase();
+	return normalized !== "off" && normalized !== "none";
+}
+function setQwenChatTemplateThinking(params, enabled) {
+	const existing = params.chat_template_kwargs;
+	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
+		...existing,
+		enable_thinking: enabled
+	} : { enable_thinking: enabled };
+}
+function applyQwenOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
+	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
+	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
+	else params.payload.enable_thinking = enabled;
+	return true;
+}
+function applyTogetherOpenAICompletionsThinkingParams(params) {
+	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return false;
+	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
+	return true;
+}
+function convertTools(tools, compat, model) {
+	const projection = projectOpenAITools(tools);
+	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
+		transport: "stream",
+		supportsStrictMode: compat?.supportsStrictMode
+	}), {
+		transport: "completions",
+		model
+	});
+	return {
+		projection,
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
+			const functionTool = {
+				name: tool.name,
+				description: tool.description,
+				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
+			};
+			if (strict !== void 0) functionTool.strict = strict;
+			return {
+				type: "function",
+				function: functionTool
+			};
+		})
+	};
+}
+function extractGoogleThoughtSignature(toolCall) {
+	const tc = toolCall;
+	if (!tc) return;
+	const fromExtra = (tc.extra_content?.google)?.thought_signature;
+	if (typeof fromExtra === "string" && fromExtra.length > 0) return fromExtra;
+	const fromFunction = tc.function?.thought_signature;
+	return typeof fromFunction === "string" && fromFunction.length > 0 ? fromFunction : void 0;
+}
+function isGoogleOpenAICompatModel(model) {
+	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
+	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
+}
+function requiresGoogleCompatToolCallThoughtSignature(model) {
+	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
+}
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
+const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
+function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
+	return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
+}
+function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
+	if (!isGoogleOpenAICompatModel(model)) return;
+	const sigById = /* @__PURE__ */ new Map();
+	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
+	for (const msg of context.messages ?? []) {
+		if (msg.role !== "assistant") continue;
+		const source = msg;
+		if (!Array.isArray(source.content)) continue;
+		for (const block of source.content) {
+			if (block.type !== "toolCall") continue;
+			const id = block.id;
+			const sig = block.thoughtSignature;
+			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
+				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
+				if (!isSameRoute && !fallbackSig) continue;
+				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
+			}
+		}
+	}
+	if (sigById.size === 0 && !fallbackSig) return;
+	for (const message of outgoingMessages) {
+		const toolCalls = message.tool_calls;
+		if (!Array.isArray(toolCalls)) continue;
+		for (const toolCall of toolCalls) {
+			const id = toolCall.id;
+			if (typeof id !== "string") continue;
+			let sig = sigById.get(id) ?? fallbackSig;
+			if (typeof sig === "string" && sig.length > 0) {
+				if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
+			}
+			if (typeof sig !== "string" || sig.length === 0) continue;
+			const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
+			toolCall.extra_content = extra;
+			const google = extra.google && typeof extra.google === "object" ? extra.google : {};
+			extra.google = google;
+			google.thought_signature = sig;
+		}
+	}
+}
+const COMPLETIONS_REASONING_REPLAY_FIELDS = [
+	"reasoning_details",
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function stripCompletionsReasoningReplayFields(record) {
+	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
+}
+function sanitizeOpenRouterReasoningReplayFields(record) {
+	const reasoningDetails = record.reasoning_details;
+	if (typeof reasoningDetails === "string") {
+		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
+		delete record.reasoning_details;
+	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
+	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
+	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
+	const reasoningText = record.reasoning_text;
+	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
+	if ("reasoning_text" in record) delete record.reasoning_text;
+}
+function sanitizeReasoningContentReplayFields(record) {
+	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
+	delete record.reasoning_details;
+	delete record.reasoning;
+	delete record.reasoning_text;
+}
+const REASONING_CONTENT_REPLAY_MODEL_IDS = /* @__PURE__ */ new Set([
+	"deepseek-v4-flash",
+	"deepseek-v4-pro",
+	"kimi-for-coding",
+	"kimi-k2.5",
+	"kimi-k2.6",
+	"kimi-k2.7-code",
+	"kimi-k2.7-code-highspeed",
+	"kimi-k3",
+	"kimi-k2-thinking",
+	"kimi-k2-thinking-turbo",
+	"mimo-v2-pro",
+	"mimo-v2-omni",
+	"mimo-v2.5",
+	"mimo-v2.5-pro",
+	"mimo-v2.6-pro"
+]);
+const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
+	"-free",
+	"-paid",
+	"-trial"
+];
+function stripReasoningContentReplayTierSuffix(modelId) {
+	for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
+	return modelId;
+}
+function getReasoningContentReplayModelIdCandidates(modelId) {
+	if (typeof modelId !== "string") return [];
+	const normalized = modelId.trim().toLowerCase();
+	if (!normalized) return [];
+	const parts = normalized.split("/").filter(Boolean);
+	const finalPart = parts[parts.length - 1] ?? normalized;
+	const candidates = [finalPart];
+	const colonParts = finalPart.split(":").filter(Boolean);
+	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
+	const baseCount = candidates.length;
+	for (let index = 0; index < baseCount; index += 1) {
+		const candidate = candidates[index];
+		if (typeof candidate !== "string") continue;
+		const stripped = stripReasoningContentReplayTierSuffix(candidate);
+		if (stripped !== candidate) candidates.push(stripped);
+	}
+	return uniqueStrings(candidates.filter(Boolean));
+}
+function shouldPreserveReasoningContentReplay(model, compat) {
+	if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
+	return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
+}
+function shouldPreserveOpenRouterReasoningReplay(model) {
+	if (model.provider !== "openrouter") return true;
+	const normalizedModelId = model.id.trim().toLowerCase();
+	return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
+}
+function shouldTrustReasoningContentReplayMetadata(model) {
+	if (!model.reasoning) return false;
+	if (model.provider.trim().toLowerCase() === "openai") return false;
+	return shouldPreserveOpenRouterReasoningReplay(model);
+}
+function sanitizeCompletionsReasoningReplayFields(messages, options) {
+	if (!Array.isArray(messages)) return;
+	for (const msg of messages) {
+		if (!msg || typeof msg !== "object") continue;
+		const record = msg;
+		if (record.role !== "assistant") continue;
+		if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
+		else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
+		else stripCompletionsReasoningReplayFields(record);
+	}
+}
+function buildOpenAICompletionsParams(model, context, options) {
+	const compat = getCompat(model);
+	const compatDetection = detectOpenAICompletionsCompat(model);
+	let messages = convertMessages(model, context.systemPrompt ? {
+		...context,
+		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
+	} : context, compat);
+	injectToolCallThoughtSignatures(messages, context, model);
+	sanitizeCompletionsReasoningReplayFields(messages, {
+		preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
+		preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
+	});
+	if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
+	const params = {
+		model: model.id,
+		messages: compat.requiresStringContent ? flattenCompletionMessagesToStringContent(messages) : messages,
+		stream: true
+	};
+	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
+	if (compat.supportsStore) params.store = false;
+	if (compat.supportsPromptCacheKey && promptCacheKey) {
+		params.prompt_cache_key = promptCacheKey;
+		if (cacheRetention === "long" && compat.supportsLongCacheRetention) params.prompt_cache_retention = "24h";
+	}
+	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (options?.topP !== void 0) params.top_p = options.topP;
+	const responseFormat = resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
+		provider: model.provider,
+		baseUrl: model.baseUrl,
+		hasTools: () => Boolean(context.tools?.length)
+	}) ? void 0 : options?.responseFormat, compat.supportsJsonSchemaResponseFormat);
+	if (responseFormat !== void 0) params.response_format = responseFormat;
+	if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
+	if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
+	if (options?.seed !== void 0) params.seed = options.seed;
+	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
+	if (supportsModelTools(model)) {
+		if (context.tools) {
+			const converted = convertTools(context.tools, compat, model);
+			if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
+			else if (hasToolHistory(context.messages)) params.tools = [];
+			if (options?.toolChoice) {
+				const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, converted.projection);
+				if (toolChoice !== void 0) params.tool_choice = toolChoice;
+			} else if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
+		} else if (hasToolHistory(context.messages)) params.tools = [];
+		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
+			delete params.tools;
+			delete params.tool_choice;
+		}
+	}
+	{
+		const maxTokenBudget = resolveOpenAICompletionsMaxTokens(model, options);
+		const effectiveMaxTokens = maxTokenBudget.maxTokens;
+		const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
+		let clampedMaxTokens = effectiveMaxTokens;
+		const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
+		if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
+			clampedMaxTokens = modelMaxTokens;
+			emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
+		}
+		if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
+			const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
+			const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
+			if (clampedMaxTokens > remainingBudget) {
+				clampedMaxTokens = remainingBudget;
+				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
+			}
+		}
+		if (clampedMaxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
+		else params.max_completion_tokens = clampedMaxTokens;
+	}
+	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
+	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: completionsReasoningEffort,
+		fallbackMap: compat.reasoningEffortMap
+	}) : void 0;
+	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
+	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
+	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	applyTogetherOpenAICompletionsThinkingParams({
+		compatThinkingFormat: compat.thinkingFormat,
+		modelReasoning: model.reasoning,
+		payload: params,
+		requestedEffort: completionsReasoningEffort
+	});
+	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
+	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
+	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
+	return params;
+}
+function parseTransportChunkUsage(rawUsage, model) {
+	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+	const cachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+	const promptTokens = rawUsage.prompt_tokens || 0;
+	const input = Math.max(0, promptTokens - cachedTokens - cacheWriteTokens);
+	const outputTokens = rawUsage.completion_tokens || 0;
+	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
+	const usage = {
+		input,
+		output: outputTokens,
+		cacheRead: cachedTokens,
+		cacheWrite: cacheWriteTokens,
+		...typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
+		totalTokens: input + outputTokens + cachedTokens + cacheWriteTokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	calculateCost(model, usage);
+	applyProviderReportedUsageCost(usage, rawUsage.cost);
+	return usage;
+}
+function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
+	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
+	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
+}
+const completionsTesting = {
+	getCompat,
+	createSseDoneDetector,
+	createOpenAICompletionsClient,
+	buildOpenAICompletionsClientConfig,
+	parseTransportChunkUsage,
+	processOpenAICompletionsStream,
+	shouldEmitOpenAICompletionsReasoningForModel
+};
+if (process.env.VITEST || false) globalThis.openclawOpenAICompletionsTransportTestApi = completionsTesting;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-payload-policy.ts
+/**
+* OpenAI Responses payload policy.
+* Classifies endpoint capabilities and applies store, prompt-cache,
+* server-compaction, service-tier, and reasoning payload rules.
+*/
+const OPENAI_RESPONSES_APIS = /* @__PURE__ */ new Set([
+	"openai-responses",
+	"azure-openai-responses",
+	"openai-chatgpt-responses",
+	"openclaw-openai-responses-transport",
+	"openclaw-openai-chatgpt-responses-transport"
+]);
+const OPENAI_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"azure-openai",
+	"azure-openai-responses"
+]);
+const LOCAL_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+const MODELSTUDIO_NATIVE_BASE_URLS = /* @__PURE__ */ new Set([
+	"https://coding-intl.dashscope.aliyuncs.com/v1",
+	"https://coding.dashscope.aliyuncs.com/v1",
+	"https://dashscope.aliyuncs.com/compatible-mode/v1",
+	"https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+]);
+const MOONSHOT_NATIVE_BASE_URLS = /* @__PURE__ */ new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
+function normalizeLowercaseString(value) {
+	const stringValue = readStringValue(value)?.trim().toLowerCase();
+	return stringValue ? stringValue : void 0;
+}
+function normalizeComparableBaseUrl(value) {
+	const trimmed = readStringValue(value)?.trim();
+	if (!trimmed) return;
+	const parsedValue = /^[a-z0-9.[\]-]+(?::\d+)?(?:[/?#].*)?$/i.test(trimmed) ? `https://${trimmed}` : trimmed;
+	try {
+		const url = new URL(parsedValue);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return;
+		url.hash = "";
+		url.search = "";
+		return url.toString().replace(/\/+$/, "").toLowerCase();
+	} catch {
+		return;
+	}
+}
+function resolveUrlHostname(value) {
+	const trimmed = readStringValue(value)?.trim();
+	if (!trimmed) return;
+	try {
+		return new URL(trimmed).hostname.toLowerCase();
+	} catch {
+		try {
+			return new URL(`https://${trimmed}`).hostname.toLowerCase();
+		} catch {
+			return;
+		}
+	}
+}
+function hostMatchesSuffix(host, suffix) {
+	return suffix.startsWith(".") || suffix.startsWith("-") ? host.endsWith(suffix) : host === suffix || host.endsWith(`.${suffix}`);
+}
+function isLocalEndpointHost(host) {
+	return LOCAL_ENDPOINT_HOSTS.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
+}
+function resolveBundledOpenAIResponsesEndpointClass(baseUrl) {
+	const trimmed = readStringValue(baseUrl)?.trim();
+	if (!trimmed) return "default";
+	const host = resolveUrlHostname(trimmed);
+	if (!host) return "invalid";
+	const comparableBaseUrl = normalizeComparableBaseUrl(trimmed);
+	switch (host) {
+		case "api.anthropic.com": return "anthropic-public";
+		case "api.cerebras.ai": return "cerebras-native";
+		case "llm.chutes.ai": return "chutes-native";
+		case "api.deepseek.com": return "deepseek-native";
+		case "api.groq.com": return "groq-native";
+		case "api.mistral.ai": return "mistral-public";
+		case "api.openai.com": return "openai-public";
+		case "chatgpt.com": return "openai";
+		case "generativelanguage.googleapis.com": return "google-generative-ai";
+		case "aiplatform.googleapis.com": return "google-vertex";
+		case "api.x.ai": return "xai-native";
+		case "api.z.ai": return "zai-native";
+	}
+	if (hostMatchesSuffix(host, ".githubcopilot.com")) return "github-copilot-native";
+	if (hostMatchesSuffix(host, ".openai.azure.com")) return "azure-openai";
+	if (hostMatchesSuffix(host, "openrouter.ai")) return "openrouter";
+	if (hostMatchesSuffix(host, "opencode.ai")) return "opencode-native";
+	if (hostMatchesSuffix(host, "-aiplatform.googleapis.com")) return "google-vertex";
+	if (comparableBaseUrl && MOONSHOT_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "moonshot-native";
+	if (comparableBaseUrl && MODELSTUDIO_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "modelstudio-native";
+	if (isLocalEndpointHost(host)) return "local";
+	return "custom";
+}
+function isOpenAIResponsesApi(api) {
+	return api !== void 0 && OPENAI_RESPONSES_APIS.has(api);
+}
+function readCompatPayloadBoolean(compat, key) {
+	if (!compat || typeof compat !== "object") return;
+	const value = compat[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolveOpenAIResponsesPayloadCapabilities(model) {
+	const provider = normalizeLowercaseString(model.provider);
+	const api = normalizeLowercaseString(model.api);
+	const isOpenAIProvider = provider === "openai";
+	const endpointClass = resolveBundledOpenAIResponsesEndpointClass(model.baseUrl);
+	const isResponsesApi = isOpenAIResponsesApi(api);
+	const usesConfiguredBaseUrl = endpointClass !== "default";
+	const usesKnownNativeOpenAIEndpoint = endpointClass === "openai-public" || endpointClass === "openai" || endpointClass === "azure-openai";
+	const usesKnownNativeOpenAIRoute = endpointClass === "default" ? provider === "openai" : usesKnownNativeOpenAIEndpoint;
+	const usesExplicitProxyLikeEndpoint = usesConfiguredBaseUrl && !usesKnownNativeOpenAIEndpoint;
+	const promptCacheKeySupport = readCompatPayloadBoolean(model.compat, "supportsPromptCacheKey");
+	const shouldStripResponsesPromptCache = promptCacheKeySupport === true ? false : promptCacheKeySupport === false ? isResponsesApi : isResponsesApi && usesExplicitProxyLikeEndpoint;
+	const supportsResponsesStoreField = readCompatPayloadBoolean(model.compat, "supportsStore") !== false && isResponsesApi;
+	return {
+		allowsOpenAIServiceTier: provider === "openai" && (api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai-public" || isOpenAIProvider && (api === "openai-chatgpt-responses" || api === "openclaw-openai-chatgpt-responses-transport" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
+		allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && api !== "openclaw-openai-chatgpt-responses-transport" && provider !== void 0 && OPENAI_RESPONSES_PROVIDERS.has(provider) && usesKnownNativeOpenAIEndpoint,
+		shouldStripResponsesPromptCache,
+		supportsResponsesStoreField,
+		usesKnownNativeOpenAIRoute
+	};
+}
+function parsePositiveInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	if (typeof value === "string") return parseStrictPositiveInteger(value);
+}
+function resolveOpenAIResponsesCompactThreshold(model) {
+	const contextWindow = parsePositiveInteger(model.contextWindow);
+	if (contextWindow) return Math.max(1e3, Math.floor(contextWindow * .7));
+	return 8e4;
+}
+function shouldEnableOpenAIResponsesServerCompaction(explicitStore, provider, extraParams) {
+	const configured = extraParams?.responsesServerCompaction;
+	if (configured === false) return false;
+	if (explicitStore !== true) return false;
+	if (configured === true) return true;
+	return provider === "openai";
+}
+function stripDisabledOpenAIReasoningPayload(payloadObj) {
+	const reasoning = payloadObj.reasoning;
+	if (reasoning === "none") {
+		delete payloadObj.reasoning;
+		return;
+	}
+	if (!reasoning || typeof reasoning !== "object" || Array.isArray(reasoning)) return;
+	if (reasoning.effort === "none") delete payloadObj.reasoning;
+}
+/** Strip returned-item metadata rejected by strict Responses-compatible endpoints. */
+function stripInputItemStatuses(input) {
+	if (!Array.isArray(input)) return;
+	for (const item of input) if (item && typeof item === "object" && !Array.isArray(item)) delete item.status;
+}
+/** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */
+function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
+	const capabilities = resolveOpenAIResponsesPayloadCapabilities(model);
+	const storeMode = options.storeMode ?? "provider-policy";
+	const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore ? true : void 0;
+	const isResponsesApi = isOpenAIResponsesApi(normalizeLowercaseString(model.api));
+	const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
+	const shouldStripInputStatus = isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute;
+	return {
+		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
+		compactThreshold: parsePositiveInteger(options.extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model),
+		explicitStore,
+		shouldStripDisabledReasoningPayload,
+		shouldStripInputStatus,
+		shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
+		shouldStripStore: explicitStore !== true && readCompatPayloadBoolean(model.compat, "supportsStore") === false && isResponsesApi,
+		useServerCompaction: options.enableServerCompaction === true && shouldEnableOpenAIResponsesServerCompaction(explicitStore, model.provider, options.extraParams)
+	};
+}
+/** Mutate a Responses request payload according to the resolved endpoint policy. */
+function applyOpenAIResponsesPayloadPolicy(payloadObj, policy) {
+	if (policy.explicitStore !== void 0) payloadObj.store = policy.explicitStore;
+	if (policy.shouldStripStore) delete payloadObj.store;
+	if (policy.shouldStripPromptCache) {
+		delete payloadObj.prompt_cache_key;
+		delete payloadObj.prompt_cache_retention;
+	}
+	if (policy.useServerCompaction && payloadObj.context_management === void 0) payloadObj.context_management = [{
+		type: "compaction",
+		compact_threshold: policy.compactThreshold
+	}];
+	if (policy.shouldStripDisabledReasoningPayload) stripDisabledOpenAIReasoningPayload(payloadObj);
+	if (policy.shouldStripInputStatus) stripInputItemStatuses(payloadObj.input);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-params-internal.ts
+function convertResponsesTools(tools, model, options) {
+	const projection = projectOpenAITools(tools);
+	const strict = resolveOpenAIStrictToolFlagWithDiagnostics(projection, options?.strict, {
+		transport: "responses",
+		model
+	});
+	return {
+		projection,
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
+			const result = {
+				type: "function",
+				name: tool.name,
+				description: tool.description,
+				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
+			};
+			if (strict !== void 0) result.strict = strict;
+			return result;
+		})
+	};
+}
+function getPromptCacheRetention(baseUrl, cacheRetention) {
+	if (cacheRetention !== "long") return;
+	return baseUrl?.includes("api.openai.com") ? "24h" : void 0;
+}
+function resolveOpenAIReasoningEffort(options) {
+	return normalizeOpenAIReasoningEffort(options?.reasoningEffort ?? options?.reasoning ?? "high");
+}
+function hasResponsesWebSearchTool(tools) {
+	if (!Array.isArray(tools)) return false;
+	return tools.some((tool) => {
+		if (!isRecord(tool)) return false;
+		if (tool.type === "web_search") return true;
+		if (tool.type === "function" && tool.name === "web_search") return true;
+		const fn = tool.function;
+		return isRecord(fn) && fn.name === "web_search";
+	});
+}
+function raiseMinimalReasoningForResponsesWebSearch(params) {
+	if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
+	for (const effort of [
+		"low",
+		"medium",
+		"high"
+	]) {
+		const resolved = resolveOpenAIReasoningEffortForModel({
+			model: params.model,
+			effort
+		});
+		if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
+	}
+	return params.effort;
+}
+const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
+	"max_output_tokens",
+	"metadata",
+	"prompt_cache_retention",
+	"service_tier",
+	"temperature",
+	"top_p"
+];
+function stripOpenAICodexResponsesUnsupportedTextFields(params) {
+	const text = params.text;
+	if (!text || typeof text !== "object" || Array.isArray(text)) return;
+	const sanitizedText = { ...text };
+	delete sanitizedText.format;
+	if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
+	else delete params.text;
+}
+function sanitizeOpenAICodexResponsesParams(model, params) {
+	if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
+	for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
+	stripOpenAICodexResponsesUnsupportedTextFields(params);
+	return params;
+}
+function buildOpenAICodexResponsesInstructions(context) {
+	if (!context.systemPrompt) return;
+	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
+}
+function resolveOpenAICodexResponsesInstructions(model, context) {
+	const instructions = buildOpenAICodexResponsesInstructions(context);
+	if (instructions && instructions.trim().length > 0) return instructions;
+	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
+}
+function ensureOpenAICodexResponsesInput(messages, context) {
+	if (messages.length > 0 || !context.systemPrompt) return;
+	if (!buildOpenAICodexResponsesInstructions(context)) throw new Error("OpenAI Codex Responses requires non-empty input when only systemPrompt is provided.");
+	messages.push(buildResponsesInputMessage("user", [{
+		type: "input_text",
+		text: " "
+	}]));
+}
+function resolveOpenAIResponsesTextFormat(responseFormat) {
+	if (responseFormat.type === "json_schema" && responseFormat.json_schema && typeof responseFormat.json_schema === "object" && !Array.isArray(responseFormat.json_schema)) return {
+		...responseFormat.json_schema,
+		type: "json_schema"
+	};
+	return responseFormat;
+}
+function buildOpenAIResponsesParams(model, context, options, metadata) {
+	const isCodexResponses = isOpenAICodexResponsesModel(model);
+	const isNativeCodexResponses = usesNativeOpenAICodexResponsesBackend(model);
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
+	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
+	const replayResponsesItemIds = !isNativeCodexResponses && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
+	const messages = convertResponsesMessages(model, context, /* @__PURE__ */ new Set([
+		"openai",
+		"opencode",
+		"azure-openai-responses",
+		"github-copilot"
+	]), {
+		includeSystemPrompt: !isCodexResponses,
+		supportsDeveloperRole,
+		replayReasoningItems: true,
+		replayResponsesItemIds,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId
+	});
+	if (isCodexResponses) ensureOpenAICodexResponsesInput(messages, context);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: promptCacheKey,
+		prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
+		...isCodexResponses ? { instructions: resolveOpenAICodexResponsesInstructions(model, context) } : {},
+		...metadata ? { metadata } : {}
+	};
+	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
+	if (effectiveMaxTokens) params.max_output_tokens = effectiveMaxTokens;
+	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (options?.topP !== void 0) params.top_p = options.topP;
+	if (options?.responseFormat !== void 0) params.text = {
+		...params.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+	};
+	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
+	if (context.tools) {
+		const converted = convertResponsesTools(context.tools, model, { strict: resolveOpenAIStrictToolSetting(model, { transport: "stream" }) });
+		if (converted.tools.length > 0 || converted.projection.inputToolCount === 0 && converted.projection.diagnostics.length === 0) params.tools = converted.tools;
+		if (options?.toolChoice) {
+			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, converted.projection);
+			if (toolChoice !== void 0) params.tool_choice = toolChoice;
+		}
+	}
+	if (model.reasoning) {
+		if (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) {
+			const resolvedReasoningEffort = resolveOpenAIReasoningEffortForModel({
+				model,
+				effort: resolveOpenAIReasoningEffort(options)
+			});
+			const reasoningEffort = resolvedReasoningEffort ? raiseMinimalReasoningForResponsesWebSearch({
+				model,
+				effort: resolvedReasoningEffort,
+				tools: params.tools
+			}) : void 0;
+			if (reasoningEffort) {
+				params.reasoning = {
+					effort: reasoningEffort,
+					...reasoningEffort === "none" ? {} : { summary: options?.reasoningSummary || "auto" }
+				};
+				if (reasoningEffort !== "none") params.include = ["reasoning.encrypted_content"];
+			}
+		} else if (model.provider !== "github-copilot") {
+			const reasoningEffort = resolveOpenAIReasoningEffortForModel({
+				model,
+				effort: "none"
+			});
+			if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
+		}
+	}
+	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
+	return sanitizeOpenAICodexResponsesParams(model, params);
+}
+//#endregion
+//#region packages/media-core/src/inline-image-data-url.ts
+/** Prefix used to distinguish inline data URLs from remote/local image references. */
+const INLINE_IMAGE_DATA_URL_PREFIX = "data:";
+const IMAGE_SIGNATURES = [
+	{
+		mime: "image/png",
+		matches: (buffer) => buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10
+	},
+	{
+		mime: "image/jpeg",
+		matches: (buffer) => buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255
+	},
+	{
+		mime: "image/webp",
+		matches: (buffer) => buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP"
+	},
+	{
+		mime: "image/gif",
+		matches: (buffer) => buffer.length >= 6 && (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a")
+	},
+	{
+		mime: "image/bmp",
+		matches: (buffer) => buffer.length >= 2 && buffer[0] === 66 && buffer[1] === 77
+	}
+];
+const HEIC_BRANDS = /* @__PURE__ */ new Set([
+	"heic",
+	"heix",
+	"hevc",
+	"hevx",
+	"heis",
+	"heim",
+	"hevm",
+	"hevs"
+]);
+const HEIF_BRANDS = /* @__PURE__ */ new Set(["mif1", "msf1"]);
+const IMAGE_SIGNATURE_PREFIX_BASE64_CHARS = 128;
+const INLINE_IMAGE_DATA_URL_MIMES = /* @__PURE__ */ new Set([
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+]);
+function startsWithDataUrl(value) {
+	return value.slice(0, 5).toLowerCase() === INLINE_IMAGE_DATA_URL_PREFIX;
+}
+function sniffIsoBmffImageMime(buffer) {
+	if (buffer.length < 12 || buffer.subarray(4, 8).toString("ascii") !== "ftyp") return;
+	const brands = [buffer.subarray(8, 12).toString("ascii")];
+	for (let offset = 16; offset + 4 <= buffer.length; offset += 4) brands.push(buffer.subarray(offset, offset + 4).toString("ascii"));
+	if (brands.some((brand) => HEIC_BRANDS.has(brand))) return "image/heic";
+	if (brands.some((brand) => HEIF_BRANDS.has(brand))) return "image/heif";
+}
+/** Sniffs supported inline image formats from decoded bytes. */
+function sniffInlineImageMime(buffer) {
+	return IMAGE_SIGNATURES.find((signature) => signature.matches(buffer))?.mime ?? sniffIsoBmffImageMime(buffer);
+}
+function isImageMimeType(value) {
+	return value.trim().toLowerCase().startsWith("image/");
+}
+/** Canonicalizes trusted inline image base64 and rejects malformed or non-image payloads. */
+function sanitizeInlineImageBase64(params) {
+	if (!isImageMimeType(params.mimeType)) return;
+	const canonicalPayload = canonicalizeBase64(params.base64);
+	if (!canonicalPayload) return;
+	const sniffedMimeType = sniffInlineImageMime(Buffer.from(canonicalPayload.slice(0, IMAGE_SIGNATURE_PREFIX_BASE64_CHARS), "base64"));
+	if (!sniffedMimeType) return;
+	return {
+		mimeType: sniffedMimeType,
+		base64: canonicalPayload
+	};
+}
+function parseInlineImageDataUrl(value) {
+	if (!startsWithDataUrl(value)) return {
+		metadata: [],
+		payload: value
+	};
+	const commaIndex = value.indexOf(",");
+	if (commaIndex < 0) return;
+	return {
+		metadata: value.slice(5, commaIndex).split(";").map((part) => part.trim()),
+		payload: value.slice(commaIndex + 1)
+	};
+}
+function metadataAllowsImageBase64(metadata) {
+	const [mimeType, ...options] = metadata;
+	return mimeType !== void 0 && isImageMimeType(mimeType) && options.some((part) => part.toLowerCase() === "base64");
+}
+function sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, allowedMimes) {
+	const parsed = parseInlineImageDataUrl(imageUrl);
+	if (!parsed) return;
+	if (parsed.metadata.length === 0) return imageUrl;
+	if (!metadataAllowsImageBase64(parsed.metadata)) return;
+	const [mimeType] = parsed.metadata;
+	const sanitized = sanitizeInlineImageBase64({
+		mimeType: mimeType ?? "",
+		base64: parsed.payload
+	});
+	if (!sanitized) return;
+	if (allowedMimes && !allowedMimes.has(sanitized.mimeType)) return;
+	return `data:${sanitized.mimeType};base64,${sanitized.base64}`;
+}
+/** Canonicalizes provider-safe inline image data URLs and rejects unsupported formats. */
+function sanitizeInlineImageDataUrl(imageUrl) {
+	return sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, INLINE_IMAGE_DATA_URL_MIMES);
+}
+//#endregion
+//#region packages/ai/src/transports/responses-image-payload-sanitizer.ts
+/**
+* Sanitizes OpenAI Responses payloads before transport. Invalid inline images
+* are replaced with text placeholders so the request remains valid and
+* auditable.
+*/
+const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
+function invalidSnakeImage() {
+	return {
+		type: "input_text",
+		text: `[${IMAGE_OMITTED_TEXT}]`
+	};
+}
+function sanitizeValue(value) {
+	if (Array.isArray(value)) return value.map(sanitizeValue);
+	if (!isRecord(value)) return value;
+	if (value.type === "input_image" && typeof value.image_url === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(value.image_url);
+		return imageUrl ? {
+			...value,
+			image_url: imageUrl
+		} : invalidSnakeImage();
+	}
+	const next = {};
+	for (const [key, child] of Object.entries(value)) next[key] = sanitizeValue(child);
+	return next;
+}
+/** Sanitize inline image fields inside a Responses API payload. */
+function sanitizeResponsesImagePayload(params) {
+	if (!Array.isArray(params.input)) return params;
+	return {
+		...params,
+		input: sanitizeValue(params.input)
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-client.ts
+function resolveProviderTransportTurnState(model, params) {
+	const normalizedProvider = model.provider.trim().toLowerCase();
+	const allowRuntimePluginLoad = normalizedProvider === "openai" || normalizedProvider === "azure-openai" || normalizedProvider === "azure-openai-responses";
+	return getAiTransportHost().plugin.resolveTransportTurnState({
+		provider: model.provider,
+		modelId: model.id,
+		allowRuntimePluginLoad,
+		context: {
+			provider: model.provider,
+			modelId: model.id,
+			model,
+			sessionId: params.sessionId,
+			turnId: params.turnId,
+			attempt: params.attempt,
+			transport: params.transport
+		}
+	});
+}
+function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId) {
+	return new OpenAI({
+		apiKey,
+		baseURL: model.baseUrl,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId),
+		fetch: buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	});
+}
+function createResponsesTransportExecutor(config) {
+	return (model, context, options) => {
+		const responsesOptions = options;
+		const eventStream = createAssistantMessageEventStream();
+		const stream = eventStream;
+		(async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: config.outputApi ?? model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			let firstEventAbort;
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const turnState = resolveProviderTransportTurnState(model, {
+					sessionId: options?.sessionId,
+					turnId: randomUUID(),
+					attempt: 1,
+					transport: "stream"
+				});
+				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId);
+				let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata);
+				const nextParams = await options?.onPayload?.(params, model);
+				if (nextParams !== void 0) params = nextParams;
+				if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
+				params = sanitizeOpenAICodexResponsesParams(model, params);
+				params = sanitizeResponsesImagePayload(params);
+				if (options?.openclawCodeModeToolSurface === true) {
+					enforceCodeModeResponsesToolSurface(params);
+					assertCodeModeResponsesToolSurface(params);
+				}
+				const requestStartedAt = Date.now();
+				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
+				const requestOptions = buildOpenAISdkRequestOptions(model, firstEventAbort.signal, config.streamRequest ? { stream: true } : void 0);
+				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
+				const responseStream = await config.createResponseStream({
+					client,
+					request: params,
+					requestOptions,
+					model
+				});
+				emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - requestStartedAt}`);
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				await processResponsesStream(observeResponsesStream(responseStream, model), output, stream, model, {
+					...config.pricingOptions?.(responsesOptions),
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+					signal: options?.signal,
+					reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+						authProfileId: responsesOptions?.authProfileId,
+						sessionId: options?.sessionId
+					})
+				});
+				if (options?.signal?.aborted) throw transportAbortError(options.signal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+				stream.push({
+					type: "done",
+					reason: output.stopReason,
+					message: output
+				});
+				stream.end();
+			} catch (error) {
+				if (error instanceof ResponsesStreamFailure && error.observation) logResponsesFailedNoDetails(error.observation);
+				log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error));
+				assignTransportErrorDetails(output, error, options?.signal);
+				stream.push({
+					type: "error",
+					reason: output.stopReason,
+					error: output
+				});
+				stream.end();
+			} finally {
+				firstEventAbort?.dispose();
+			}
+		})();
+		return eventStream;
+	};
+}
+function createOpenAIResponsesTransportStreamFn() {
+	return createResponsesTransportExecutor({
+		streamRequest: true,
+		createClient: createOpenAIResponsesClient,
+		buildRequest: buildOpenAIResponsesParams,
+		createResponseStream: createResponsesStreamWithEncryptedContentRetry,
+		pricingOptions: (options) => ({
+			serviceTier: options?.serviceTier,
+			applyServiceTierPricing
+		})
+	});
+}
+function createAzureOpenAIResponsesTransportStreamFn() {
+	return createResponsesTransportExecutor({
+		outputApi: "azure-openai-responses",
+		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
+		createClient: createAzureOpenAIClient,
+		buildRequest: (model, context, options, metadata) => buildAzureOpenAIResponsesParams(model, context, options, resolveAzureDeploymentName(model), metadata),
+		createResponseStream: async ({ client, request, requestOptions }) => await client.responses.create(request, requestOptions)
+	});
+}
+function normalizeAzureBaseUrl(baseUrl) {
+	return baseUrl.replace(/\/+$/, "");
+}
+function resolveAzureDeploymentName(model) {
+	return resolveAzureDeploymentNameFromMap({
+		modelId: model.id,
+		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
+	});
+}
+function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders) {
+	const baseURL = normalizeAzureBaseUrl(model.baseUrl);
+	const clientOptions = {
+		apiKey,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
+		baseURL,
+		fetch: buildGuardedModelFetch(model),
+		...buildOpenAISdkClientOptions(model)
+	};
+	if (isOpenAICompatibleAzureResponsesBaseUrl(baseURL)) return new OpenAI(clientOptions);
+	return new AzureOpenAI({
+		...clientOptions,
+		apiVersion: resolveAzureOpenAIApiVersion()
+	});
+}
+function buildAzureOpenAIResponsesParams(model, context, options, deploymentName, metadata) {
+	const params = buildOpenAIResponsesParams(model, context, options, metadata);
+	params.model = deploymentName;
+	delete params.store;
+	return params;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-transport.ts
+/** OpenAI Responses transport facade. */
+const responsesTesting = {
+	getCompat,
+	assertCodeModeResponsesToolSurface,
+	buildOpenAIResponsesParams,
+	buildOpenAIClientHeaders,
+	buildOpenAISdkClientOptions,
+	buildOpenAISdkRequestOptions,
+	createAzureOpenAIClient,
+	createOpenAIResponsesClient,
+	enforceCodeModeResponsesToolSurface,
+	sanitizeOpenAICodexResponsesParams,
+	processResponsesStream,
+	formatModelTransportDebugBaseUrl,
+	buildResponsesFailedNoDetailsObservation,
+	buildOpenAIResponsesReasoningReplayMetadata,
+	isInvalidEncryptedContentError,
+	normalizeResponsesFailedEvent,
+	prepareOpenAIResponsesReasoningItemForReplay,
+	createResponsesStreamWithEncryptedContentRetry,
+	resolveAzureOpenAIApiVersion,
+	stripResponsesRequestEncryptedContent,
+	tagOpenAIResponsesReasoningReplayItem,
+	summarizeResponsesFailedNoDetailsObservation,
+	summarizeResponsesPayload,
+	summarizeResponsesTools,
+	stringifyRedactedEvent,
+	stringifyRedactedPayload
+};
+if (process.env.VITEST || false) globalThis.openclawOpenAIResponsesTransportTestApi = responsesTesting;
+//#endregion
+//#region packages/ai/src/transports/provider-transport-stream.ts
+const SUPPORTED_TRANSPORT_APIS = /* @__PURE__ */ new Set([
+	"openai-responses",
+	"openai-chatgpt-responses",
+	"openai-completions",
+	"azure-openai-responses",
+	"anthropic-messages",
+	"google-generative-ai"
+]);
+const SIMPLE_TRANSPORT_API_ALIAS = {
+	"openai-responses": "openclaw-openai-responses-transport",
+	"openai-chatgpt-responses": "openclaw-openai-chatgpt-responses-transport",
+	"openai-completions": "openclaw-openai-completions-transport",
+	"azure-openai-responses": "openclaw-azure-openai-responses-transport",
+	"anthropic-messages": "openclaw-anthropic-messages-transport",
+	"google-generative-ai": "openclaw-google-generative-ai-transport"
+};
+function createProviderOwnedGoogleTransportStreamFn(model, ctx) {
+	return getAiTransportHost().plugin.resolveProviderStream({
+		provider: model.provider,
+		config: ctx?.cfg,
+		workspaceDir: ctx?.workspaceDir,
+		env: ctx?.env,
+		context: {
+			config: ctx?.cfg,
+			agentDir: ctx?.agentDir,
+			workspaceDir: ctx?.workspaceDir,
+			provider: model.provider,
+			modelId: model.id,
+			model
+		}
+	}) ?? getAiTransportHost().plugin.resolveProviderStream({
+		provider: "google",
+		config: ctx?.cfg,
+		workspaceDir: ctx?.workspaceDir,
+		env: ctx?.env,
+		context: {
+			config: ctx?.cfg,
+			agentDir: ctx?.agentDir,
+			workspaceDir: ctx?.workspaceDir,
+			provider: model.provider,
+			modelId: model.id,
+			model
+		}
+	}) ?? void 0;
+}
+function createSupportedTransportStreamFn(model, ctx) {
+	switch (model.api) {
+		case "openai-responses":
+		case "openai-chatgpt-responses": return createOpenAIResponsesTransportStreamFn();
+		case "openai-completions": return createOpenAICompletionsTransportStreamFn();
+		case "azure-openai-responses": return createAzureOpenAIResponsesTransportStreamFn();
+		case "anthropic-messages": return createAnthropicMessagesTransportStreamFn();
+		case "google-generative-ai": return createProviderOwnedGoogleTransportStreamFn(model, ctx);
+		default: return;
+	}
+}
+function hasOpenClawTransportRequirement(model) {
+	return getAiTransportHost().requiresManagedTransport(model);
+}
+/** Returns whether OpenClaw has a managed transport implementation for this API. */
+function isTransportAwareApiSupported(api) {
+	return SUPPORTED_TRANSPORT_APIS.has(api);
+}
+/** Maps public model APIs to the internal transport API id used by simple runtime dispatch. */
+function resolveTransportAwareSimpleApi(api) {
+	return SIMPLE_TRANSPORT_API_ALIAS[api];
+}
+/** Creates a managed transport stream only when request overrides require it. */
+function createTransportAwareStreamFnForModel(model, ctx) {
+	if (!hasOpenClawTransportRequirement(model)) return;
+	if (!isTransportAwareApiSupported(model.api)) throw new Error(`Model-provider request.proxy/request.tls/localService is not yet supported for api "${model.api}"`);
+	const streamFn = createSupportedTransportStreamFn(model, ctx);
+	if (!streamFn) throw new Error(`Managed transport stream is unavailable for api "${model.api}"`);
+	return streamFn;
+}
+/** Creates a managed OpenClaw transport stream for explicit fallback/runtime callers. */
+function createOpenClawTransportStreamFnForModel(model, ctx) {
+	if (!isTransportAwareApiSupported(model.api)) return;
+	return createSupportedTransportStreamFn(model, ctx);
+}
+function createBoundaryAwareStreamFnForModel(model, ctx) {
+	if (!isTransportAwareApiSupported(model.api)) return;
+	return createSupportedTransportStreamFn(model, ctx);
+}
+function prepareTransportAwareSimpleModel(model, ctx) {
+	const streamFn = createTransportAwareStreamFnForModel(model, ctx);
+	const alias = resolveTransportAwareSimpleApi(model.api);
+	if (!streamFn || !alias) return model;
+	return getAiTransportHost().inheritManagedTransport(model, {
+		...model,
+		api: alias
+	});
+}
+function buildTransportAwareSimpleStreamFn(model, ctx) {
+	return createTransportAwareStreamFnForModel(model, ctx);
+}
+//#endregion
+//#region packages/ai/src/transports/simple-completion-transport.ts
+const PROVIDER_SIMPLE_COMPLETION_API_PREFIX = "openclaw-provider-simple:";
+const INVALID_CODEX_BASE_URL_MESSAGE = "OpenAI Codex Responses baseUrl must not include query parameters or fragments";
+function registerCustomApi(registry, api, streamFn) {
+	getAiTransportHost().registerCustomApi(registry, api, streamFn);
+	return registry.getApiProvider(api) !== void 0;
+}
+function projectModel(model, patch) {
+	return getAiTransportHost().inheritManagedTransport(model, {
+		...model,
+		...patch
+	});
+}
+function resolveAnthropicVertexSimpleApi(baseUrl) {
+	return `openclaw-anthropic-vertex-simple:${baseUrl?.trim() ? encodeURIComponent(baseUrl.trim()) : "default"}`;
+}
+function normalizeCodexResponsesBaseUrlForOpenAISdk(baseUrl) {
+	const normalized = baseUrl?.trim() || "https://chatgpt.com/backend-api";
+	try {
+		const parsed = new URL(normalized);
+		const pathname = parsed.pathname.replace(/\/+$/u, "");
+		const path = pathname.toLowerCase();
+		if (parsed.hostname.toLowerCase() === "chatgpt.com" && [
+			"/backend-api",
+			"/backend-api/v1",
+			"/backend-api/codex",
+			"/backend-api/codex/v1",
+			"/backend-api/codex/responses"
+		].includes(path)) {
+			parsed.pathname = "/backend-api/codex";
+			parsed.search = "";
+			parsed.hash = "";
+			return parsed.toString().replace(/\/$/u, "");
+		}
+		if (normalized.includes("?") || normalized.includes("#")) throw new Error(INVALID_CODEX_BASE_URL_MESSAGE);
+		parsed.pathname = path.endsWith("/codex/responses") ? pathname.slice(0, -10) : path.endsWith("/codex") ? pathname : `${pathname}/codex`;
+		return parsed.toString();
+	} catch (error) {
+		if (error instanceof Error && error.message === INVALID_CODEX_BASE_URL_MESSAGE) throw error;
+	}
+	if (normalized.includes("?") || normalized.includes("#")) throw new Error(INVALID_CODEX_BASE_URL_MESSAGE);
+	const path = normalized.replace(/\/+$/u, "");
+	if (path.endsWith("/codex/responses")) return path.slice(0, -10);
+	return path.endsWith("/codex") ? path : `${path}/codex`;
+}
+function resolveProviderSimpleCompletionApi(model) {
+	const parts = [
+		model.provider,
+		model.id,
+		model.api,
+		model.baseUrl || "default"
+	];
+	return `${PROVIDER_SIMPLE_COMPLETION_API_PREFIX}${parts.map((part) => encodeURIComponent(part)).join(":")}`;
+}
+function applyProviderSimpleCompletionWrapper(registry, model, cfg) {
+	if (model.api.startsWith(PROVIDER_SIMPLE_COMPLETION_API_PREFIX)) return model;
+	const sourceProvider = registry.getApiProvider(model.api);
+	if (!sourceProvider) return model;
+	const sourceApi = model.api;
+	const sourceStreamFn = (runtimeModel, context, options) => sourceProvider.streamSimple(projectModel(runtimeModel, { api: sourceApi }), context, options);
+	const streamFn = getAiTransportHost().plugin.wrapSimpleCompletionStream({
+		provider: model.provider,
+		config: cfg,
+		context: {
+			config: cfg,
+			provider: model.provider,
+			modelId: model.id,
+			model,
+			streamFn: sourceStreamFn
+		}
+	});
+	if (!streamFn) return model;
+	const api = resolveProviderSimpleCompletionApi(model);
+	return registerCustomApi(registry, api, streamFn) ? projectModel(model, { api }) : model;
+}
+function prepareCodexSimpleTransportModel(registry, model, cfg) {
+	if (model.provider !== "openai" || model.api !== "openai-chatgpt-responses") return;
+	const transportModel = projectModel(model, { baseUrl: normalizeCodexResponsesBaseUrlForOpenAISdk(model.baseUrl) });
+	const api = resolveTransportAwareSimpleApi(model.api);
+	const streamFn = createOpenClawTransportStreamFnForModel(transportModel, { cfg });
+	if (!api || !streamFn) return;
+	if (!registerCustomApi(registry, api, streamFn)) return;
+	return projectModel(transportModel, { api });
+}
+function resolveModelHeaderSentinels(model) {
+	const headers = resolveAiTransportHeaderSentinels(model.headers);
+	return headers === model.headers ? model : projectModel(model, { headers });
+}
+function wrapPluginProviderStream(streamFn) {
+	return (model, context, options) => {
+		const host = getAiTransportHost();
+		const apiKey = options?.apiKey ? host.resolveSecretSentinel(options.apiKey) : options?.apiKey;
+		const headers = resolveAiTransportHeaderSentinels(options?.headers);
+		return streamFn(resolveModelHeaderSentinels(model), context, apiKey === options?.apiKey && headers === options?.headers ? options : {
+			...options,
+			apiKey,
+			headers
+		});
+	};
+}
+function registerProviderStreamForModel(params) {
+	const pluginModel = resolveModelHeaderSentinels(params.model);
+	const providerStreamFn = getAiTransportHost().plugin.resolveProviderStream({
+		provider: params.model.provider,
+		config: params.cfg,
+		context: {
+			config: params.cfg,
+			provider: params.model.provider,
+			modelId: params.model.id,
+			model: pluginModel
+		}
+	});
+	const transportFallback = providerStreamFn ? void 0 : createTransportAwareStreamFnForModel(params.model.api === "google-generative-ai" ? pluginModel : params.model, { cfg: params.cfg });
+	const streamFn = providerStreamFn ? wrapPluginProviderStream(providerStreamFn) : transportFallback && params.model.api === "google-generative-ai" ? wrapPluginProviderStream(transportFallback) : transportFallback;
+	return streamFn && registerCustomApi(params.apiRegistry, params.model.api, streamFn) ? streamFn : void 0;
+}
+function prepareModelForSimpleCompletion(params) {
+	const { apiRegistry, model, cfg } = params;
+	if (!apiRegistry.getApiProvider(model.api) && registerProviderStreamForModel({
+		model,
+		cfg,
+		apiRegistry
+	})) return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
+	const codexTransportModel = prepareCodexSimpleTransportModel(apiRegistry, model, cfg);
+	if (codexTransportModel) return applyProviderSimpleCompletionWrapper(apiRegistry, codexTransportModel, cfg);
+	const transportAwareModel = prepareTransportAwareSimpleModel(model, { cfg });
+	if (transportAwareModel !== model) {
+		const streamFn = buildTransportAwareSimpleStreamFn(model, { cfg });
+		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return applyProviderSimpleCompletionWrapper(apiRegistry, transportAwareModel, cfg);
+	}
+	if (model.api === "google-generative-ai") return applyProviderSimpleCompletionWrapper(apiRegistry, getAiTransportHost().prepareGoogleSimpleCompletionModel(apiRegistry, model), cfg);
+	if (model.provider === "anthropic-vertex") {
+		const api = resolveAnthropicVertexSimpleApi(model.baseUrl);
+		if (registerCustomApi(apiRegistry, api, getAiTransportHost().plugin.createAnthropicVertexStream(model))) return applyProviderSimpleCompletionWrapper(apiRegistry, projectModel(model, { api }), cfg);
+	}
+	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
+}
+//#endregion
+export { GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, coerceTransportToolCallArguments, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, hasOpenAICompatibleConversationTurn, isCodeModeModelVisibleToolName, isOpenAICodexResponsesModel, log, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, quoteUnsafeIntegerLiterals, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveCacheRetention, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend };