@openclaw/ai 2026.8.1-beta.2 → 2026.8.1

package/dist/transports.mjs

@@ -1,31 +1,27 @@
-import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
-import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./anthropic-JsNA5KCu.mjs";
-import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as normalizeLowercaseStringOrEmpty, t as hasNonEmptyString } from "./string-coerce-fsri9iCu.mjs";
-import { r as calculateCost } from "./sanitize-unicode-BYqrYtC_.mjs";
-import { _ as resolveAnthropicThinkingEffort, a as describeToolResultMediaPlaceholder, b as usesClaudeStreamingRefusalContract, d as ANTHROPIC_CLAUDE_CODE_VERSION, f as applyClaudeRequestContract, g as requiresClaudeAdaptiveThinking, h as prepareClaudeNoPrefillRequestContext, l as isImageWithMediaPayload, m as mapAnthropicStopReason, n as getAiTransportHost, o as extractToolResultBlockText, p as defaultsClaudeAdaptiveThinking, r as resolveAiTransportHeaderSentinels, s as extractToolResultText, u as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, y as usesClaudeFable5MessagesContract } from "./host-DTqNc7ad.mjs";
-import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
-import { i as canonicalizeBase64, n as projectProviderError, o as stableStringify } from "./provider-error-BUwEnjXq.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DgNTYnRY.mjs";
-import { r as asNonNegativeFiniteNumber } from "./number-coercion-H9qHik3g.mjs";
-import { _ as isOpenAIGpt56Model, c as OpenAIResponsesWebSocketPostDispatchError, d as OpenAIResponsesWebSocketSafeRetryError, g as isOpenAIGpt55Model, h as isOpenAIGpt54MiniModel, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPreDispatchError, p as parseOpenAIResponsesWebSocketServerError, r as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketResponseFailedError, v as normalizeOpenAIReasoningEffort, w as uniqueStrings, y as resolveOpenAIReasoningEffortForModel } from "./openai-responses-contracts-CyfIkQi5.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { d as resolveClaudeSonnet5ModelIdentity, g as supportsClaudeNativeXhighEffort, p as supportsClaudeAdaptiveThinking, u as resolveClaudeOpus5ModelIdentity } from "./src-Bu3FiFAG.mjs";
+import { c as normalizeLowercaseStringOrEmpty, o as isRecord, s as hasNonEmptyString } from "./utf16-slice-qz3nsy87.mjs";
+import { r as calculateCost } from "./sanitize-unicode-DCkltN94.mjs";
+import { S as usesClaudeStreamingRefusalContract, _ as prepareClaudeNoPrefillRequestContext, a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, f as ANTHROPIC_CLAUDE_CODE_BILLING_SYSTEM_BLOCK, g as mapAnthropicStopReason, h as defaultsClaudeAdaptiveThinking, m as applyClaudeRequestContract, n as getAiTransportHost, p as ANTHROPIC_CLAUDE_CODE_VERSION, r as resolveAiTransportHeaderSentinels, s as extractToolResultBlockText, v as requiresClaudeAdaptiveThinking, x as usesClaudeFable5MessagesContract, y as resolveAnthropicThinkingEffort } from "./host-D51fmkH6.mjs";
+import { i as stableStringify } from "./provider-error-jZP5NMTZ.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-_nhGTn2b.mjs";
+import { a as asNonNegativeFiniteNumber } from "./base64-CEFBpSkN.mjs";
+import { n as uniqueStrings } from "./string-normalization--fwJ4S2q.mjs";
+import { A as applyAnthropicCacheControlToMessages, C as applyAnthropicFallbackBoundary, D as createAnthropicInlineImageBudget, E as applyAnthropicRefusal, F as resolveAnthropicServerCompactionPlan, I as isAnthropicOAuthApiKey, L as omitFoundryBearerCredentialHeaders, M as applyAnthropicPayloadPolicyToParams, N as resolveAnthropicEphemeralCacheControl, O as normalizeAnthropicInlineContent, P as resolveAnthropicPayloadPolicy, R as usesFoundryBearerAuth, T as resolveAnthropicFallbackServingModelCost, _ as toClaudeCodeToolName, a as suppressAnthropicCompaction, b as ANTHROPIC_SERVER_SIDE_FALLBACKS, f as normalizeAnthropicToolCallId, g as resolveOriginalAnthropicToolName, h as reconcileAnthropicToolChoice, i as resolveNewestAnthropicCompaction, j as applyAnthropicEphemeralCacheControlMarkers, k as resolveAnthropicImageMediaType, m as projectAnthropicTools, n as createCompactionCapture, o as applyAnthropicMessageDeltaUsage, p as normalizeAnthropicToolChoice, r as isAnthropicReplayRejection, s as applyAnthropicMessageStartUsage, t as buildAnthropicReplayPlan, v as ANTHROPIC_OMITTED_REASONING_TEXT, w as readAnthropicFallbackBoundary, x as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, y as findActiveAnthropicToolTurnAssistantIndex } from "./anthropic-compaction-replay-CY4tkD4V.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary, t as adjustMaxTokensForThinking } from "./simple-options-D58D5Kvw.mjs";
-import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch, r as resolveModelRequestTimeoutMs, s as resolveProviderRequestPolicyConfig } from "./tool-schema-json-projection-q5d7QX5c.mjs";
-import { A as resolveAnthropicImageMediaType, C as readAnthropicFallbackBoundary, D as usesFoundryBearerAuth, E as omitFoundryBearerCredentialHeaders, F as resolveAnthropicPayloadPolicy, I as resolveAnthropicServerCompactionPlan, M as applyAnthropicEphemeralCacheControlMarkers, N as applyAnthropicPayloadPolicyToParams, O as createAnthropicInlineImageBudget, P as resolveAnthropicEphemeralCacheControl, S as applyAnthropicFallbackBoundary, T as applyAnthropicRefusal, _ as ANTHROPIC_OMITTED_REASONING_TEXT, a as applyAnthropicMessageDeltaUsage, b as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, d as normalizeAnthropicToolCallId, f as normalizeAnthropicToolChoice, g as toClaudeCodeToolName, h as resolveOriginalAnthropicToolName, i as suppressAnthropicCompaction, j as applyAnthropicCacheControlToMessages, k as normalizeAnthropicInlineContent, m as reconcileAnthropicToolChoice, n as createCompactionCapture, o as applyAnthropicMessageStartUsage, p as projectAnthropicTools, r as isAnthropicReplayRejection, t as buildAnthropicReplayPlan, v as findActiveAnthropicToolTurnAssistantIndex, w as resolveAnthropicFallbackServingModelCost, y as ANTHROPIC_SERVER_SIDE_FALLBACKS } from "./anthropic-compaction-replay-8lJNKXOE.mjs";
-import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagPendingCommentaryText, r as convertMessages, s as detectOpenAICompletionsCompat, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-BkFkqqK0.mjs";
+import { a as codeModeToolSurfaceObserver, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking } from "./simple-options-DKx86yX9.mjs";
+import { a as resolveProviderEndpoint, c as transformTransportMessages, i as resolveOpenAIStrictToolSetting, n as buildGuardedModelFetch } from "./tool-schema-json-projection-qvTEs5Am.mjs";
+import { a as isGoogleGemini3FlashModel, c as parseRetryAfterSeconds, f as resolveModelHeaderSentinels$1, i as isCodeModeModelVisibleToolName, l as readResponseTextSnippet, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as redactIdentifier } from "./transport-utils-BHx9z8Cl.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
+import { S as quoteUnsafeIntegerLiterals, _ as transportAbortError, a as createWritableTransportEventStream, b as parseJsonObjectPreservingUnsafeIntegers, c as finalizeTransportStream, d as notifyProviderHttpMetadata, f as notifyProviderHttpResponse, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, i as createEmptyTransportUsage, l as mergeTransportHeaders, m as parseTerminalToolCallArguments, n as coerceTransportToolCallArguments, o as failTransportStream, p as notifyProviderStreamOpened, r as copyProviderAcceptanceObserver, s as finalizeTerminalToolCallArguments, t as assignTransportErrorDetails, u as mergeTransportMetadata, v as withProviderAcceptanceObserver, x as parseJsonPreservingUnsafeIntegers, y as withProviderResponseHook } from "./transport-stream-shared-CT5ycdzn.mjs";
+import { C as createDeepSeekTextFilter, E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, T as tagPendingCommentaryText, _ as hasToolCallHistory, a as buildOpenAISdkClientOptions, b as resolveOpenAICompletionsCompat, c as filterCodeModePayloadTools, d as readCodeModePayloadToolName, f as resolveCodeModeResponsesVisibleToolNames, g as convertMessages, h as resolveOpenAIReasoningEffortMap, i as buildOpenAIClientHeaders, l as getCompat, m as usesNativeOpenAICodexResponsesBackend, n as shouldEmitOpenAICompletionsReasoning, o as buildOpenAISdkRequestOptions, p as resolveOpenAIStrictToolFlagWithDiagnostics, r as assertCodeModeResponsesToolSurface, s as enforceCodeModeResponsesToolSurface, t as processCompletionsStream, u as isOpenAICodexResponsesModel, v as finalizeOpenAICompletionsToolCalls, x as resolveOpenAICompletionsResponseFormat, y as detectOpenAICompletionsCompat } from "./openai-completions-stream-Bpns6uNc.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
-import { n as notifyLlmRequestActivity } from "./headers-DdOQtGuU.mjs";
-import { B as buildResponsesInputMessage, C as summarizeResponsesTools, G as suppressOpenAIResponsesCompaction, H as createOpenAIResponsesAssistantOutput, I as createResponsesStreamWithEncryptedContentRetry, K as resolveReplayableResponsesMessageId, L as isInvalidEncryptedContentError, R as resolveAzureOpenAIApiVersion, S as summarizeResponsesPayload, U as buildOpenAIResponsesReasoningReplayMetadata, V as convertResponsesMessages, W as captureOpenAIResponsesCompaction, Y as normalizeOpenAIStrictToolParameters, Z as resolveOpenAIProjectedToolsStrictToolFlag, _ as safeDebugValue, b as summarizeOpenAITransportError, c as processResponsesStream, dt as resolveModelPayloadDebugMode, f as observeResponsesStream, ft as resolveModelSseDebugMode, g as normalizeResponsesFailedEvent, h as logResponsesFailedNoDetails, ht as quoteUnsafeIntegerLiterals, m as buildResponsesFailedNoDetailsObservation, mt as parseJsonPreservingUnsafeIntegers, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, pt as parseJsonObjectPreservingUnsafeIntegers, q as findOpenAIStrictToolProjectionDiagnostics, ut as emitModelTransportDebug, v as stringifyRedactedEvent, x as summarizeResponsesFailedNoDetailsObservation, y as stringifyRedactedPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DXIt3iY5.mjs";
-import { a as createWritableTransportEventStream, c as mergeTransportHeaders, d as sanitizeTransportPayloadText, f as transportAbortError, i as createEmptyTransportUsage, l as mergeTransportMetadata, n as assignTransportErrorDetails, o as failTransportStream, p as withProviderResponseHook, r as coerceTransportToolCallArguments, s as finalizeTransportStream, u as sanitizeNonEmptyTransportPayloadText } from "./provider-transcript-transform-ePx-Bbfr.mjs";
-import { a as isGoogleGemini3FlashModel, c as readResponseTextSnippet, d as resolveModelHeaderSentinels$1, f as resolveSecretSentinel, i as isCodeModeModelVisibleToolName, l as redactIdentifier, m as supportsModelTools, n as createAbortError$1, o as isGoogleGemini3ProModel, p as sha256Hex, r as estimateStringChars, s as parseRetryAfterSeconds, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-DJqkxbhC.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
+import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as googleFlashSupportsMinimalThinking } from "./google-thinking-level-C-V3tecN.mjs";
-import { a as createModelStreamCooperativeScheduler, c as log, d as readOpenAICompletionsContentDeltas, f as resolvePromptCacheKey, i as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, l as measureUtf8AppendBytes, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIResponseHook, p as throwIfModelStreamAborted, r as reconcileOpenAIResponsesToolChoice, s as isOpenAICompletionsThinkingEnabled, t as projectOpenAITools, u as parseOpenAICompletionsUsage } from "./openai-tool-projection-CY04OcvQ.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-rnPwX2pg.mjs";
-import { i as resolveOpenAIResponsesServerCompactionPlan, n as resolveOpenAIResponsesCompactEndpointPlan, r as resolveOpenAIResponsesPayloadPolicy, t as applyOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy-BDxV-W0c.mjs";
+import { B as buildResponsesInputMessage, C as summarizeResponsesTools, G as captureOpenAIResponsesCompaction, H as createOpenAIResponsesAssistantOutput, I as createResponsesStreamWithEncryptedContentRetry, J as resolveReplayableResponsesMessageId, K as resolveNewestOpenAIResponsesCompactionReplay, L as isInvalidEncryptedContentError, R as resolveAzureOpenAIApiVersion, S as summarizeResponsesPayload, U as CompactionReplayRefreshRequiredError, V as convertResponsesMessages, W as buildOpenAIResponsesReasoningReplayMetadata, X as resolveModelPayloadDebugMode, Y as emitModelTransportDebug, Z as resolveModelSseDebugMode, _ as safeDebugValue, b as summarizeOpenAITransportError, c as processResponsesStream, f as observeResponsesStream, g as normalizeResponsesFailedEvent, h as logResponsesFailedNoDetails, m as buildResponsesFailedNoDetailsObservation, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, q as suppressOpenAIResponsesCompaction, v as stringifyRedactedEvent, x as summarizeResponsesFailedNoDetailsObservation, y as stringifyRedactedPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-zPmKnhF5.mjs";
+import { A as readOpenAICompletionsReasoningBatch, C as createOpenAIProviderAcceptanceHook, D as measureUtf8AppendBytes, E as log, M as resolvePromptCacheKey, N as throwIfModelStreamAborted, O as parseOpenAICompletionsUsage, S as createModelStreamCooperativeScheduler, T as isOpenAICompletionsThinkingEnabled, b as reconcileOpenAIResponsesToolChoice, j as resolveOpenAIClientBaseUrl, k as readOpenAICompletionsContentDeltas, r as normalizeOpenAIStrictToolParameters, v as projectOpenAITools, w as createOpenAIResponseHook, x as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-Dgl4H2MU.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
+import { C as isOpenAIGpt54MiniModel, D as resolveOpenAIReasoningEffortForModel, E as normalizeOpenAIReasoningEffort, T as isOpenAIGpt56Model, _ as OpenAIResponsesWebSocketPostDispatchError, a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, d as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, f as OPENAI_RESPONSES_APIS, i as sanitizeResponsesImagePayload, l as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch, v as OpenAIResponsesWebSocketPreDispatchError, w as isOpenAIGpt55Model, x as parseOpenAIResponsesWebSocketServerError, y as OpenAIResponsesWebSocketSafeRetryError } from "./openai-responses-compaction-window-DwydGZI8.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import { randomUUID } from "node:crypto";
@@ -62,12 +58,9 @@ function resolveAnthropicMessagesMaxTokens(params) {
 	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 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;
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	return endpointClass === "default" || endpointClass === "anthropic-public";
 }
 function isKimiAnthropicProvider(provider) {
@@ -82,7 +75,7 @@ function useAnthropicServerSideFallback(model) {
 	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
 }
 function supportsReasoningContentReplay(model) {
-	return resolveProviderEndpoint(model.baseUrl).endpointClass === "xiaomi-native";
+	return resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
 }
 function buildAnthropicBetaHeader(model, betaFeatures, params) {
 	if (!isDirectAnthropicModel(model)) return;
@@ -304,7 +297,7 @@ function convertAnthropicTools(tools, isOAuthToken) {
 	};
 }
 function parseAnthropicToolCallArguments(inputJson) {
-	return parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson);
+	return coerceTransportToolCallArguments(parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson));
 }
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 /** Resolve the effective Anthropic API base URL from model or environment. */
@@ -407,7 +400,7 @@ async function* parseAnthropicSseBody(body, signal) {
 }
 function createAnthropicMessagesClient(params) {
 	const url = resolveAnthropicMessagesUrl(params.baseURL);
-	return { messages: { async *stream(body, options) {
+	return { messages: { async stream(body, options) {
 		const headers = mergeTransportHeaders({
 			"content-type": "application/json",
 			"anthropic-version": "2023-06-01",
@@ -420,12 +413,10 @@ function createAnthropicMessagesClient(params) {
 			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);
+		return {
+			response,
+			stream: response.body ? parseAnthropicSseBody(response.body, options?.signal) : []
+		};
 	} } };
 }
 function formatAnthropicMessagesHttpError(response, detail) {
@@ -486,7 +477,7 @@ function createAnthropicTransportClient(params) {
 	}
 	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
 	if (needsInterleavedBeta) betaFeatures.push("interleaved-thinking-2025-05-14");
-	if (isAnthropicOAuthToken(apiKey)) {
+	if (isAnthropicOAuthApiKey(apiKey)) {
 		const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: true });
 		return {
 			client: createAnthropicMessagesClient({
@@ -536,7 +527,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		baseUrl: model.baseUrl,
 		cacheRetention: options?.cacheRetention,
 		enableCacheControl: true
-	});
+	}, model);
 	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
 	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
 		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
@@ -620,7 +611,7 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 	const reasoningModelMaxTokens = resolvePositiveAnthropicTokenLimit(model.maxTokens) ?? baseMaxTokens;
 	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
 	const reasoning = options?.reasoning === "off" && mandatoryAdaptiveThinking ? "low" : options?.reasoning;
-	const resolved = {
+	const resolved = copyProviderAcceptanceObserver(options, {
 		temperature: options?.temperature,
 		stop: options?.stop,
 		maxTokens: baseMaxTokens,
@@ -630,6 +621,7 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 		sessionId: options?.sessionId,
 		headers: options?.headers,
 		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
 		maxRetryDelayMs: options?.maxRetryDelayMs,
 		metadata: options?.metadata,
 		interleavedThinking: options?.interleavedThinking,
@@ -638,7 +630,7 @@ function resolveAnthropicTransportOptions(model, options, apiKey) {
 		reasoning,
 		...options?.anthropicServerCompaction === true ? { anthropicServerCompaction: true } : {},
 		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
-	};
+	});
 	if (reasoning === "off") {
 		resolved.thinkingEnabled = false;
 		return resolved;
@@ -700,12 +692,23 @@ function createAnthropicMessagesTransportStreamFn() {
 				const nextParams = await transportOptions.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				applyClaudeRequestContract(params, model);
-				const anthropicStream = client.messages.stream({
+				const { response, stream: anthropicStream } = await client.messages.stream({
 					...params,
 					stream: true
 				}, transportOptions.signal ? { signal: transportOptions.signal } : void 0);
+				await notifyProviderHttpResponse({
+					options: transportOptions,
+					response,
+					model
+				});
+				if (!response.ok) {
+					const detail = await readAnthropicMessagesErrorBodySnippet(response);
+					throw new Error(formatAnthropicMessagesHttpError(response, detail));
+				}
 				const blocks = output.content;
 				const blockIndexes = /* @__PURE__ */ new Map();
+				const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
+				const sealedToolCalls = [];
 				const compactionCapture = createCompactionCapture(output, model, transportOptions);
 				const pendingThinkingSignatures = /* @__PURE__ */ new Map();
 				const allowReasoningContentReplay = supportsReasoningContentReplay(model);
@@ -740,6 +743,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							partial: output
 						});
 					}
+					if (contentIndex === void 0) return false;
 					block.thinking += text;
 					block.thinkingSignature = "reasoning_content";
 					eventSink.push({
@@ -771,6 +775,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							partial: output
 						});
 					}
+					if (contentIndex === void 0) return false;
 					block.text += text;
 					eventSink.push({
 						type: "text_delta",
@@ -833,6 +838,7 @@ function createAnthropicMessagesTransportStreamFn() {
 						const fallbackBoundary = refusalBuffer ? readAnthropicFallbackBoundary(contentBlock) : null;
 						if (fallbackBoundary) {
 							refusalBuffer?.discard();
+							sealedToolCalls.length = 0;
 							pendingTextEnds.length = 0;
 							blockIndexes.clear();
 							pendingThinkingSignatures.clear();
@@ -955,6 +961,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							};
 							output.content.push(block);
 							blockIndexes.set(index, output.content.length - 1);
+							toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
 							eventSink.push({
 								type: "toolcall_start",
 								contentIndex: output.content.length - 1,
@@ -975,7 +982,7 @@ function createAnthropicMessagesTransportStreamFn() {
 							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") {
+								if (text.length > 0) if (block?.type === "text" && index !== void 0) {
 									block.text += text;
 									eventSink.push({
 										type: "text_delta",
@@ -1003,6 +1010,7 @@ function createAnthropicMessagesTransportStreamFn() {
 								partial: output
 							});
 						}
+						if (index === void 0) continue;
 						if (block?.type === "text" && delta?.type === "text_delta" && typeof delta.text === "string") {
 							block.text += delta.text;
 							eventSink.push({
@@ -1026,7 +1034,7 @@ function createAnthropicMessagesTransportStreamFn() {
 						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);
+							if (toolArgumentPreviewSchedules.get(block)?.(partialJson.length)) block.arguments = parseAnthropicToolCallArguments(partialJson);
 							eventSink.push({
 								type: "toolcall_delta",
 								contentIndex: index,
@@ -1080,12 +1088,9 @@ function createAnthropicMessagesTransportStreamFn() {
 							continue;
 						}
 						if (block.type === "toolCall") {
-							delete block.partialJson;
-							eventSink.push({
-								type: "toolcall_end",
-								contentIndex: index,
-								toolCall: block,
-								partial: output
+							sealedToolCalls.push({
+								block,
+								contentIndex: index
 							});
 							finishReasoningContentSidecars(event.index);
 						}
@@ -1105,6 +1110,17 @@ function createAnthropicMessagesTransportStreamFn() {
 				if (isDirectAnthropicModel(model) && !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");
+				if ([...blockIndexes.values()].some((index) => blocks[index]?.type === "toolCall")) throw new Error("Provider completed stream with an incomplete tool call");
+				finalizeTerminalToolCallArguments(sealedToolCalls.map(({ block }) => block), (block) => block.partialJson && block.partialJson.length > 0 ? block.partialJson : block.arguments);
+				for (const sealed of sealedToolCalls) {
+					delete sealed.block.partialJson;
+					eventSink.push({
+						type: "toolcall_end",
+						contentIndex: sealed.contentIndex,
+						toolCall: sealed.block,
+						partial: output
+					});
+				}
 				refusalBuffer?.flush();
 				if (output.stopReason === "toolUse" || output.content.some((block) => block.type === "toolCall")) tagPendingCommentaryText(output.content);
 				flushPendingTextEnds();
@@ -1116,7 +1132,7 @@ function createAnthropicMessagesTransportStreamFn() {
 				if (refusalBuffer) {
 					refusalBuffer.discard();
 					output.content = [];
-				}
+				} else output.content = output.content.filter((block) => block.type !== "toolCall");
 				if (usedCompactionReplay && isAnthropicReplayRejection(error)) suppressAnthropicCompaction(output, model, options);
 				failTransportStream({
 					stream,
@@ -1133,96 +1149,6 @@ function createAnthropicMessagesTransportStreamFn() {
 	};
 }
 //#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.
@@ -1521,202 +1447,10 @@ function applyCompletionsReplay(outgoingMessages, context, model, compat) {
 	});
 }
 //#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 Object.hasOwn(record, field) ? record[field] : void 0;
-	} catch {
-		return;
-	}
-}
-function readCodeModePayloadToolName(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 readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes) {
-	if (!isRecord(tool)) return;
-	const type = readToolPayloadField(tool, "type");
-	if (typeof type === "string" && allowedHostedToolTypes?.has(type)) {
-		try {
-			if (Object.hasOwn(tool, "name") || Object.hasOwn(tool, "function") || Object.hasOwn(tool, "functionDeclarations") || Object.hasOwn(tool, "function_declarations")) return false;
-		} catch {
-			return false;
-		}
-		return `hosted:${type}`;
-	}
-	const name = readCodeModePayloadToolName(tool);
-	return typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames) ? `client:${name}` : void 0;
-}
-function filterCodeModePayloadTools(payload, visibleToolNames, allowedHostedToolTypes) {
-	if (!isRecord(payload)) return;
-	const tools = readToolPayloadField(payload, "tools");
-	if (!Array.isArray(tools)) return;
-	payload.tools = tools.flatMap((tool) => {
-		const identity = readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes);
-		if (identity) return [tool];
-		if (identity === false) return [];
-		if (!isRecord(tool)) return [];
-		const filteredGroups = {};
-		for (const key of ["functionDeclarations", "function_declarations"]) {
-			const declarations = readToolPayloadField(tool, key);
-			if (!Array.isArray(declarations)) continue;
-			const filtered = declarations.filter((declaration) => {
-				const declarationName = readCodeModePayloadToolName(declaration);
-				return typeof declarationName === "string" && isCodeModeModelVisibleToolName(declarationName, visibleToolNames);
-			});
-			if (filtered.length > 0) filteredGroups[key] = filtered;
-		}
-		return Object.keys(filteredGroups).length > 0 ? [filteredGroups] : [];
-	});
-}
-function resolveCodeModeResponsesVisibleToolNames(context) {
-	return new Set((context.tools ?? []).map(readCodeModePayloadToolName).filter((name) => typeof name === "string"));
-}
-function enforceCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes) {
-	if (!isRecord(payload)) return;
-	const tools = readToolPayloadField(payload, "tools");
-	if (!Array.isArray(tools)) return;
-	payload.tools = tools.filter((tool) => Boolean(readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes)));
-}
-function assertCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes) {
-	const tools = isRecord(payload) ? readToolPayloadField(payload, "tools") : void 0;
-	if (!Array.isArray(tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
-	const identities = tools.map((tool) => readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes));
-	const names = identities.flatMap((identity) => typeof identity === "string" && identity.startsWith("client:") ? [identity.slice(7)] : []).toSorted((left, right) => left.localeCompare(right));
-	if (names.length >= 2 && identities.every((identity) => typeof identity === "string") && new Set(identities).size === identities.length && names.includes("exec") && names.includes("wait")) 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, timeoutMs) {
-	return resolveModelRequestTimeoutMs(model, timeoutMs);
-}
-function buildOpenAISdkClientOptions(model) {
-	const timeout = resolveOpenAISdkTimeoutMs(model);
-	return timeout === void 0 ? {} : { timeout };
-}
-function buildOpenAISdkRequestOptions(model, signal, options) {
-	const timeout = resolveOpenAISdkTimeoutMs(model, options?.timeoutMs);
-	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
-	if (timeout === void 0 && options?.maxRetries === void 0 && !signal && !headers) return;
-	return {
-		...headers ? { headers } : {},
-		...signal ? { signal } : {},
-		...timeout !== void 0 ? { timeout } : {},
-		...options?.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
-	};
-}
-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-params.ts
 function isKnownOpenAICompletionsEndpoint(model) {
 	if (!model.baseUrl.trim()) return true;
-	const endpointClass = resolveProviderEndpoint(model.baseUrl).endpointClass;
+	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
 	try {
 		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
@@ -1724,7 +1458,7 @@ function isKnownOpenAICompletionsEndpoint(model) {
 		return false;
 	}
 }
-function resolveOpenAICompletionsReasoningEffort$1(options) {
+function resolveOpenAICompletionsReasoningEffort(options) {
 	return options?.reasoningEffort ?? options?.reasoning ?? "high";
 }
 function resolveOpenAICompletionsMaxTokens(model, options) {
@@ -1923,7 +1657,7 @@ function buildOpenAICompletionsParams(model, context, options) {
 		if (clampedMaxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
 		else params.max_completion_tokens = clampedMaxTokens;
 	}
-	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort$1(options);
+	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
 	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
 		model,
 		effort: completionsReasoningEffort,
@@ -1949,713 +1683,6 @@ function buildOpenAICompletionsParams(model, context, options) {
 	return params;
 }
 //#endregion
-//#region packages/ai/src/transports/openai-completions-dsml.ts
-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_INVOKE_OPEN_PREFIXES = DEEPSEEK_DSML_BARS.map((bar) => `<${bar}DSML${bar}invoke`);
-const DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.map((bar) => `</${bar}DSML${bar}invoke>`);
-const DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length));
-const DEEPSEEK_DSML_RECOVERY_MAX_BOUNDARY_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_TOOL_CLOSE_TOKENS.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES.map((token) => token.length), ...DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS.map((token) => token.length));
-const MAX_DSML_RECOVERY_BUFFER_BYTES = 256e3;
-const DEEPSEEK_DSML_SCAN_BATCH_CHARS = 64 * 1024;
-function createDsmlRecoverer() {
-	let buffer = "";
-	let bufferBytes = 0;
-	let bufferEndsWithHighSurrogate = false;
-	let pendingScanChars = 0;
-	let activeOpenToken = null;
-	let blockScanState = {
-		offset: 0,
-		mode: "outer",
-		invokeOpenStart: -1
-	};
-	const resetBlockScan = () => {
-		activeOpenToken = null;
-		pendingScanChars = 0;
-		blockScanState = {
-			offset: 0,
-			mode: "outer",
-			invokeOpenStart: -1
-		};
-	};
-	const consume = (final) => {
-		const output = [];
-		while (buffer) {
-			const open = activeOpenToken ? {
-				index: 0,
-				token: activeOpenToken
-			} : findEarliestStringToken(buffer, DEEPSEEK_DSML_TOOL_OPEN_TOKENS);
-			if (!open) {
-				resetBlockScan();
-				if (final) {
-					output.push({
-						kind: "text",
-						text: buffer
-					});
-					buffer = "";
-					bufferBytes = 0;
-					bufferEndsWithHighSurrogate = false;
-					return output;
-				}
-				const keep = longestDeepSeekDsmlToolOpenPrefixSuffixLength(buffer);
-				const emitLength = buffer.length - keep;
-				if (emitLength > 0) {
-					const emitted = buffer.slice(0, emitLength);
-					output.push({
-						kind: "text",
-						text: emitted
-					});
-					bufferBytes -= Buffer.byteLength(emitted, "utf8");
-					buffer = buffer.slice(emitted.length);
-					if (!buffer) bufferEndsWithHighSurrogate = false;
-				}
-				return output;
-			}
-			if (open.index > 0) {
-				const prefix = buffer.slice(0, open.index);
-				output.push({
-					kind: "text",
-					text: prefix
-				});
-				bufferBytes -= Buffer.byteLength(prefix, "utf8");
-				buffer = buffer.slice(prefix.length);
-				resetBlockScan();
-			}
-			activeOpenToken = open.token;
-			if (blockScanState.offset === 0) blockScanState.offset = open.token.length;
-			const blockScan = scanDeepSeekDsmlToolBlock(buffer, open.token.replace("<", "</"), open.token.length, blockScanState);
-			if (blockScan.kind === "nested-open") throw new Error("Nested DeepSeek DSML recovery wrappers are not supported");
-			const close = blockScan.kind === "close" ? blockScan : null;
-			if (!close) {
-				if (final) {
-					output.push({
-						kind: "text",
-						text: buffer
-					});
-					buffer = "";
-					bufferBytes = 0;
-					bufferEndsWithHighSurrogate = false;
-					return output;
-				}
-				if (bufferBytes > MAX_DSML_RECOVERY_BUFFER_BYTES) throw new Error("Exceeded DeepSeek DSML recovery buffer limit");
-				return output;
-			}
-			resetBlockScan();
-			const body = buffer.slice(open.token.length, close.index);
-			const blockText = buffer.slice(0, close.index + close.token.length);
-			if (Buffer.byteLength(blockText, "utf8") > MAX_DSML_RECOVERY_BUFFER_BYTES) throw new Error("Exceeded DeepSeek DSML recovery buffer limit");
-			const recoveredToolCalls = parseDeepSeekDsmlToolCallBlock(body);
-			if (recoveredToolCalls.length > 0) output.push(...recoveredToolCalls);
-			else output.push({
-				kind: "text",
-				text: blockText
-			});
-			bufferBytes -= Buffer.byteLength(blockText, "utf8");
-			buffer = buffer.slice(blockText.length);
-			if (!buffer) bufferEndsWithHighSurrogate = false;
-		}
-		return output;
-	};
-	return {
-		push(chunk) {
-			const append = measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk);
-			bufferBytes += append.bytes;
-			bufferEndsWithHighSurrogate = append.endsWithHighSurrogate;
-			buffer += chunk;
-			pendingScanChars += chunk.length;
-			if (activeOpenToken && pendingScanChars < DEEPSEEK_DSML_SCAN_BATCH_CHARS && !chunk.includes("<") && !chunk.includes(">") && bufferBytes <= MAX_DSML_RECOVERY_BUFFER_BYTES) return [];
-			pendingScanChars = 0;
-			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 invokeBodyStart = openMatch.index + openMatch[0].length;
-		const invokeClose = findEarliestStringToken(body.slice(invokeBodyStart), ["</|DSML|invoke>", "</｜DSML｜invoke>"]);
-		if (!invokeClose) break;
-		const invokeBody = body.slice(invokeBodyStart, invokeBodyStart + invokeClose.index);
-		invokeOpenRegex.lastIndex = invokeBodyStart + invokeClose.index + invokeClose.token.length;
-		const invokeName = parseXmlAttribute(openMatch[1] ?? "", "name");
-		if (!invokeName) continue;
-		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, fromIndex = 0) {
-	let best = null;
-	for (const token of tokens) {
-		const index = text.indexOf(token, fromIndex);
-		if (index !== -1 && (!best || index < best.index)) best = {
-			index,
-			token
-		};
-	}
-	return best;
-}
-function scanDeepSeekDsmlToolBlock(text, closeToken, contentStartIndex, state) {
-	while (state.offset < text.length) {
-		if (state.mode === "invoke-open") {
-			const nextOpen = text.indexOf("<", state.offset);
-			const nextClose = text.indexOf(">", state.offset);
-			if (nextClose === -1 && nextOpen === -1) {
-				state.offset = text.length;
-				return { kind: "incomplete" };
-			}
-			if (nextOpen !== -1 && (nextClose === -1 || nextOpen < nextClose)) {
-				state.mode = "outer";
-				state.offset = nextOpen;
-				state.invokeOpenStart = -1;
-				continue;
-			}
-			const invokeOpenTag = text.slice(state.invokeOpenStart, nextClose + 1);
-			if (!/^<[|｜]DSML[|｜]invoke\b[^<>]*>$/.test(invokeOpenTag)) {
-				state.mode = "outer";
-				state.offset = state.invokeOpenStart + 1;
-				state.invokeOpenStart = -1;
-				continue;
-			}
-			state.mode = "invoke-body";
-			state.offset = nextClose + 1;
-			state.invokeOpenStart = -1;
-			continue;
-		}
-		if (state.mode === "invoke-body") {
-			const invokeClose = findEarliestStringToken(text, DEEPSEEK_DSML_INVOKE_CLOSE_TOKENS, state.offset);
-			if (!invokeClose) {
-				state.offset = Math.max(0, text.length - DEEPSEEK_DSML_RECOVERY_MAX_BOUNDARY_LEN + 1);
-				return { kind: "incomplete" };
-			}
-			state.mode = "outer";
-			state.offset = invokeClose.index + invokeClose.token.length;
-			continue;
-		}
-		const toolOpen = findEarliestStringToken(text, DEEPSEEK_DSML_TOOL_OPEN_TOKENS, state.offset);
-		const toolCloseIndex = text.indexOf(closeToken, state.offset);
-		const invokeOpen = findEarliestStringToken(text, DEEPSEEK_DSML_INVOKE_OPEN_PREFIXES, state.offset);
-		const next = [
-			toolOpen ? {
-				kind: "nested-open",
-				...toolOpen
-			} : null,
-			toolCloseIndex === -1 ? null : {
-				kind: "close",
-				index: toolCloseIndex,
-				token: closeToken
-			},
-			invokeOpen ? {
-				kind: "invoke-open",
-				...invokeOpen
-			} : null
-		].filter((candidate) => candidate !== null).toSorted((left, right) => left.index - right.index)[0];
-		if (!next) {
-			state.offset = Math.max(contentStartIndex, text.length - DEEPSEEK_DSML_RECOVERY_MAX_BOUNDARY_LEN + 1);
-			return { kind: "incomplete" };
-		}
-		if (next.kind === "invoke-open") {
-			state.mode = "invoke-open";
-			state.invokeOpenStart = next.index;
-			state.offset = next.index + next.token.length;
-			continue;
-		}
-		return next;
-	}
-	return { kind: "incomplete" };
-}
-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;
-}
-//#endregion
-//#region packages/ai/src/transports/openai-completions-stream.ts
-function extractToolCallThoughtSignature(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;
-	if (typeof fromFunction === "string" && fromFunction.length > 0) return fromFunction;
-	const fromToolCall = tc.thought_signature;
-	return typeof fromToolCall === "string" && fromToolCall.length > 0 ? fromToolCall : void 0;
-}
-async function processCompletionsStream(responseStream, output, model, stream, options) {
-	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
-	const emitReasoning = options?.emitReasoning ?? true;
-	const compat = getCompat(model);
-	const shouldFilterDeepSeekDsmlText = compat.thinkingFormat === "deepseek";
-	const deepSeekTextFilter = shouldFilterDeepSeekDsmlText ? createDeepSeekTextFilter() : null;
-	const deepSeekToolCallRecoverer = shouldFilterDeepSeekDsmlText ? createDsmlRecoverer() : 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 toolCallBlockIndices = /* @__PURE__ */ new WeakMap();
-	const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
-	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({ 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;
-		}
-		notifyLlmRequestActivity(options?.signal);
-		const chunk = rawChunk;
-		output.responseId ||= chunk.id;
-		let hasReasoningUsageActivity = false;
-		if (chunk.usage) {
-			output.usage = parseOpenAICompletionsUsage(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 = parseOpenAICompletionsUsage(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 rawChoiceDelta = choice.delta ?? choice.message;
-		if (!rawChoiceDelta) {
-			emitReasoningUsageActivity(hasReasoningUsageActivity);
-			await cooperativeScheduler.afterEvent();
-			continue;
-		}
-		for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
-			const choiceDelta = normalizedDelta.delta;
-			const reasoningDeltas = getCompletionsReasoningDeltas(choiceDelta, compat.visibleReasoningDetailTypes);
-			const hasMirroredReasoning = reasoningDeltas.some((delta) => delta.kind === "thinking");
-			if (hasMirroredReasoning) reasoningTagTextPartitioner.markStrict();
-			const contentDeltas = readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, reasoningDeltas.filter((reasoningDelta) => reasoningDelta.kind === "thinking").map((reasoningDelta) => reasoningDelta.text));
-			const appendReasoningDeltas = () => {
-				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 (hasMirroredReasoning) appendReasoningDeltas();
-			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 {
-				if (reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
-				appendRoutedContentDelta(contentDelta);
-			}
-			if (!hasMirroredReasoning) appendReasoningDeltas();
-			const toolCallDeltas = normalizedDelta.toolCalls;
-			if (toolCallDeltas.length > 0) {
-				sawNativeToolCallDelta = true;
-				flushReasoningTagTextPartitionerAtEnd();
-				rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-				for (const toolCall of toolCallDeltas) {
-					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 = extractToolCallThoughtSignature(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 = extractToolCallThoughtSignature(toolCall);
-					if (deltaSig) block.thoughtSignature = deltaSig;
-					if (toolCall.function?.arguments) {
-						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();
-	finalizeOpenAICompletionsToolCalls(output, {
-		allowSilentToolCallPromotion: sawStopFinishReason || sawNativeToolCallDelta && (options?.sawStreamDONE?.() ?? false),
-		onConfirmedToolCall(block, contentIndex) {
-			pushStreamEvent({
-				type: "toolcall_end",
-				contentIndex,
-				toolCall: block,
-				partial: output
-			});
-		}
-	});
-	if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
-	if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
-}
-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 hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
-	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
-}
-//#endregion
 //#region packages/ai/src/transports/openai-completions-transport.ts
 function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
 	const messages = params.messages;
@@ -2731,15 +1758,14 @@ function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
 		}
 	}
 	return {
-		baseURL,
+		baseURL: resolveOpenAIClientBaseUrl(model, baseURL),
 		defaultHeaders: headers,
 		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
 	};
 }
 function createOpenAICompletionsTransportStreamFn() {
 	return (model, context, options) => {
-		const eventStream = createAssistantMessageEventStream();
-		const stream = eventStream;
+		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
 			const output = {
 				role: "assistant",
@@ -2794,7 +1820,7 @@ function createOpenAICompletionsTransportStreamFn() {
 				if (nextParams !== void 0) params = nextParams;
 				if (options?.openclawCodeModeToolSurface === true) {
 					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
-					enforceCodeModeResponsesToolSurface(params, visibleToolNames);
+					enforceCodeModeResponsesToolSurface(params, visibleToolNames, void 0, codeModeToolSurfaceObserver.get(options));
 					assertCodeModeResponsesToolSurface(params, visibleToolNames);
 				}
 				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
@@ -2808,7 +1834,7 @@ function createOpenAICompletionsTransportStreamFn() {
 					stream: responseStream,
 					signal: firstEventAbort.signal,
 					abort: firstEventAbort.abort,
-					hook: createOpenAIResponseHook(options?.onResponse, response, model),
+					hook: createOpenAIProviderAcceptanceHook(options, response, model),
 					onReady: () => stream.push({
 						type: "start",
 						partial: output
@@ -2816,6 +1842,7 @@ function createOpenAICompletionsTransportStreamFn() {
 				}), output, model, stream, {
 					signal: options?.signal,
 					emitReasoning,
+					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
 					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 					abortFirstEventStream: firstEventAbort.abort,
 					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
@@ -2835,6 +1862,7 @@ function createOpenAICompletionsTransportStreamFn() {
 					cleanup: () => {
 						output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 						finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
+						tagUnresolvedTextAsCommentary(output);
 					}
 				});
 			} finally {
@@ -2889,7 +1917,7 @@ function jsonValuesEqual(left, right) {
 	return stableStringify(JSON.parse(JSON.stringify(left))) === stableStringify(JSON.parse(JSON.stringify(right)));
 }
 function requestWithoutInput(request) {
-	const { input: _input, previous_response_id: _previousResponseId, ...rest } = request;
+	const { input: _input, previous_response_id: _previousResponseId, instructions: _instructions, ...rest } = request;
 	if (!isRecord(rest.metadata)) return rest;
 	const metadata = Object.fromEntries(Object.entries(rest.metadata).filter(([key]) => key !== "openclaw_turn_id" && key !== "openclaw_turn_attempt"));
 	return {
@@ -3080,18 +2108,27 @@ function sanitizeOpenAICodexResponsesParams(model, params) {
 	stripOpenAICodexResponsesUnsupportedTextFields(params);
 	return params;
 }
-function buildOpenAICodexResponsesInstructions(context) {
+function buildOpenAIResponsesInstructionsText(context) {
 	if (!context.systemPrompt) return;
 	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
 }
-function resolveOpenAICodexResponsesInstructions(model, context) {
-	const instructions = buildOpenAICodexResponsesInstructions(context);
+function resolveOpenAIResponsesInstructions(model, context, usesInstructionsField) {
+	if (!usesInstructionsField) return;
+	const instructions = buildOpenAIResponsesInstructionsText(context);
 	if (instructions && instructions.trim().length > 0) return instructions;
 	return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
 }
-function ensureOpenAICodexResponsesInput(messages, context) {
+function buildOpenAIResponsesCompactSystemMessage(model, instructions) {
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	return buildResponsesInputMessage(model.reasoning && supportsDeveloperRole !== false ? "developer" : "system", [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(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.");
+	if (!buildOpenAIResponsesInstructionsText(context)) throw new Error("OpenAI Responses requires non-empty input when only systemPrompt is provided.");
 	messages.push(buildResponsesInputMessage("user", [{
 		type: "input_text",
 		text: " "
@@ -3105,16 +2142,12 @@ function resolveOpenAIResponsesTextFormat(responseFormat) {
 	return responseFormat;
 }
 function convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode) {
-	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);
 	return convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
-		includeSystemPrompt: !isCodexResponses,
-		supportsDeveloperRole,
+		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
 		replayReasoningItems: true,
 		replayResponsesItemIds,
 		authProfileId: options?.authProfileId,
@@ -3123,19 +2156,19 @@ function convertOpenAIResponsesMessagesForRequest(model, context, options, repla
 	});
 }
 function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
-	const isCodexResponses = isOpenAICodexResponsesModel(model);
 	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
 	const messages = convertOpenAIResponsesMessagesForRequest(model, context, options, replayMode);
-	if (isCodexResponses) ensureOpenAICodexResponsesInput(messages, context);
+	ensureOpenAIResponsesNonEmptyInput(messages, context);
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
+	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
 	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) } : {},
+		...instructions ? { instructions } : {},
 		...metadata ? { metadata } : {}
 	};
 	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
@@ -3405,9 +2438,8 @@ function createOpenAIResponsesWebSocketStream(params) {
 					}
 					const event = readServerEvent(next.value);
 					if (!event) continue;
-					if (event.type === "response.failed") throw new OpenAIResponsesWebSocketResponseFailedError(event.response.output.length > 0);
 					if (event.type === "response.completed") terminalResponse = event.response;
-					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete";
+					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
 					yield event;
 					if (terminalReceived) {
 						degradedWebSocketConnections.delete(degradationKey);
@@ -3419,7 +2451,7 @@ function createOpenAIResponsesWebSocketStream(params) {
 				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError;
 				if (!params.callerSignal?.aborted && !safeRetry) markDegraded();
 				if (!requestDispatched && !params.signal?.aborted) throw new OpenAIResponsesWebSocketPreDispatchError(error);
-				if (!requestDispatched || params.callerSignal?.aborted || error instanceof OpenAIResponsesWebSocketResponseFailedError || safeRetry) throw error;
+				if (!requestDispatched || params.callerSignal?.aborted || safeRetry) throw error;
 				throw new OpenAIResponsesWebSocketPostDispatchError(error);
 			} finally {
 				await iterator.return?.().catch(() => void 0);
@@ -3441,149 +2473,6 @@ function closeOpenAIResponsesWebSocketSessions(sessionId) {
 }
 registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
 //#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 resolveNativeOpenAIResponsesWebSocketMode(model, transport) {
 	if (transport !== "websocket" && transport !== "websocket-cached" && transport !== "auto") return;
@@ -3617,17 +2506,18 @@ function resolveProviderTransportTurnState(model, params) {
 		}
 	});
 }
-function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId) {
+function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders, sessionId, fetchOverride) {
 	return new OpenAI({
 		apiKey,
-		baseURL: model.baseUrl,
+		baseURL: resolveOpenAIClientBaseUrl(model),
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId),
-		fetch: buildGuardedModelFetch(model),
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
 	});
 }
 async function postOpenAIResponsesCompaction(params) {
+	const compactInput = typeof params.request.instructions === "string" && params.request.instructions.length > 0 ? [buildOpenAIResponsesCompactSystemMessage(params.model, params.request.instructions), ...params.request.input ?? []] : params.request.input;
 	const response = await params.client.post("/responses/compact", {
 		...buildOpenAISdkRequestOptions(params.model, params.options?.signal, {
 			timeoutMs: params.options?.timeoutMs,
@@ -3635,15 +2525,21 @@ async function postOpenAIResponsesCompaction(params) {
 		}),
 		body: {
 			model: params.request.model,
-			input: params.request.input
+			input: compactInput
 		}
 	});
 	const output = isRecord(response) && Array.isArray(response.output) ? response.output : [];
-	const item = output[0];
+	const item = output.at(-1);
+	const retainedItems = output.slice(0, -1);
+	const retainedUserMessageCount = retainedItems.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user" && Array.isArray(candidate.content)).length;
+	const inputUserMessageCount = Array.isArray(params.request.input) ? params.request.input.filter((candidate) => isRecord(candidate) && candidate.type === "message" && candidate.role === "user").length : 0;
+	const retainedMessagePrefixSupported = supportsNativeOpenAIResponsesEndpoint(params.model);
 	const usage = isRecord(response) && isRecord(response.usage) ? response.usage : void 0;
-	if (!isRecord(response) || response.object !== "response.compaction" || output.length !== 1 || !isRecord(item) || item.type !== "compaction" || typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0 || !usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") throw new Error("Responses compact endpoint did not return exactly one compaction item");
+	if (!isRecord(response) || response.object !== "response.compaction" || !isOpenAIResponsesCompactionOutput(output, params.model) || retainedItems.length > 0 && (!retainedMessagePrefixSupported || retainedUserMessageCount !== inputUserMessageCount) || !isRecord(item) || item.type !== "compaction" || typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0 || !usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") throw new Error("Responses compact endpoint did not return one trailing compaction item");
 	return {
+		output,
 		item,
+		historyMode: retainedUserMessageCount > 0 ? "retained-users" : "compacted-prefix",
 		usage,
 		model: params.model,
 		replayMetadata: buildOpenAIResponsesReasoningReplayMetadata(params.model, {
@@ -3656,8 +2552,7 @@ function createResponsesTransportExecutor(config) {
 	return (model, context, options) => {
 		const responsesOptions = options;
 		const compactRequest = claimResponsesCompactRequest(responsesOptions);
-		const eventStream = createAssistantMessageEventStream();
-		const stream = eventStream;
+		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
 			const output = createOpenAIResponsesAssistantOutput(model, config.outputApi);
 			let firstEventAbort;
@@ -3673,7 +2568,7 @@ function createResponsesTransportExecutor(config) {
 				});
 				const websocketSessionPolicy = websocketMode ? turnState?.websocket : void 0;
 				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketSessionPolicy?.headers, options?.sessionId) : void 0;
-				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId);
+				const client = config.createClient(model, context, apiKey, options?.headers, turnState?.headers, options?.sessionId, compactRequest ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : void 0);
 				const buildRequest = async (replayMode) => {
 					let params = config.buildRequest(model, context, responsesOptions, turnState?.metadata, replayMode);
 					const nextParams = await options?.onPayload?.(params, model);
@@ -3684,7 +2579,7 @@ function createResponsesTransportExecutor(config) {
 					if (options?.openclawCodeModeToolSurface === true) {
 						const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
 						const allowedHostedToolTypes = responsesOptions?.openclawCodeModeAllowedHostedToolTypes;
-						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
+						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
 						assertCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes);
 					}
 					return params;
@@ -3701,12 +2596,11 @@ function createResponsesTransportExecutor(config) {
 					output.usage.output = compacted.usage.output_tokens;
 					output.usage.totalTokens = compacted.usage.input_tokens + compacted.usage.output_tokens;
 					compactRequest.resolve(compacted);
-					stream.push({
-						type: "done",
-						reason: output.stopReason,
-						message: output
+					finalizeTransportStream({
+						stream,
+						output,
+						signal: options?.signal
 					});
-					stream.end();
 					return;
 				}
 				const sessionId = options?.sessionId;
@@ -3744,7 +2638,7 @@ function createResponsesTransportExecutor(config) {
 				emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} requestIdHash=${redactIdentifier(options?.requestId, { len: 64 })} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
 				let continuationBaseline;
 				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
-					const { stream: rawResponseStream, response, attempt } = await config.createResponseStream({
+					const { stream: responseStream } = await config.createResponseStream({
 						client,
 						request: initialRequest,
 						requestOptions,
@@ -3753,19 +2647,23 @@ function createResponsesTransportExecutor(config) {
 						initialAttemptKind,
 						initialRejectedCompaction,
 						buildFullHistoryRequest: () => buildRequest("full-history"),
-						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint)
-					});
-					if (continuationClaim) continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
-					return withProviderResponseHook({
-						stream: observeResponsesStream(rawResponseStream, model, requestStartedAt),
-						signal: firstEvent.signal,
-						abort: firstEvent.abort,
-						hook: createOpenAIResponseHook(options?.onResponse, response, model),
-						onReady: () => {
-							emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} transport=sse elapsedMs=${Date.now() - requestStartedAt}`);
-							startStream();
+						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint),
+						canRetryStream: () => output.content.length === 0,
+						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
+							if (continuationClaim) continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
+							return withProviderResponseHook({
+								stream: observeResponsesStream(rawResponseStream, model, requestStartedAt),
+								signal: firstEvent.signal,
+								abort: firstEvent.abort,
+								hook: createOpenAIProviderAcceptanceHook(options, response, model),
+								onReady: () => {
+									emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} transport=sse elapsedMs=${Date.now() - requestStartedAt}`);
+									startStream();
+								}
+							});
 						}
 					});
+					return responseStream;
 				};
 				let responseStream;
 				let finishWebSocket;
@@ -3796,8 +2694,16 @@ function createResponsesTransportExecutor(config) {
 					transport = "websocket";
 					emitModelTransportDebug(log, `[responses] websocket_selected provider=${model.provider} api=${model.api} model=${model.id} mode=${websocketMode} reused=${websocket.reusedConnection} continuation=${websocket.continuationStatus === "continued"} continuationStatus=${websocket.continuationStatus} sessionIdHash=${redactIdentifier(options?.sessionId)} headersHash=${redactIdentifier(JSON.stringify(Object.entries(websocketHeaders ?? {}).toSorted(([a], [b]) => a.localeCompare(b))))}`);
 					responseStream = { async *[Symbol.asyncIterator]() {
+						let providerAccepted = false;
 						try {
 							for await (const event of websocket.stream) {
+								if (!providerAccepted) {
+									providerAccepted = true;
+									await notifyProviderStreamOpened({
+										options,
+										cancelStream: () => websocket.finish({ keep: false })
+									});
+								}
 								startStream();
 								yield event;
 							}
@@ -3848,33 +2754,30 @@ function createResponsesTransportExecutor(config) {
 					throw error;
 				}
 				emitModelTransportDebug(log, `[responses] completed provider=${model.provider} api=${model.api} model=${model.id} transport=${transport} elapsedMs=${Date.now() - requestStartedAt}`);
-				stream.push({
-					type: "done",
-					reason: output.stopReason,
-					message: output
+				finalizeTransportStream({
+					stream,
+					output,
+					signal: options?.signal
 				});
-				stream.end();
 			} catch (error) {
 				if (compactRequest) {
 					compactRequest.reject(error);
-					Object.assign(output, projectProviderError(error, options?.signal));
-					stream.push({
-						type: "error",
-						reason: output.stopReason,
-						error: output
+					failTransportStream({
+						stream,
+						output,
+						signal: options?.signal,
+						error
 					});
-					stream.end();
 					return;
 				}
 				if (error instanceof ResponsesStreamFailure && error.observation) logResponsesFailedNoDetails(error.observation);
 				log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error));
-				Object.assign(output, projectProviderError(error, options?.signal));
-				stream.push({
-					type: "error",
-					reason: output.stopReason,
-					error: output
+				failTransportStream({
+					stream,
+					output,
+					signal: options?.signal,
+					error
 				});
-				stream.end();
 			} finally {
 				continuationClaim?.release();
 				firstEventAbort?.dispose();
@@ -3905,23 +2808,20 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		createResponseStream: createResponsesStreamWithEncryptedContentRetry
 	});
 }
-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);
+function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders, _sessionId, fetchOverride) {
+	const baseURL = model.baseUrl.replace(/\/+$/, "");
 	const clientOptions = {
 		apiKey,
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
 		baseURL,
-		fetch: buildGuardedModelFetch(model),
+		fetch: fetchOverride ?? buildGuardedModelFetch(model),
 		...buildOpenAISdkClientOptions(model)
 	};
 	if (isOpenAICompatibleAzureResponsesBaseUrl(baseURL)) return new OpenAI(clientOptions);
@@ -3967,10 +2867,116 @@ const responsesTesting = {
 if (process.env.VITEST || false) globalThis.openclawOpenAIResponsesTransportTestApi = responsesTesting;
 //#endregion
 //#region packages/ai/src/transports/provider-compaction-replay.ts
+function isAssistantReplayMessage(message) {
+	return message.role === "assistant";
+}
+/** Resolve from prepared transport facts; never retain or return credential material. */
+function resolveCompactionReplayEligibility(model, options) {
+	if (OPENAI_RESPONSES_APIS.has(model.api)) return true;
+	return Boolean(options.apiKey?.trim()) && resolveAnthropicServerCompactionPlan(model, options.extraParams, options.apiKey).enabled;
+}
+function resolveCompactionSource(messages, model, identity) {
+	if (identity.enabled === false) return;
+	const assistants = messages.filter(isAssistantReplayMessage);
+	const selected = (() => {
+		if (OPENAI_RESPONSES_APIS.has(model.api)) {
+			const responses = resolveNewestOpenAIResponsesCompactionReplay(assistants, model, identity);
+			return responses ? {
+				family: "responses",
+				...responses
+			} : void 0;
+		}
+		if (identity.enabled !== true) return;
+		const anthropic = resolveNewestAnthropicCompaction(assistants, model, identity);
+		return anthropic ? {
+			family: "anthropic",
+			...anthropic
+		} : void 0;
+	})();
+	if (!selected) return;
+	const owner = assistants.find((message) => message === selected.owner);
+	return owner ? {
+		...selected,
+		owner
+	} : void 0;
+}
+/** Manual recovery uses the durable client compactor, never a guessed retained-user prefix. */
+function requiresCompactionReplayRefresh(messages, model, identity) {
+	const checkpoint = resolveCompactionSource(messages, model, identity);
+	return checkpoint?.family === "responses" && checkpoint.mode === "refresh-required";
+}
+/** Carry a checkpoint immediately after reference-preserving history limiting, before repair. */
+function preserveCompactionReplayWindow(source, windowed, model, identity) {
+	const checkpoint = resolveCompactionSource(source, model, identity);
+	if (!checkpoint || windowed.some((message) => message === checkpoint.owner)) return windowed;
+	const owner = checkpoint.owner;
+	const replay = checkpoint.owner.providerReplay;
+	const providerReplay = replay?.type === "openai-responses-retained-compaction" ? replay : {
+		...replay,
+		replayIndex: 0
+	};
+	const suffix = new Set(source.slice(source.indexOf(owner) + 1));
+	return [{
+		...owner,
+		content: [],
+		providerReplay
+	}, ...windowed.filter((message) => suffix.has(message))];
+}
+function estimateResponsesWindow(checkpoint, estimate) {
+	return checkpoint.output.reduce((tokens, entry) => {
+		if (entry.type === "compaction") {
+			const { encrypted_content, ...metadata } = entry;
+			return tokens + estimate.text(encrypted_content) + estimate.json(metadata);
+		}
+		const { content, ...metadata } = entry;
+		return tokens + estimate.json(metadata) + content.reduce((sum, block) => {
+			if (block.type === "input_text") {
+				const { text, ...fields } = block;
+				return sum + estimate.text(text) + estimate.json(fields);
+			}
+			if (block.type === "input_image") {
+				const { image_url: _imageUrl, ...fields } = block;
+				return sum + estimate.image() + estimate.json(block.image_url?.startsWith("data:") ? fields : block);
+			}
+			return sum + estimate.json(block);
+		}, 0);
+	}, 0);
+}
+/** Estimate the canonical prefix and its tail once, independent of unbound usage snapshots. */
+function resolveCompactionReplayPressure(messages, model, identity, estimate) {
+	const checkpoint = resolveCompactionSource(messages, model, identity);
+	if (!checkpoint) return;
+	if (checkpoint.family === "responses" && checkpoint.mode === "refresh-required") throw new CompactionReplayRefreshRequiredError();
+	const ownerIndex = messages.findIndex((message) => message === checkpoint.owner);
+	const owner = messages[ownerIndex];
+	if (!owner) return;
+	const prefixTokens = checkpoint.family === "anthropic" ? estimate.text(checkpoint.summary) : checkpoint.mode === "complete-window" ? estimateResponsesWindow(checkpoint, estimate) : estimate.text(checkpoint.item.encrypted_content);
+	const { contextUsage: _staleContextUsage, ...usage } = checkpoint.owner.usage;
+	const tail = [];
+	for (const message of messages.slice(ownerIndex + 1)) {
+		if (!isAssistantReplayMessage(message) || message.usage.contextUsage === void 0) {
+			tail.push(message);
+			continue;
+		}
+		const { contextUsage: _unboundContextUsage, ...billedUsage } = message.usage;
+		tail.push({
+			...message,
+			usage: billedUsage
+		});
+	}
+	return {
+		messages: [{
+			...owner,
+			content: checkpoint.owner.content.slice(checkpoint.replayIndex),
+			usage
+		}, ...tail],
+		prefixTokens
+	};
+}
 /** Whether provider replay state is a prefix-bound server compaction checkpoint. */
 function isCompactionReplayCheckpoint(replay) {
 	const type = replay && typeof replay === "object" ? replay.type : void 0;
-	return type === "anthropic-compaction" || type === "openai-responses-compaction";
+	return type === "anthropic-compaction" || type === "openai-responses-compaction" || type === "openai-responses-retained-compaction";
 }
 /** Strip prefix-bound checkpoints after local history rewrites. */
 function stripCompactionReplayCheckpoint(message) {
@@ -3991,8 +2997,9 @@ function replaceCompactionReplayOwnerContent(message, content) {
 	};
 	const replay = message.providerReplay;
 	if (!isCompactionReplayCheckpoint(replay)) return next;
+	if (replay.type === "openai-responses-retained-compaction") return next;
 	const replayIndex = replay.replayIndex ?? 0;
-	if (content.length === 0 || replayIndex > message.content.length) return stripCompactionReplayCheckpoint(next);
+	if (content.length === 0 && message.content.length > 0 || replayIndex > message.content.length) return stripCompactionReplayCheckpoint(next);
 	let sourceIndex = 0;
 	let nextReplayIndex = 0;
 	if (!content.every((block) => {
@@ -4261,4 +3268,4 @@ function prepareModelForSimpleCompletion(params) {
 	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
 }
 //#endregion
-export { GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, applyAnthropicCacheControlToMessages, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderResponseHook };
+export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicCacheControlToMessages, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };