@openclaw/ai 2026.9.5 → 2026.9.7

package/dist/transports.mjs

@@ -1,54 +1,40 @@
-import { _ as supportsClaudeAdaptiveThinking, h as resolveClaudeSonnet5ModelIdentity, m as resolveClaudeOpus5ModelIdentity } from "./src-DeKjbE8I.mjs";
+import { S as supportsClaudeAdaptiveThinking, b as resolveClaudeSonnet5ModelIdentity, v as resolveClaudeOpus5ModelIdentity, y as resolveClaudeSonnet55ModelIdentity } from "./src-H4aXcFuX.mjs";
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
+import { _ as requiresClaudeAdaptiveThinking, b as usesClaudeFable5MessagesContract, f as applyClaudeRequestContract, g as prepareClaudeNoPrefillRequestContext, m as defaultsClaudeAdaptiveThinking, n as getAiTransportHost, p as buildAnthropicClaudeCodeIdentity, r as resolveAiTransportHeaderSentinels, v as resolveAnthropicThinkingEffort, x as usesClaudeStreamingRefusalContract } from "./host-CHi3X87F.mjs";
 import { n as normalizeLowercaseStringOrEmpty, t as hasNonEmptyString } from "./string-coerce-fsri9iCu.mjs";
-import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { E as resolveAnthropicThinkingEffort, O as usesClaudeFable5MessagesContract, S as defaultsClaudeAdaptiveThinking, T as requiresClaudeAdaptiveThinking, b as ANTHROPIC_CLAUDE_CODE_VERSION, k as usesClaudeStreamingRefusalContract, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels, w as prepareClaudeNoPrefillRequestContext, x as applyClaudeRequestContract } from "./host-B4MeUNBc.mjs";
-import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { a as redactDiagnosticText, o as stableStringify } from "./provider-error-DDqw9Qda.mjs";
-import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, m as toErrorObject, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./diagnostics-Dm4bisWG.mjs";
-import { a as readResponseTextSnippet, i as isCodeModeModelVisibleToolName, n as createAbortError$1, s as resolveModelHeaderSentinels, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-1cyq5Y7x.mjs";
-import { a as resolveOpenAIPromptCacheKeySupport, i as resolveOpenAICompletionsCompat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-CkwdxTZx.mjs";
-import { i as resolveProviderEndpoint, s as transformTransportMessages, t as buildGuardedModelFetch } from "./host-policy-DUnXSx0I.mjs";
-import { B as logAnthropicContextEdits, C as applyAnthropicThinkingBindingControls, D as ANTHROPIC_SERVER_SIDE_FALLBACKS, F as applyAnthropicPayloadPolicyToParams, G as resolveAnthropicServerCompactionPlan, H as resolveAnthropicContextManagementBetaHeader, I as applyAnthropicRequestCacheControl, J as usesFoundryBearerAuth, K as isAnthropicOAuthApiKey, L as buildAnthropicSystemBlocks, N as applyAnthropicContextManagementToRequest, O as ANTHROPIC_SERVER_SIDE_FALLBACK_BETA, P as applyAnthropicEphemeralCacheControlMarkers, R as isAnthropicServerToolClearingEnabled, U as resolveAnthropicEphemeralCacheControl, V as resolveAnthropicCacheOptions, W as resolveAnthropicPayloadPolicy, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, l as buildAnthropicGenerationParams, m as resolveNewestAnthropicCompaction, p as isAnthropicReplayRejection, q as omitFoundryBearerCredentialHeaders, t as consumeAnthropicStream, u as convertAnthropicMessages, z as isDirectAnthropicModel } from "./anthropic-stream-reducer-BvdYYWL8.mjs";
+import { a as redactDiagnosticText, o as truncateUtf16Safe, s as stableStringify } from "./provider-error-CwT_j2v0.mjs";
+import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl, u as hasOnlyResponsesFunctionTools, v as toErrorObject } from "./diagnostics-CJaB6g8J.mjs";
+import { a as readResponseTextSnippet, i as isCodeModeModelVisibleToolName, n as createAbortError$1, s as resolveModelHeaderSentinels, t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-C-4bf2Ok.mjs";
+import { a as resolveOpenAIPromptCacheKeySupport, i as resolveOpenAICompletionsCompat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-BOVWBZDn.mjs";
+import { r as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-BOAwRg_M.mjs";
+import { A as applyAnthropicRequestCacheControl, B as ANTHROPIC_SERVER_SIDE_FALLBACKS, C as applyAnthropicThinkingBindingControls, D as applyAnthropicContextManagementToRequest, F as resolveAnthropicCacheOptions, I as resolveAnthropicEphemeralCacheControl, J as usesFoundryBearerAuth, K as isAnthropicOAuthApiKey, L as resolveAnthropicPayloadPolicy, M as isAnthropicServerToolClearingEnabled, N as isDirectAnthropicModel, O as applyAnthropicEphemeralCacheControlMarkers, P as logAnthropicContextEdits, R as resolveAnthropicRequestBetaHeader, d as convertAnthropicTools, f as buildAnthropicReplayPlan, g as normalizeAnthropicToolCallId, h as suppressAnthropicCompaction, j as buildAnthropicSystemBlocks, k as applyAnthropicPayloadPolicyToParams, l as buildAnthropicGenerationParams, m as resolveNewestAnthropicCompaction, p as isAnthropicReplayRejection, q as omitFoundryBearerCredentialHeaders, t as consumeAnthropicStream, u as convertAnthropicMessages, z as resolveAnthropicServerCompactionPlan } from "./anthropic-stream-reducer-D9MCkl8Z.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { a as codeModeToolSurfaceObserver, o as reasoningTagTextPolicy, t as adjustMaxTokensForThinking, v as sortPromptCacheToolsByName } from "./simple-options-C6cFWj_f.mjs";
-import { A as resolvePromptCacheKey, C as isOpenAICompletionsThinkingEnabled, D as readOpenAICompletionsContentDeltas, E as parseOpenAICompletionsUsage, M as redactIdentifier, N as sha256Hex, O as readOpenAICompletionsReasoningBatch, S as createResponseModelTracker, T as measureUtf8AppendBytes, _ as resolveOpenAIReasoningEffortMap, a as enforceCodeModeResponsesToolSurface, b as createOpenAIProviderAcceptanceHook, c as readCodeModePayloadToolName, i as buildOpenAISdkRequestOptions, j as throwIfModelStreamAborted, k as resolveOpenAIClientBaseUrl, l as resolveCodeModeResponsesVisibleToolNames, n as buildOpenAIClientHeaders, o as filterCodeModePayloadTools, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as log, x as createOpenAIResponseHook, y as createModelStreamCooperativeScheduler } from "./openai-transport-params-DQeuAvBl.mjs";
-import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { C as quoteUnsafeIntegerLiterals, S as parseJsonPreservingUnsafeIntegers, _ as sanitizeTransportPayloadText, a as createEmptyTransportUsage, b as withProviderResponseHook, c as finalizeTerminalToolCallArguments, d as mergeTransportMetadata, f as notifyProviderHttpMetadata, g as sanitizeNonEmptyTransportPayloadText, h as parseTerminalToolCallArguments, i as copyProviderAcceptanceObserver, l as finalizeTransportStream, m as notifyProviderStreamOpened, n as assignTransportErrorDetails, o as createWritableTransportEventStream, p as notifyProviderHttpResponse, r as coerceTransportToolCallArguments, s as failTransportStream, t as IncompleteToolCallError, u as mergeTransportHeaders, v as transportAbortError, x as parseJsonObjectPreservingUnsafeIntegers, y as withProviderAcceptanceObserver } from "./transport-stream-shared-D-6FQSHm.mjs";
+import { C as parseJsonObjectPreservingUnsafeIntegers, S as withProviderResponseHook, T as quoteUnsafeIntegerLiterals, _ as sanitizeNonEmptyTransportPayloadText, a as createEmptyTransportUsage, b as transportAbortError, c as failTransportStream, d as iterateModelStream, f as mergeTransportHeaders, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, i as copyProviderAcceptanceObserver, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as assignTransportErrorDetails, o as createModelStreamCooperativeScheduler, p as notifyProviderHttpMetadata, r as coerceTransportToolCallArguments, s as createWritableTransportEventStream, t as IncompleteToolCallError, u as finalizeTransportStream, v as sanitizeTransportPayloadText, w as parseJsonPreservingUnsafeIntegers, x as withProviderAcceptanceObserver, y as throwIfModelStreamAborted } from "./transport-stream-shared-Dh5qKJ8e.mjs";
+import { D as sortPromptCacheToolsByName, l as codeModeToolSurfaceObserver, s as prepareModelRequestBody, t as adjustMaxTokensForThinking, u as reasoningTagTextPolicy } from "./simple-options-CGAkCwtM.mjs";
+import { A as redactIdentifier, C as log, D as readOpenAICompletionsReasoningBatch, E as readOpenAICompletionsContentDeltas, O as resolveOpenAIClientBaseUrl, S as isOpenAICompletionsThinkingEnabled, T as parseOpenAICompletionsUsage, _ as resolveOpenAIReasoningEffortMap, a as enforceCodeModeResponsesToolSurface, b as createOpenAIResponseHook, c as readCodeModePayloadToolName, i as buildOpenAISdkRequestOptions, j as sha256Hex, k as resolvePromptCacheKey, l as resolveCodeModeResponsesVisibleToolNames, n as buildOpenAIClientHeaders, o as filterCodeModePayloadTools, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as measureUtf8AppendBytes, x as createResponseModelTracker, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-BwlpzX-2.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
 import { t as createDeferredEventBuffer } from "./deferred-event-buffer-DAvyP7qA.mjs";
-import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CnUSOwhr.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-DsyI5jOP.mjs";
 import { a as tagUnresolvedTextAsCommentary } from "./assistant-text-phase-C20rxWwP.mjs";
-import { t as createAssistantOutput } from "./assistant-output-BsEkB-vU.mjs";
+import { n as createAssistantOutput } from "./provider-transcript-transform-JbFbHV8h.mjs";
 import { n as resolveOpencodeSessionHeaders } from "./session-affinity-Bcunsn4I.mjs";
-import { c as flattenCompletionMessagesToStringContent, d as canonicalizeMaxTokensParam, f as resolveMaxTokensParam, l as stripCompletionMessagesToRoleContent, n as shouldEmitOpenAICompletionsReasoning, o as isAzureOpenAICompatibleHost, p as createDeepSeekTextFilter, r as buildOpenAICompletionsParams, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream, u as applyCompletionsAnthropicCacheControl } from "./openai-completions-stream-Bu98b0Hv.mjs";
-import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-CyWnYlh0.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C9ZadkJW.mjs";
-import { d as OpenAIResponsesWebSocketSafeRetryError, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError } from "./openai-responses-contracts-DWrfMODE.mjs";
-import { r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-CkGToCD2.mjs";
-import { a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, i as sanitizeResponsesImagePayload, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch } from "./openai-responses-compaction-window-D6P5oZP5.mjs";
-import { A as resolveNextResponsesEncryptedContentAttempt, B as responsesContinuationPrefixFingerprint, D as createResponsesStreamWithEncryptedContentRetry, F as createOpenAIResponsesAssistantOutput, G as CompactionReplayRefreshRequiredError, H as isConfigurationUpdate, I as recordResponsesInputReplay, J as isOpenAIResponsesReplayContext, K as buildOpenAIResponsesReasoningReplayMetadata, L as responsesInputFingerprint, M as resolveResponsesContextUsageBoundary, O as isInvalidEncryptedContentError, R as claimOpenAIResponsesHttpContinuation, U as replayResponsesReasoningUpdates, V as responsesContinuationRequestFingerprint, W as supportsResponsesReasoningUpdate, X as suppressOpenAIResponsesCompaction, Y as resolveNewestOpenAIResponsesCompactionReplay, Z as resolveReplayableResponsesMessageId, c as processResponsesStream, d as logResponsesFailedNoDetails, f as safeDebugValue, j as recordResponsesContextUsage, k as resolveAzureOpenAIApiVersion, l as observeResponsesStream, m as summarizeResponsesPayload, n as applyResponsesServiceTierPricing, p as summarizeOpenAITransportError, q as captureOpenAIResponsesCompaction, u as ResponsesStreamFailure, z as resolveResponsesContinuationRequest } from "./openai-responses-shared-CwsziD_m.mjs";
+import { c as flattenCompletionMessagesToStringContent, d as canonicalizeMaxTokensParam, f as resolveMaxTokensParam, l as stripCompletionMessagesToRoleContent, n as shouldEmitOpenAICompletionsReasoning, o as isAzureOpenAICompatibleHost, p as createDeepSeekTextFilter, r as buildOpenAICompletionsParams, s as finalizeOpenAICompletionsToolCalls, t as processCompletionsStream, u as applyCompletionsAnthropicCacheControl } from "./openai-completions-stream-CDCuw3DP.mjs";
+import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-CtjVtVot.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-B9o0S4SZ.mjs";
+import { d as OpenAIResponsesWebSocketSafeRetryError, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError } from "./openai-responses-contracts-CLxnqS9p.mjs";
+import { r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-BheUi_hl.mjs";
+import { a as applyOpenAIResponsesPayloadPolicy, c as resolveOpenAIResponsesServerCompactionPlan, i as sanitizeResponsesImagePayload, n as isOpenAIResponsesCompactionOutput, o as resolveOpenAIResponsesCompactEndpointPlan, s as resolveOpenAIResponsesPayloadPolicy, t as createBoundedOpenAIResponsesCompactionFetch } from "./openai-responses-compaction-window-UNK1GDpy.mjs";
+import { $ as OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE, A as recordResponsesContextUsage, B as resolveResponsesContinuationRequest, C as resolveAzureOpenAIApiVersion, D as safeDebugValue, E as logResponsesFailedNoDetails, G as supportsResponsesReasoningUpdate, H as responsesContinuationRequestFingerprint, I as recordResponsesInputReplay, J as captureOpenAIResponsesCompaction, K as CompactionReplayRefreshRequiredError, L as responsesInputFingerprint, O as summarizeOpenAITransportError, Q as OPENAI_RESPONSES_CALL_ID_RE, R as claimOpenAIResponsesHttpContinuation, S as isInvalidEncryptedContentError, T as ResponsesStreamFailure, U as isConfigurationUpdate, V as responsesContinuationPrefixFingerprint, W as replayResponsesReasoningUpdates, X as resolveNewestOpenAIResponsesCompactionReplay, Y as isOpenAIResponsesReplayContext, Z as suppressOpenAIResponsesCompaction, c as observeResponsesStream, et as OPENAI_RESPONSES_ID_MAX_LENGTH, it as resolveReplayableResponsesMessageId, j as resolveResponsesContextUsageBoundary, k as summarizeResponsesPayload, n as applyResponsesServiceTierPricing, nt as shouldNormalizeOpenAIResponsesToolCallId, q as buildOpenAIResponsesReasoningReplayMetadata, rt as splitOpenAIFunctionCallPairing, s as processResponsesStream, tt as normalizeOpenAIResponsesFunctionCallId, w as resolveNextResponsesEncryptedContentAttempt, x as createResponsesStreamWithEncryptedContentRetry, z as recordResponsesContinuationState } from "./openai-responses-shared-DL4ulQn7.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 { a as sanitizeOpenAICodexResponsesParams, n as buildOpenAIResponsesCompactSystemMessage, r as buildOpenAIResponsesParams, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-C15_-OwV.mjs";
+import { a as sanitizeOpenAICodexResponsesParams, n as buildOpenAIResponsesCompactSystemMessage, r as buildOpenAIResponsesParams, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-iAqLb4tk.mjs";
+import { n as withResponsesRequestAcceptance, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-Fsag-IGZ.mjs";
 import { randomUUID } from "node:crypto";
 import OpenAI, { AzureOpenAI } from "openai";
 import { ResponsesWS } from "openai/resources/responses/ws.js";
-//#region packages/ai/src/transports/anthropic-transport-stream.ts
-/**
-* Native Anthropic Messages streaming transport.
-* Converts OpenClaw contexts/tools into Anthropic payloads, streams SSE events
-* back into runtime output blocks, and applies provider request policy.
-*/
-const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES = 8192;
-const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS = 400;
-const ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS = 1e4;
+//#region packages/ai/src/transports/anthropic-transport-options.ts
 const ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS = 4096;
 const ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR = 4;
-const ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS = 16777216;
-function resolveAnthropicRequestModelId(model) {
-	if (isDirectAnthropicModel(model) && /^anthropic\//i.test(model.id)) return model.id.replace(/^anthropic\//i, "");
-	return model.id;
-}
-const EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT = ".";
 function resolvePositiveAnthropicTokenLimit(value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return;
 	const floored = Math.floor(value);
@@ -63,6 +49,72 @@ 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 resolveAnthropicTransportOptions(model, options, apiKey) {
+	const baseMaxTokens = resolveAnthropicMessagesMaxTokens({
+		modelContextWindow: model.contextWindow,
+		modelMaxTokens: model.maxTokens,
+		requestedMaxTokens: options?.maxTokens,
+		useModelDefault: resolveClaudeSonnet5ModelIdentity(model) !== void 0 || resolveClaudeOpus5ModelIdentity(model) !== void 0
+	});
+	if (baseMaxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
+	const reasoningModelMaxTokens = resolvePositiveAnthropicTokenLimit(model.maxTokens) ?? baseMaxTokens;
+	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
+	const reasoning = options?.reasoning === "off" && mandatoryAdaptiveThinking ? "low" : options?.reasoning;
+	const resolved = copyProviderAcceptanceObserver(options, {
+		temperature: options?.temperature,
+		stop: options?.stop,
+		maxTokens: baseMaxTokens,
+		signal: options?.signal,
+		apiKey,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata,
+		interleavedThinking: options?.interleavedThinking,
+		toolChoice: options?.toolChoice,
+		thinkingBudgets: options?.thinkingBudgets,
+		thinkingDisplay: options?.thinkingDisplay,
+		reasoning,
+		anthropicServerCompaction: options?.anthropicServerCompaction,
+		anthropicCompactThreshold: options?.anthropicCompactThreshold,
+		cacheTtlPruning: options?.cacheTtlPruning,
+		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
+	});
+	if (reasoning === "off") {
+		resolved.thinkingEnabled = false;
+		return resolved;
+	}
+	if (!reasoning) {
+		resolved.thinkingEnabled = defaultsClaudeAdaptiveThinking(model);
+		if (resolved.thinkingEnabled) resolved.effort = resolveAnthropicThinkingEffort(model, reasoning);
+		return resolved;
+	}
+	if (supportsClaudeAdaptiveThinking(model)) {
+		resolved.thinkingEnabled = true;
+		resolved.effort = resolveAnthropicThinkingEffort(model, reasoning);
+		return resolved;
+	}
+	const adjusted = adjustMaxTokensForThinking(baseMaxTokens, reasoningModelMaxTokens, reasoning === "max" ? "high" : reasoning, options?.thinkingBudgets);
+	const thinkingEnabled = adjusted.thinkingBudget >= 1024;
+	resolved.maxTokens = adjusted.maxTokens;
+	resolved.thinkingEnabled = thinkingEnabled;
+	resolved.thinkingBudgetTokens = thinkingEnabled ? adjusted.thinkingBudget : void 0;
+	return resolved;
+}
+//#endregion
+//#region packages/ai/src/transports/anthropic-transport-stream.ts
+const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_BYTES = 8192;
+const ANTHROPIC_MESSAGES_ERROR_BODY_MAX_CHARS = 400;
+const ANTHROPIC_MESSAGES_ERROR_BODY_READ_IDLE_TIMEOUT_MS = 1e4;
+const ANTHROPIC_MESSAGES_SSE_PENDING_BUFFER_MAX_CHARS = 16777216;
+function resolveAnthropicRequestModelId(model) {
+	if (isDirectAnthropicModel(model) && /^anthropic\//i.test(model.id)) return model.id.replace(/^anthropic\//i, "");
+	return model.id;
+}
+const EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT = ".";
 function isKimiAnthropicProvider(provider) {
 	return /^kimi(?:-|$)/.test(normalizeLowercaseStringOrEmpty(provider ?? ""));
 }
@@ -72,7 +124,7 @@ function isKimiAnthropicProvider(provider) {
 * identity) requests are excluded until the beta is verified there.
 */
 function useAnthropicServerSideFallback(model) {
-	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
+	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0 || resolveClaudeSonnet55ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
 }
 function supportsReasoningContentReplay(model) {
 	return resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
@@ -154,31 +206,27 @@ async function* parseAnthropicSseBody(body, signal) {
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let completed = false;
+	const delimiter = /(?:\r\n|\r(?!\n)|\n)(?:\r\n|\r(?!\n)|\n)/g;
+	let scanOffset = 0;
 	try {
-		while (true) {
+		while (!completed) {
 			const { done, value } = await readAnthropicSseChunk(reader, signal);
-			if (done) {
-				completed = true;
-				break;
-			}
-			buffer = `${buffer}${decoder.decode(value, { stream: true })}`.replaceAll("\r\n", "\n");
-			let frameEnd = buffer.indexOf("\n\n");
-			while (frameEnd >= 0) {
+			completed = done;
+			buffer += decoder.decode(value, { stream: !done });
+			delimiter.lastIndex = scanOffset;
+			for (;;) {
+				const boundary = delimiter.exec(buffer);
+				if (!boundary && (!completed || !buffer)) break;
+				const frameEnd = boundary?.index ?? buffer.length;
 				assertAnthropicSsePendingBufferWithinLimit(frameEnd);
-				const frame = buffer.slice(0, frameEnd);
-				buffer = buffer.slice(frameEnd + 2);
-				const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+				const frame = boundary ? buffer.slice(0, frameEnd) : buffer.trim();
+				buffer = boundary ? buffer.slice(frameEnd + boundary[0].length) : "";
+				delimiter.lastIndex = 0;
+				const data = frame.split(/\r\n|\n|\r/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
 				if (data && data !== "[DONE]") yield parseAnthropicSseEventData(data);
-				frameEnd = buffer.indexOf("\n\n");
 			}
 			assertAnthropicSsePendingBufferWithinLimit(buffer.length);
-		}
-		const tailBuffer = `${buffer}${decoder.decode()}`.replaceAll("\r\n", "\n");
-		assertAnthropicSsePendingBufferWithinLimit(tailBuffer.length);
-		const tail = tailBuffer.trim();
-		if (tail) {
-			const data = tail.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
-			if (data && data !== "[DONE]") yield parseAnthropicSseEventData(data);
+			scanOffset = Math.max(0, buffer.length - 3);
 		}
 	} finally {
 		if (!completed) {
@@ -189,9 +237,9 @@ async function* parseAnthropicSseBody(body, signal) {
 		reader.releaseLock();
 	}
 }
-function createAnthropicMessagesClient(params) {
+function createAnthropicMessageRequest(params) {
 	const url = resolveAnthropicMessagesUrl(params.baseURL);
-	return { messages: { async stream(body, options) {
+	return async (body, options) => {
 		const headers = new Headers(mergeTransportHeaders({
 			"content-type": "application/json",
 			"anthropic-version": "2023-06-01",
@@ -209,7 +257,7 @@ function createAnthropicMessagesClient(params) {
 			response,
 			stream: response.body ? parseAnthropicSseBody(response.body, options?.signal) : []
 		};
-	} } };
+	};
 }
 async function readAnthropicMessagesErrorBody(response) {
 	try {
@@ -235,27 +283,11 @@ function createAnthropicTransportClient(params) {
 	const optionHeaders = resolveOpencodeSessionHeaders(model, options);
 	const needsInterleavedBeta = (options?.interleavedThinking ?? true) && !supportsClaudeAdaptiveThinking(model);
 	const fetch = isKimiAnthropicProvider(model.provider) && options?.thinkingEnabled === true ? buildGuardedModelFetch(model, void 0, { sanitizeSse: false }) : buildGuardedModelFetch(model);
-	if (model.provider === "github-copilot") {
-		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
-		return {
-			client: createAnthropicMessagesClient({
-				apiKey: null,
-				authToken: apiKey,
-				baseURL: model.baseUrl,
-				defaultHeaders: mergeTransportHeaders({
-					accept: "application/json",
-					"anthropic-dangerous-direct-browser-access": "true",
-					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
-				}, model.headers, getAiTransportHost().buildCopilotDynamicHeaders(context.messages), optionHeaders),
-				fetch
-			}),
-			isOAuthToken: false
-		};
-	}
-	if (usesFoundryBearerAuth(resolveModelHeaderSentinels(model))) {
+	const copilot = model.provider === "github-copilot";
+	if (copilot || usesFoundryBearerAuth(resolveModelHeaderSentinels(model))) {
 		const betaFeatures = needsInterleavedBeta ? ["interleaved-thinking-2025-05-14"] : [];
 		return {
-			client: createAnthropicMessagesClient({
+			request: createAnthropicMessageRequest({
 				apiKey: null,
 				authToken: apiKey,
 				baseURL: model.baseUrl,
@@ -263,7 +295,7 @@ function createAnthropicTransportClient(params) {
 					accept: "application/json",
 					"anthropic-dangerous-direct-browser-access": "true",
 					...betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}
-				}, omitFoundryBearerCredentialHeaders(model.headers), optionHeaders),
+				}, copilot ? model.headers : omitFoundryBearerCredentialHeaders(model.headers), copilot ? getAiTransportHost().buildCopilotDynamicHeaders(context.messages) : void 0, optionHeaders),
 				fetch
 			}),
 			isOAuthToken: false
@@ -273,32 +305,28 @@ function createAnthropicTransportClient(params) {
 	if (needsInterleavedBeta) betaFeatures.push("interleaved-thinking-2025-05-14");
 	if (isAnthropicOAuthApiKey(apiKey)) {
 		const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: true });
+		const identity = buildAnthropicClaudeCodeIdentity(betaHeader, model.headers, optionHeaders);
 		return {
-			client: createAnthropicMessagesClient({
+			request: createAnthropicMessageRequest({
 				apiKey: null,
 				authToken: apiKey,
 				baseURL: model.baseUrl,
-				defaultHeaders: mergeTransportHeaders({
-					accept: "application/json",
-					"anthropic-dangerous-direct-browser-access": "true",
-					...betaHeader ? { "anthropic-beta": betaHeader } : {},
-					"user-agent": `claude-cli/${ANTHROPIC_CLAUDE_CODE_VERSION}`,
-					"x-app": "cli"
-				}, model.headers, optionHeaders),
+				defaultHeaders: identity.headers,
 				fetch
 			}),
-			isOAuthToken: true
+			isOAuthToken: true,
+			claudeCodeVersion: identity.version
 		};
 	}
-	if (useAnthropicServerSideFallback(model)) betaFeatures.push(ANTHROPIC_SERVER_SIDE_FALLBACK_BETA);
 	const betaHeader = buildAnthropicBetaHeader(model, betaFeatures, { oauth: false });
 	const defaultHeaders = mergeTransportHeaders({
 		accept: "application/json",
 		"anthropic-dangerous-direct-browser-access": "true",
-		...betaHeader ? { "anthropic-beta": betaHeader } : {}
+		...betaHeader ? { "anthropic-beta": betaHeader } : {},
+		...options?.sessionId && options.cacheRetention !== "none" && model.compat?.sendSessionAffinityHeaders === true ? { "x-session-affinity": options.sessionId } : {}
 	}, model.headers, optionHeaders);
 	return {
-		client: createAnthropicMessagesClient({
+		request: createAnthropicMessageRequest({
 			apiKey,
 			baseURL: model.baseUrl,
 			defaultHeaders,
@@ -308,7 +336,7 @@ function createAnthropicTransportClient(params) {
 		directApiKeyBetaHeader: isDirectAnthropicModel(model) ? new Headers(defaultHeaders).get("anthropic-beta") ?? "" : void 0
 	};
 }
-async function buildAnthropicParams(model, context, isOAuthToken, options) {
+async function buildAnthropicParams(model, context, isOAuthToken, options, claudeCodeVersion) {
 	const replayThinkingEnabled = requiresClaudeAdaptiveThinking(model) || options?.thinkingEnabled === true;
 	const maxTokens = resolveAnthropicMessagesMaxTokens({
 		modelContextWindow: model.contextWindow,
@@ -323,7 +351,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		sessionId: options?.sessionId
 	});
 	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
-	const messages = await convertAnthropicMessages(transformTransportMessages(replayPlan.messages, model, normalizeAnthropicToolCallId), model, isOAuthToken, {
+	const messages = await convertAnthropicMessages(getAiTransportHost().transformTransportMessages(replayPlan.messages, model, normalizeAnthropicToolCallId, void 0), model, isOAuthToken, {
 		profile: "transport",
 		allowReasoningContentReplay: supportsReasoningContentReplay(model),
 		allowEmptySignature: model.compat?.allowEmptySignature,
@@ -338,7 +366,7 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		stream: true
 	};
 	if (!isOAuthToken && useAnthropicServerSideFallback(model)) params.fallbacks = ANTHROPIC_SERVER_SIDE_FALLBACKS;
-	const system = buildAnthropicSystemBlocks(context.systemPrompt, isOAuthToken, cacheControl);
+	const system = buildAnthropicSystemBlocks(context.systemPrompt, isOAuthToken, cacheControl, claudeCodeVersion);
 	if (system) params.system = system;
 	const convertedTools = context.tools ? convertAnthropicTools(context.tools, isOAuthToken) : void 0;
 	const toolProjection = convertedTools?.projection;
@@ -356,60 +384,6 @@ async function buildAnthropicParams(model, context, isOAuthToken, options) {
 		usedCompactionReplay: replayPlan.compaction !== void 0
 	};
 }
-function resolveAnthropicTransportOptions(model, options, apiKey) {
-	const baseMaxTokens = resolveAnthropicMessagesMaxTokens({
-		modelContextWindow: model.contextWindow,
-		modelMaxTokens: model.maxTokens,
-		requestedMaxTokens: options?.maxTokens,
-		useModelDefault: resolveClaudeSonnet5ModelIdentity(model) !== void 0 || resolveClaudeOpus5ModelIdentity(model) !== void 0
-	});
-	if (baseMaxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
-	const reasoningModelMaxTokens = resolvePositiveAnthropicTokenLimit(model.maxTokens) ?? baseMaxTokens;
-	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
-	const reasoning = options?.reasoning === "off" && mandatoryAdaptiveThinking ? "low" : options?.reasoning;
-	const resolved = copyProviderAcceptanceObserver(options, {
-		temperature: options?.temperature,
-		stop: options?.stop,
-		maxTokens: baseMaxTokens,
-		signal: options?.signal,
-		apiKey,
-		cacheRetention: options?.cacheRetention,
-		sessionId: options?.sessionId,
-		headers: options?.headers,
-		onPayload: options?.onPayload,
-		onResponse: options?.onResponse,
-		maxRetryDelayMs: options?.maxRetryDelayMs,
-		metadata: options?.metadata,
-		interleavedThinking: options?.interleavedThinking,
-		toolChoice: options?.toolChoice,
-		thinkingBudgets: options?.thinkingBudgets,
-		reasoning,
-		anthropicServerCompaction: options?.anthropicServerCompaction,
-		anthropicCompactThreshold: options?.anthropicCompactThreshold,
-		cacheTtlPruning: options?.cacheTtlPruning,
-		...options?.authProfileId ? { authProfileId: options.authProfileId } : {}
-	});
-	if (reasoning === "off") {
-		resolved.thinkingEnabled = false;
-		return resolved;
-	}
-	if (!reasoning) {
-		resolved.thinkingEnabled = defaultsClaudeAdaptiveThinking(model);
-		if (resolved.thinkingEnabled) resolved.effort = resolveAnthropicThinkingEffort(model, reasoning);
-		return resolved;
-	}
-	if (supportsClaudeAdaptiveThinking(model)) {
-		resolved.thinkingEnabled = true;
-		resolved.effort = resolveAnthropicThinkingEffort(model, reasoning);
-		return resolved;
-	}
-	const adjusted = adjustMaxTokensForThinking(baseMaxTokens, reasoningModelMaxTokens, reasoning === "max" ? "high" : reasoning, options?.thinkingBudgets);
-	const thinkingEnabled = adjusted.thinkingBudget >= 1024;
-	resolved.maxTokens = adjusted.maxTokens;
-	resolved.thinkingEnabled = thinkingEnabled;
-	resolved.thinkingBudgetTokens = thinkingEnabled ? adjusted.thinkingBudget : void 0;
-	return resolved;
-}
 /** Create the stream function used by Anthropic Messages transport models. */
 function createAnthropicMessagesTransportStreamFn() {
 	return (rawModel, context, rawOptions) => {
@@ -425,22 +399,22 @@ function createAnthropicMessagesTransportStreamFn() {
 				if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 				const transportOptions = resolveAnthropicTransportOptions(model, options, apiKey);
 				const requestContext = prepareClaudeNoPrefillRequestContext(model, context);
-				const { client, isOAuthToken, directApiKeyBetaHeader } = createAnthropicTransportClient({
+				const { request, isOAuthToken, directApiKeyBetaHeader, claudeCodeVersion } = createAnthropicTransportClient({
 					model,
 					context: requestContext,
 					apiKey,
 					options: transportOptions
 				});
-				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions);
+				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions, claudeCodeVersion);
 				usedCompactionReplay = builtParams.usedCompactionReplay;
 				let params = builtParams.params;
 				applyAnthropicContextManagementToRequest(params, model, transportOptions, directApiKeyBetaHeader);
 				const nextParams = await transportOptions.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				applyClaudeRequestContract(params, model);
-				const betaHeader = resolveAnthropicContextManagementBetaHeader(params, directApiKeyBetaHeader);
+				const betaHeader = resolveAnthropicRequestBetaHeader(params, directApiKeyBetaHeader);
 				const bindingHeaders = applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader ? { "anthropic-beta": betaHeader } : void 0);
-				const { response, stream: anthropicStream } = await client.messages.stream({
+				const { response, stream: anthropicStream } = await request({
 					...params,
 					stream: true
 				}, {
@@ -615,29 +589,7 @@ function createOpenAICompletionsTransportStreamFn() {
 	return (model, context, options) => {
 		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
-			const output = {
-				role: "assistant",
-				content: [],
-				api: model.api,
-				provider: model.provider,
-				model: model.id,
-				usage: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					totalTokens: 0,
-					cost: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						total: 0
-					}
-				},
-				stopReason: "stop",
-				timestamp: Date.now()
-			};
+			const output = createAssistantOutput(model);
 			let firstEventAbort;
 			try {
 				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
@@ -676,6 +628,7 @@ function createOpenAICompletionsTransportStreamFn() {
 					...optionHeaders
 				}, void 0, resolvePromptCacheKey(options, cacheRetention), cacheRetention), { fetch: doneDetectingFetch });
 				let params = buildOpenAICompletionsParams(model, context, options);
+				const encodeBody = prepareModelRequestBody(options);
 				const nextParams = await options?.onPayload?.(params, model);
 				if (nextParams !== void 0) params = nextParams;
 				if (options?.openclawCodeModeToolSurface === true) {
@@ -686,7 +639,10 @@ function createOpenAICompletionsTransportStreamFn() {
 				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
 				const emitReasoning = shouldEmitOpenAICompletionsReasoning(model, options);
 				firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-				const { data: responseStream, response } = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, firstEventAbort.signal, { timeoutMs: options?.timeoutMs })).withResponse();
+				const { data: responseStream, response } = await client.chat.completions.create(params, {
+					...buildOpenAISdkRequestOptions(model, firstEventAbort.signal, { timeoutMs: options?.timeoutMs }),
+					...await encodeBody(params)
+				}).withResponse();
 				const hookedResponseStream = withProviderResponseHook({
 					stream: responseStream,
 					signal: firstEventAbort.signal,
@@ -1024,10 +980,11 @@ function createOpenAIResponsesWebSocketStream(params) {
 		throw new OpenAIResponsesWebSocketPreDispatchError(error);
 	}
 	let prepared;
+	let previousContinuation;
 	const resumedSteering = lease.steeringContinuation;
 	const steeringMode = resumedSteering ? resumedSteering.requiresInput ? "required-input" : "automatic" : void 0;
 	try {
-		const continuation = lease.entry?.continuation;
+		const continuation = previousContinuation = lease.entry?.continuation;
 		if (continuation && lease.entry) {
 			lease.entry.continuation = void 0;
 			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
@@ -1093,11 +1050,7 @@ function createOpenAIResponsesWebSocketStream(params) {
 	const finish = ({ keep = true } = {}) => {
 		if (released) return;
 		released = true;
-		if (keep && lease.entry && terminalResponse) lease.entry.continuation = {
-			lastRequest: prepared.fullRequest ?? fullRequest,
-			lastResponseId: terminalResponse.id,
-			lastResponseItems: terminalResponse.output
-		};
+		if (keep && lease.entry && terminalResponse) lease.entry.continuation = recordResponsesContinuationState(previousContinuation, prepared.fullRequest ?? fullRequest, terminalResponse, previousContinuation?.lastResponseId === prepared.request.previous_response_id);
 		lease.release({ keep });
 	};
 	return {
@@ -1337,6 +1290,36 @@ function restoreResponsesReasoningState(context, model, identity, request) {
 	return prepared;
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-request-fetch.ts
+function withDefaultResponsesStreamEncoding(fetch) {
+	return (input, init) => {
+		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		if (headers.has("accept-encoding")) return fetch(input, init);
+		headers.set("accept-encoding", "identity");
+		return fetch(input, {
+			...init,
+			headers
+		});
+	};
+}
+/** Preserve the existing fetch policy while binding explicit continuation dispatch to its signal. */
+function createResponsesRequestFetch(model, options) {
+	const lifecycle = options.lifecycle;
+	if (lifecycle && options.compact) throw new Error("Provider review continuation cannot replace its reviewed input with compaction");
+	let fetchOverride = options.compact ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : options.stream ? withDefaultResponsesStreamEncoding(buildGuardedModelFetch(model)) : void 0;
+	if (lifecycle) {
+		const dispatchFetch = fetchOverride ?? buildGuardedModelFetch(model);
+		fetchOverride = async (input, init) => {
+			const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
+			await lifecycle.beforeDispatch(signal ?? void 0);
+			signal?.throwIfAborted();
+			lifecycle.assertCurrent();
+			return dispatchFetch(input, init);
+		};
+	}
+	return fetchOverride;
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-client.ts
 function resolveNativeOpenAIResponsesWebSocketMode(model, transport) {
 	if (transport !== "websocket" && transport !== "websocket-cached" && transport !== "auto") return;
@@ -1362,29 +1345,20 @@ function createOpenAIResponsesClient(model, apiKey, defaultHeaders, fetchOverrid
 		...buildOpenAISdkClientOptions(model)
 	});
 }
-function withDefaultResponsesStreamEncoding(fetch) {
-	return (input, init) => {
-		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
-		if (headers.has("accept-encoding")) return fetch(input, init);
-		headers.set("accept-encoding", "identity");
-		return fetch(input, {
-			...init,
-			headers
-		});
-	};
-}
 function createResponsesTransportExecutor(config) {
 	return (model, context, options) => {
 		const responsesOptions = options;
 		const compactRequest = claimResponsesCompactRequest(responsesOptions);
 		const { eventStream, stream } = createWritableTransportEventStream();
 		(async () => {
-			const output = createOpenAIResponsesAssistantOutput(model, config.outputApi);
+			const output = createAssistantOutput(model, config.outputApi);
 			let firstEventAbort;
 			let continuationClaim;
+			const requestLifecycle = responsesRequestLifecycle.get(options);
 			try {
 				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 				const websocketMode = resolveNativeOpenAIResponsesWebSocketMode(model, responsesOptions?.transport);
+				const encodeBody = prepareModelRequestBody(websocketMode || compactRequest ? void 0 : options);
 				const turnState = resolveProviderTransportTurnState(model, {
 					sessionId: options?.sessionId,
 					turnId: randomUUID(),
@@ -1396,14 +1370,18 @@ function createResponsesTransportExecutor(config) {
 				const websocketTurnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, websocketSessionPolicy?.headers);
 				const websocketHeaders = websocketMode ? buildOpenAIClientHeaders(model, context, options?.headers, websocketTurnHeaders, options?.sessionId, options?.cacheRetention) : void 0;
 				const httpHeaders = buildOpenAIClientHeaders(model, context, options?.headers, httpTurnHeaders, options?.sessionId, options?.cacheRetention);
-				const client = config.createClient(model, apiKey, httpHeaders, compactRequest ? createBoundedOpenAIResponsesCompactionFetch(buildGuardedModelFetch(model)) : config.streamRequest ? withDefaultResponsesStreamEncoding(buildGuardedModelFetch(model)) : void 0);
+				const fetchOverride = createResponsesRequestFetch(model, {
+					compact: Boolean(compactRequest),
+					stream: config.streamRequest,
+					lifecycle: requestLifecycle
+				});
+				const client = config.createClient(model, apiKey, httpHeaders, fetchOverride);
 				const nativeAstra = model.id === "gpt-6-astra" && supportsNativeOpenAIResponsesEndpoint(model);
 				const asyncToolExecutionEligible = nativeAstra && options?.asyncToolExecution === true && !responsesOptions?.openclawCodeModeToolSurface;
 				const prepareRequest = async (request) => {
 					let params = request;
 					const nextParams = await options?.onPayload?.(params, model);
 					if (nextParams !== void 0) params = nextParams;
-					if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
 					params = sanitizeOpenAICodexResponsesParams(model, params);
 					params = sanitizeResponsesImagePayload(params);
 					if (options?.openclawCodeModeToolSurface === true) {
@@ -1477,6 +1455,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)}`);
 				const responseModelTracker = createResponseModelTracker(isOpenAICodexResponsesModel(model));
 				let continuationBaseline;
+				let dispatchedPreviousResponseId;
 				let contextUsageEligible = true;
 				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
 					const { stream: responseStream } = await createResponsesStreamWithEncryptedContentRetry({
@@ -1484,6 +1463,7 @@ function createResponsesTransportExecutor(config) {
 						request: initialRequest,
 						requestOptions,
 						model,
+						encodeBody,
 						observePrompt,
 						initialAttemptKind,
 						initialRejectedCompaction,
@@ -1492,6 +1472,7 @@ function createResponsesTransportExecutor(config) {
 						canRetryStream: () => output.content.length === 0,
 						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
 							contextUsageEligible &&= attempt.kind === "initial";
+							dispatchedPreviousResponseId = attempt.request.previous_response_id;
 							continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
 							const trackedResponseStream = responseModelTracker.track(response, rawResponseStream);
 							return withProviderResponseHook({
@@ -1592,7 +1573,9 @@ function createResponsesTransportExecutor(config) {
 				}
 				else responseStream = await createSseStream();
 				try {
-					const terminal = await processResponsesStream(responseStream, output, stream, model, {
+					const acceptedResponseStream = withResponsesRequestAcceptance(responseStream, requestLifecycle, transport === "websocket" ? websocketSignal : firstEvent.signal);
+					const terminal = await processResponsesStream(acceptedResponseStream, output, stream, model, {
+						canRetryIdentityConflict: () => hasOnlyResponsesFunctionTools(transport === "websocket" ? websocketBaseline : continuationBaseline),
 						...config.pricingOptions?.(responsesOptions, model),
 						firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
 						abortFirstEventStream: firstEvent.abort,
@@ -1610,7 +1593,7 @@ function createResponsesTransportExecutor(config) {
 					if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 					const admitted = transport === "websocket" ? websocketBaseline : continuationBaseline;
 					if (terminal && admitted && supportsNativeOpenAIResponsesEndpoint(model)) recordResponsesReasoningState(output, model, responsesOptions, admitted, terminal.output);
-					if (continuationClaim && continuationBaseline && terminal) continuationClaim.commit(continuationBaseline, terminal);
+					if (continuationClaim && continuationBaseline && terminal) continuationClaim.commit(continuationBaseline, terminal, dispatchedPreviousResponseId);
 					if (terminal && admitted && contextUsageEligible) recordResponsesContextUsage(output, model, responsesOptions, admitted, terminal.output, "transport");
 				} catch (error) {
 					finishWebSocket?.({ keep: false });
@@ -1623,6 +1606,7 @@ function createResponsesTransportExecutor(config) {
 					signal: options?.signal
 				});
 			} catch (error) {
+				if (requestLifecycle) await requestLifecycle.settle().catch(() => void 0);
 				if (compactRequest) {
 					compactRequest.reject(error);
 					failTransportStream({
@@ -1884,21 +1868,8 @@ const SIMPLE_TRANSPORT_API_ALIAS = {
 	"google-generative-ai": "openclaw-google-generative-ai-transport"
 };
 function createProviderOwnedGoogleTransportStreamFn(model, ctx) {
-	const streamFn = getAiTransportHost().plugin.resolveProviderStream({
-		provider: model.provider,
-		config: ctx?.cfg,
-		workspaceDir: ctx?.workspaceDir,
-		env: ctx?.env,
-		context: {
-			config: ctx?.cfg,
-			agentDir: ctx?.agentDir,
-			workspaceDir: ctx?.workspaceDir,
-			provider: model.provider,
-			modelId: model.id,
-			model
-		}
-	}) ?? getAiTransportHost().plugin.resolveProviderStream({
-		provider: "google",
+	const resolveStream = (provider) => getAiTransportHost().plugin.resolveProviderStream({
+		provider,
 		config: ctx?.cfg,
 		workspaceDir: ctx?.workspaceDir,
 		env: ctx?.env,
@@ -1910,7 +1881,8 @@ function createProviderOwnedGoogleTransportStreamFn(model, ctx) {
 			modelId: model.id,
 			model
 		}
-	}) ?? void 0;
+	});
+	const streamFn = resolveStream(model.provider) ?? resolveStream("google") ?? void 0;
 	return streamFn ? (requestModel, context, options) => streamFn(requestModel, context, {
 		...options,
 		headers: resolveOpencodeSessionHeaders(requestModel, options)
@@ -1927,13 +1899,6 @@ function createSupportedTransportStreamFn(model, ctx) {
 		default: return;
 	}
 }
-function hasOpenClawTransportRequirement(model) {
-	return getAiTransportHost().requiresManagedTransport(model);
-}
-/** Returns whether OpenClaw has a managed transport implementation for this API. */
-function isTransportAwareApiSupported(api) {
-	return SUPPORTED_TRANSPORT_APIS.has(api);
-}
 /** Maps public model APIs to the internal transport API id used by simple runtime dispatch. */
 function resolveTransportAwareSimpleApi(api) {
 	if (OPENAI_RESPONSES_APIS.has(api)) {
@@ -1944,19 +1909,17 @@ function resolveTransportAwareSimpleApi(api) {
 }
 /** Creates a managed transport stream only when request overrides require it. */
 function createTransportAwareStreamFnForModel(model, ctx) {
-	if (!hasOpenClawTransportRequirement(model)) return;
-	if (!isTransportAwareApiSupported(model.api)) throw new Error(`Model-provider request.proxy/request.tls/localService is not yet supported for api "${model.api}"`);
+	if (!getAiTransportHost().requiresManagedTransport(model)) return;
+	if (!SUPPORTED_TRANSPORT_APIS.has(model.api)) throw new Error(`Model-provider request.proxy/request.tls/localService is not yet supported for api "${model.api}"`);
 	const streamFn = createSupportedTransportStreamFn(model, ctx);
 	if (!streamFn) throw new Error(`Managed transport stream is unavailable for api "${model.api}"`);
 	return streamFn;
 }
 /** Creates a managed OpenClaw transport stream for explicit fallback/runtime callers. */
 function createOpenClawTransportStreamFnForModel(model, ctx) {
-	if (!isTransportAwareApiSupported(model.api)) return;
 	return createSupportedTransportStreamFn(model, ctx);
 }
 function createBoundaryAwareStreamFnForModel(model, ctx) {
-	if (!isTransportAwareApiSupported(model.api)) return;
 	return createSupportedTransportStreamFn(model, ctx);
 }
 function prepareTransportAwareSimpleModel(model, ctx) {
@@ -2030,13 +1993,15 @@ function normalizeCodexResponsesBaseUrlForOpenAISdk(baseUrl) {
 	if (path.endsWith("/codex/responses")) return path.slice(0, -10);
 	return path.endsWith("/codex") ? path : `${path}/codex`;
 }
-function resolveProviderSimpleCompletionApi(model) {
+function resolveProviderSimpleCompletionApi(model, auth, agentId) {
 	const parts = [
 		model.provider,
 		model.id,
 		model.api,
 		model.baseUrl || "default"
 	];
+	if (auth) parts.push(auth.mode, auth.authFlow ?? "");
+	if (agentId) parts.push("agent", agentId);
 	return `${PROVIDER_SIMPLE_COMPLETION_API_PREFIX}${parts.map((part) => encodeURIComponent(part)).join(":")}`;
 }
 function resolveProviderStreamApi(model) {
@@ -2048,7 +2013,7 @@ function resolveProviderStreamApi(model) {
 	];
 	return `${PROVIDER_STREAM_API_PREFIX}${parts.map((part) => encodeURIComponent(part)).join(":")}`;
 }
-function applyProviderSimpleCompletionWrapper(registry, model, cfg, hookSourceApi = model.api) {
+function applyProviderSimpleCompletionWrapper(registry, model, cfg, hookSourceApi = model.api, auth, agentId) {
 	if (model.api.startsWith(PROVIDER_SIMPLE_COMPLETION_API_PREFIX)) return model;
 	const sourceProvider = registry.getApiProvider(model.api);
 	if (!sourceProvider) return model;
@@ -2063,12 +2028,15 @@ function applyProviderSimpleCompletionWrapper(registry, model, cfg, hookSourceAp
 			modelId: model.id,
 			model,
 			sourceApi: hookSourceApi,
+			auth,
+			agentId,
 			streamFn: sourceStreamFn
 		}
 	});
 	if (!streamFn) return model;
-	const api = resolveProviderSimpleCompletionApi(model);
-	return registerCustomApi(registry, api, streamFn) ? projectModel(model, { api }) : model;
+	const registeredStreamFn = (runtimeModel, context, options) => streamFn(projectModel(runtimeModel, { api: hookSourceApi }), context, options);
+	const api = resolveProviderSimpleCompletionApi(model, auth, agentId);
+	return registerCustomApi(registry, api, registeredStreamFn) ? projectModel(model, { api }) : model;
 }
 function prepareCodexSimpleTransportModel(registry, model, cfg) {
 	if (model.provider !== "openai" || model.api !== "openai-chatgpt-responses") return;
@@ -2119,25 +2087,26 @@ function prepareProviderStreamModel(params) {
 	return api === params.model.api ? params.model : projectModel(params.model, { api });
 }
 function prepareModelForSimpleCompletion(params) {
-	const { apiRegistry, model, cfg } = params;
+	const { apiRegistry, model, cfg, auth, agentId } = params;
+	const wrap = (prepared) => applyProviderSimpleCompletionWrapper(apiRegistry, prepared, cfg, model.api, auth, agentId);
 	const providerStreamModel = prepareProviderStreamModel({
 		model,
 		cfg,
 		apiRegistry
 	});
-	if (providerStreamModel) return applyProviderSimpleCompletionWrapper(apiRegistry, providerStreamModel, cfg, model.api);
+	if (providerStreamModel) return wrap(providerStreamModel);
 	const codexTransportModel = prepareCodexSimpleTransportModel(apiRegistry, model, cfg);
-	if (codexTransportModel) return applyProviderSimpleCompletionWrapper(apiRegistry, codexTransportModel, cfg, model.api);
+	if (codexTransportModel) return wrap(codexTransportModel);
 	const transportAwareModel = prepareTransportAwareSimpleModel(model, { cfg });
 	if (transportAwareModel !== model) {
 		const streamFn = buildTransportAwareSimpleStreamFn(model, { cfg });
-		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return applyProviderSimpleCompletionWrapper(apiRegistry, transportAwareModel, cfg, model.api);
+		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return wrap(transportAwareModel);
 	}
 	if (model.provider === "anthropic-vertex") {
 		const api = resolveAnthropicVertexSimpleApi(model.baseUrl);
-		if (registerCustomApi(apiRegistry, api, getAiTransportHost().plugin.createAnthropicVertexStream(model))) return applyProviderSimpleCompletionWrapper(apiRegistry, projectModel(model, { api }), cfg, model.api);
+		if (registerCustomApi(apiRegistry, api, getAiTransportHost().plugin.createAnthropicVertexStream(model))) return wrap(projectModel(model, { api }));
 	}
-	return applyProviderSimpleCompletionWrapper(apiRegistry, model, cfg);
+	return wrap(model);
 }
 //#endregion
-export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, IncompleteToolCallError, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyCompletionsAnthropicCacheControl, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildAnthropicSystemBlocks, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, consumeGoogleGenerateContentStream, convertGoogleTools, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createResponseModelTracker, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isAnthropicServerToolClearingEnabled, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareHeadersForSimpleCompletion, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, projectGoogleMessages, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, requiresGoogleToolCallId, resolveAnthropicCacheOptions, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };
+export { CompactionReplayRefreshRequiredError, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, IncompleteToolCallError, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, OPENAI_RESPONSES_CALL_ID_RE, OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE, OPENAI_RESPONSES_ID_MAX_LENGTH, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyCompletionsAnthropicCacheControl, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildAnthropicSystemBlocks, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, consumeGoogleGenerateContentStream, convertGoogleTools, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createResponseModelTracker, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, filterCodeModePayloadTools, finalizeTerminalToolCallArguments, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, googleFlashSupportsMinimalThinking, hasOpenAICompatibleConversationTurn, isAnthropicServerToolClearingEnabled, isCodeModeModelVisibleToolName, isCompactionReplayCheckpoint, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, isOpenAICompletionsThinkingEnabled, iterateModelStream, log, logAnthropicContextEdits, measureUtf8AppendBytes, mergeTransportHeaders, normalizeCodexResponsesBaseUrlForOpenAISdk, normalizeOpenAIResponsesFunctionCallId, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, parseOpenAICompletionsUsage, parseTerminalToolCallArguments, prepareHeadersForSimpleCompletion, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, preserveCompactionReplayWindow, projectGoogleMessages, quoteUnsafeIntegerLiterals, readCodeModePayloadToolName, readOpenAICompletionsContentDeltas, readOpenAICompletionsReasoningBatch, replaceCompactionReplayOwnerContent, requestPreparedOpenAIResponsesCompaction, requiresCompactionReplayRefresh, requiresGoogleToolCallId, resolveAnthropicCacheOptions, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveAnthropicRequestBetaHeader, resolveAnthropicServerCompactionPlan, resolveCodeModeResponsesVisibleToolNames, resolveCompactionReplayEligibility, resolveCompactionReplayPressure, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIClientBaseUrl, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, shouldNormalizeOpenAIResponsesToolCallId, sortPromptCacheToolsByName as sortTransportToolsByName, splitOpenAIFunctionCallPairing, stripCompactionReplayCheckpoint, stripCompactionReplayCheckpointInPlace, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };