@openclaw/ai 2026.9.8 → 2026.10.1-beta.1

package/dist/transports.mjs

@@ -1,144 +1,50 @@
-import { S as supportsClaudeAdaptiveThinking, b as resolveClaudeSonnet5ModelIdentity, v as resolveClaudeOpus5ModelIdentity, y as resolveClaudeSonnet55ModelIdentity } from "./src-H4aXcFuX.mjs";
+import { S as supportsClaudeAdaptiveThinking } from "./src-B0NIt2UK.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-DwBmNMCC.mjs";
-import { n as normalizeLowercaseStringOrEmpty, t as hasNonEmptyString } from "./string-coerce-fsri9iCu.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-CqXzku3R.mjs";
-import { a as resolveOpenAIPromptCacheKeySupport, i as resolveOpenAICompletionsCompat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-BJf57ZxN.mjs";
-import { r as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-wK-ay_RK.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-DrsBCsFY.mjs";
-import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.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-BU5pwY6W.mjs";
-import { D as sortPromptCacheToolsByName, l as codeModeToolSurfaceObserver, s as prepareModelRequestBody, t as adjustMaxTokensForThinking, u as reasoningTagTextPolicy } from "./simple-options-BkDPMuxw.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-DyFJ4cgR.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-CtgOVOSv.mjs";
+import { T as usesClaudeStreamingRefusalContract, _ as buildAnthropicClaudeCodeIdentity, a as resolveAiTransportHeaderSentinels, b as prepareClaudeNoPrefillRequestContext, r as getAiTransportHost } from "./host-DCW52iHe.mjs";
+import { A as resolveOpenAIThinkingApi, D as supportsOpenAITemperature, b as isOpenAIGpt6Model, d as OpenAIResponsesWebSocketSafeRetryError, g as responsesServiceTierObserver, i as OPENAI_RESPONSES_APIS, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, r as OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS, t as AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS, u as OpenAIResponsesWebSocketPreDispatchError } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { n as getSessionResourceOwnerId, r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
+import { a as redactDiagnosticText, o as truncateUtf16Safe, s as stableStringify } from "./provider-error-DQBE1bUQ.mjs";
+import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-I8YQTzf8.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-Caj-4RBA.mjs";
+import { a as readResponseTextSnippet, i as isCodeModeModelVisibleToolName, n as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, s as resolveModelHeaderSentinels } from "./text-signature-MLwfi6fq.mjs";
+import { a as resolveOpenAIPromptCacheKeySupport, c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat, n as isNativeOpenAIEndpoint, o as usesNativeOpenAICodexResponsesBackend, r as isOpenAICodexResponsesModel, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-BdmlhD4u.mjs";
+import { t as buildGuardedModelFetch } from "./host-policy-B3jc4Rpn.mjs";
+import { A as buildAnthropicSystemBlocks, C as isAnthropicReplayRejection, D as applyAnthropicEphemeralCacheControlMarkers, E as applyAnthropicContextManagementToRequest, F as resolveAnthropicEphemeralCacheControl, I as resolveAnthropicPayloadPolicy, J as usesFoundryBearerAuth, K as isAnthropicOAuthApiKey, L as resolveAnthropicRequestBetaHeader, M as isDirectAnthropicModel, N as logAnthropicContextEdits, O as applyAnthropicPayloadPolicyToParams, P as resolveAnthropicCacheOptions, R as resolveAnthropicServerCompactionPlan, T as suppressAnthropicCompaction, d as resolveAnthropicTransportOptions, j as isAnthropicServerToolClearingEnabled, k as applyAnthropicRequestCacheControl, l as buildAnthropicRequest, q as omitFoundryBearerCredentialHeaders, t as consumeAnthropicStream, u as prepareAnthropicRequest, w as resolveNewestAnthropicCompaction, z as supportsAnthropicServerSideFallback } from "./anthropic-stream-reducer-BQ1tjd7x.mjs";
+import { i as resolveCacheRetention } from "./cloudflare-5qSGvIUH.mjs";
+import { C as parseJsonObjectPreservingUnsafeIntegers, M as racePromiseWithAbortSignal, 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, j as createAbortError$1, 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-CxXXz_Dd.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, l as codeModeToolSurfaceObserver, s as prepareModelRequestBody } from "./simple-options-BkKTXxhp.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, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, i as buildOpenAISdkRequestOptions, j as sha256Hex, k as resolvePromptCacheKey, l as resolveCodeModeResponsesVisibleToolNames, m as reconcileOpenAIResponsesToolChoice, 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-JFsnIyto.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-Bs5aWE1d.mjs";
-import { a as tagUnresolvedTextAsCommentary } from "./assistant-text-phase-C20rxWwP.mjs";
-import { n as createAssistantOutput } from "./provider-transcript-transform-DjA5Fk2P.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-dju_5F3P.mjs";
-import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-Dz2dAnGo.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-Dw7OtYUs.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-CYGCjAQz.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-CIEHiKx7.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-BX3QTNSv.mjs";
+import { n as isProviderReplayContext, r as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-C7Bmi84a.mjs";
+import { t as createAssistantOutput } from "./assistant-output-OLm-Oln0.mjs";
+import { n as resolveOpencodeSessionHeaders } from "./session-affinity-DA4WHv1h.mjs";
+import { a as flattenCompletionMessagesToStringContent, c as hasOpenAICompatibleConversationTurn, d as createDeepSeekTextFilter, l as canonicalizeMaxTokensParam, o as stripCompletionMessagesToRoleContent, r as buildOpenAICompletionsParams, s as applyCompletionsAnthropicCacheControl, t as createOpenAICompletionsTransportStreamFn, u as resolveMaxTokensParam } from "./openai-completions-transport-DWM2mQDB.mjs";
+import { a as googleFlashSupportsMinimalThinking, i as consumeGoogleGenerateContentStream, n as projectGoogleMessages, r as requiresGoogleToolCallId, t as convertGoogleTools } from "./google-messages-BwPPycw6.mjs";
+import { r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-_M2kLdUE.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.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-m878aVpU.mjs";
+import { $ as OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE, A as recordResponsesContextUsage, B as recordResponsesContinuationState, C as resolveAzureOpenAIApiVersion, D as safeDebugValue, E as logResponsesFailedNoDetails, F as convertResponsesMessages, G as replayResponsesReasoningUpdates, H as responsesContinuationPrefixFingerprint, I as readResponsesInputReplayState, J as buildOpenAIResponsesReasoningReplayMetadata, K as supportsResponsesReasoningUpdate, L as recordResponsesInputReplay, N as buildResponsesInputMessage, O as summarizeOpenAITransportError, Q as OPENAI_RESPONSES_CALL_ID_RE, R as responsesInputFingerprint, S as isInvalidEncryptedContentError, T as ResponsesStreamFailure, U as responsesContinuationRequestFingerprint, V as resolveResponsesContinuationRequest, W as isConfigurationUpdate, X as resolveNewestOpenAIResponsesCompactionReplay, Y as captureOpenAIResponsesCompaction, Z as suppressOpenAIResponsesCompaction, a as prepareResponsesTools, 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 CompactionReplayRefreshRequiredError, rt as splitOpenAIFunctionCallPairing, s as processResponsesStream, tt as normalizeOpenAIResponsesFunctionCallId, w as resolveNextResponsesEncryptedContentAttempt, x as createResponsesStreamWithEncryptedContentRetry, z as claimOpenAIResponsesHttpContinuation } from "./openai-responses-shared-C7oVyjED.mjs";
+import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-D0dvJMbZ.mjs";
+import { t as hasResponsesWebSearchTool } from "./openai-web-search-tools-Cfu0uLyN.mjs";
+import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-CCg7B6l4.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-options.ts
-const ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS = 4096;
-const ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR = 4;
-function resolvePositiveAnthropicTokenLimit(value) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return;
-	const floored = Math.floor(value);
-	return floored > 0 ? floored : void 0;
-}
-function resolveAnthropicMessagesMaxTokens(params) {
-	const requested = resolvePositiveAnthropicTokenLimit(params.requestedMaxTokens);
-	if (requested !== void 0) return requested;
-	const modelMax = resolvePositiveAnthropicTokenLimit(params.modelMaxTokens);
-	if (modelMax !== void 0) return params.useModelDefault ? modelMax : Math.min(modelMax, 32e3);
-	if (params.modelMaxTokens !== void 0) return;
-	const contextWindow = resolvePositiveAnthropicTokenLimit(params.modelContextWindow);
-	return contextWindow === void 0 ? ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS : Math.max(1, Math.min(ANTHROPIC_MESSAGES_DEFAULT_MAX_TOKENS, Math.floor(contextWindow / ANTHROPIC_MESSAGES_FALLBACK_CONTEXT_DIVISOR)));
-}
-function 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 ?? ""));
 }
-/**
-* Server-side refusal fallback is a first-party Claude API beta: proxies and
-* Bedrock/Vertex/Foundry reject the `fallbacks` param, and OAuth (Claude Code
-* identity) requests are excluded until the beta is verified there.
-*/
-function useAnthropicServerSideFallback(model) {
-	return (usesClaudeFable5MessagesContract(model) || resolveClaudeOpus5ModelIdentity(model) !== void 0 || resolveClaudeSonnet55ModelIdentity(model) !== void 0) && isDirectAnthropicModel(model);
-}
-function supportsReasoningContentReplay(model) {
-	return resolveProviderEndpoint(model).endpointClass === "xiaomi-native";
-}
 function buildAnthropicBetaHeader(model, betaFeatures, params) {
 	if (!isDirectAnthropicModel(model)) return;
 	return params.oauth ? `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}` : betaFeatures.join(",");
 }
-function ensureNonEmptyAnthropicMessages(messages) {
-	return messages.length > 0 ? messages : [{
-		role: "user",
-		content: EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT
-	}];
-}
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
 /** Resolve the effective Anthropic API base URL from model or environment. */
 function resolveAnthropicBaseUrl(baseUrl) {
@@ -324,7 +230,12 @@ function createAnthropicTransportClient(params) {
 		"anthropic-dangerous-direct-browser-access": "true",
 		...betaHeader ? { "anthropic-beta": betaHeader } : {},
 		...options?.sessionId && options.cacheRetention !== "none" && model.compat?.sendSessionAffinityHeaders === true ? { "x-session-affinity": options.sessionId } : {}
-	}, model.headers, optionHeaders);
+	}, model.headers, optionHeaders, getAiTransportHost().resolveProviderRequestHeaders({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		model
+	}));
 	return {
 		request: createAnthropicMessageRequest({
 			apiKey,
@@ -336,54 +247,6 @@ function createAnthropicTransportClient(params) {
 		directApiKeyBetaHeader: isDirectAnthropicModel(model) ? new Headers(defaultHeaders).get("anthropic-beta") ?? "" : void 0
 	};
 }
-async function buildAnthropicParams(model, context, isOAuthToken, options, claudeCodeVersion) {
-	const replayThinkingEnabled = requiresClaudeAdaptiveThinking(model) || options?.thinkingEnabled === true;
-	const maxTokens = resolveAnthropicMessagesMaxTokens({
-		modelContextWindow: model.contextWindow,
-		modelMaxTokens: model.maxTokens,
-		requestedMaxTokens: options?.maxTokens
-	});
-	if (maxTokens === void 0) throw new Error(`Anthropic Messages transport requires a positive maxTokens value for ${model.provider}/${model.id}`);
-	const { cacheControl, supportsCacheControlOnTools } = resolveAnthropicCacheOptions(model, options?.cacheRetention);
-	const replayPlan = buildAnthropicReplayPlan(context.messages, model, {
-		enabled: !isOAuthToken && options?.anthropicServerCompaction === true,
-		authProfileId: options?.authProfileId,
-		sessionId: options?.sessionId
-	});
-	const cacheBreakpointOptOutMessageIndexes = /* @__PURE__ */ new Set();
-	const messages = await convertAnthropicMessages(getAiTransportHost().transformTransportMessages(replayPlan.messages, model, normalizeAnthropicToolCallId, void 0), model, isOAuthToken, {
-		profile: "transport",
-		allowReasoningContentReplay: supportsReasoningContentReplay(model),
-		allowEmptySignature: model.compat?.allowEmptySignature,
-		compaction: replayPlan.compaction,
-		replayThinkingEnabled,
-		cacheBreakpointOptOutMessageIndexes
-	});
-	const params = {
-		model: resolveAnthropicRequestModelId(model),
-		messages: ensureNonEmptyAnthropicMessages(messages),
-		max_tokens: maxTokens,
-		stream: true
-	};
-	if (!isOAuthToken && useAnthropicServerSideFallback(model)) params.fallbacks = ANTHROPIC_SERVER_SIDE_FALLBACKS;
-	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;
-	Object.assign(params, buildAnthropicGenerationParams({
-		model,
-		options,
-		tools: convertedTools?.tools,
-		toolProjection,
-		profile: "transport"
-	}));
-	applyAnthropicRequestCacheControl(params, cacheControl, supportsCacheControlOnTools, cacheBreakpointOptOutMessageIndexes);
-	return {
-		params,
-		toolProjection,
-		usedCompactionReplay: replayPlan.compaction !== void 0
-	};
-}
 /** Create the stream function used by Anthropic Messages transport models. */
 function createAnthropicMessagesTransportStreamFn() {
 	return (rawModel, context, rawOptions) => {
@@ -405,21 +268,15 @@ function createAnthropicMessagesTransportStreamFn() {
 					apiKey,
 					options: transportOptions
 				});
-				const builtParams = await buildAnthropicParams(model, requestContext, isOAuthToken, transportOptions, claudeCodeVersion);
+				const builtParams = await buildAnthropicRequest(model, requestContext, transportOptions, "transport", isOAuthToken, !isOAuthToken && supportsAnthropicServerSideFallback(model), 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 = resolveAnthropicRequestBetaHeader(params, directApiKeyBetaHeader);
-				const bindingHeaders = applyAnthropicThinkingBindingControls(params, betaHeader) ?? (betaHeader ? { "anthropic-beta": betaHeader } : void 0);
+				const { params, headers } = await prepareAnthropicRequest(builtParams.params, model, transportOptions, directApiKeyBetaHeader);
 				const { response, stream: anthropicStream } = await request({
 					...params,
 					stream: true
 				}, {
 					signal: transportOptions.signal,
-					headers: bindingHeaders
+					headers
 				});
 				await notifyProviderHttpResponse({
 					options: transportOptions,
@@ -470,221 +327,144 @@ function createAnthropicMessagesTransportStreamFn() {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-compatible-conversation-turn.ts
-/**
-* OpenAI-compatible conversation turn detector.
-*
-* Some providers reject requests without a non-empty user/assistant turn; this
-* helper checks the loose message payload shape before transport submission.
-*/
-function hasNonEmptyContentPart(part) {
-	if (!part || typeof part !== "object") return false;
-	const record = part;
-	if (record.type === "text") return hasNonEmptyString(record.text);
-	return true;
-}
-function hasNonEmptyMessageContent(content) {
-	if (hasNonEmptyString(content)) return true;
-	if (!Array.isArray(content)) return false;
-	return content.some(hasNonEmptyContentPart);
-}
-function hasAssistantToolCall(message) {
-	const toolCalls = message.tool_calls;
-	return Array.isArray(toolCalls) && toolCalls.some((toolCall) => {
-		return Boolean(toolCall && typeof toolCall === "object");
-	});
-}
-/** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
-function hasOpenAICompatibleConversationTurn(messages) {
-	if (!Array.isArray(messages)) return false;
-	return messages.some((message) => {
-		if (!message || typeof message !== "object") return false;
-		const record = message;
-		if (record.role === "user") return hasNonEmptyMessageContent(record.content);
-		if (record.role === "assistant") return hasNonEmptyMessageContent(record.content) || hasAssistantToolCall(record);
-		return false;
+//#region packages/ai/src/transports/openai-responses-params-internal.ts
+const OPENAI_RESPONSES_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"opencode",
+	"azure-openai-responses",
+	"github-copilot"
+]);
+function raiseMinimalReasoningForResponsesWebSearch(params) {
+	if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
+	for (const effort of [
+		"low",
+		"medium",
+		"high"
+	]) {
+		const resolved = resolveOpenAIRequestReasoning(params.model, effort).effort;
+		if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
+	}
+	return params.effort;
+}
+const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
+	"max_output_tokens",
+	"metadata",
+	"prompt_cache_retention",
+	"prompt_cache_options",
+	"service_tier",
+	"temperature",
+	"top_p"
+];
+function stripOpenAICodexResponsesUnsupportedTextFields(params) {
+	const text = params.text;
+	if (!text || typeof text !== "object" || Array.isArray(text)) return;
+	const sanitizedText = { ...text };
+	delete sanitizedText.format;
+	if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
+	else delete params.text;
+}
+function sanitizeOpenAICodexResponsesParams(model, params) {
+	if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
+	for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
+	Object.assign(params, { store: false });
+	stripOpenAICodexResponsesUnsupportedTextFields(params);
+	return params;
+}
+function buildOpenAIResponsesInstructionsText(context) {
+	if (!context.systemPrompt) return;
+	return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
+}
+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 buildOpenAIResponsesCompactSystemMessage(model, instructions) {
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
+	const role = model.reasoning && supportsDeveloperRole !== false ? "developer" : "system";
+	return buildResponsesInputMessage(role, [{
+		type: "input_text",
+		text: instructions
+	}]);
+}
+function ensureOpenAIResponsesNonEmptyInput(messages, context) {
+	if (messages.length > 0 || !context.systemPrompt) return;
+	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: " "
+	}]));
+}
+function buildOpenAIResponsesParams(model, context, options, metadata, replayMode = "checkpoint") {
+	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "transport-default" });
+	const policyAllowsReplayIds = payloadPolicy.explicitStore !== false && !payloadPolicy.shouldStripStore;
+	const replayResponsesItemIds = !usesNativeOpenAICodexResponsesBackend(model) && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
+	const messages = convertResponsesMessages(model, context, OPENAI_RESPONSES_TOOL_CALL_PROVIDERS, {
+		includeSystemPrompt: !payloadPolicy.usesInstructionsField,
+		replayReasoningItems: true,
+		replayResponsesItemIds,
+		authProfileId: options?.authProfileId,
+		sessionId: options?.sessionId,
+		replayMode
 	});
-}
-//#endregion
-//#region packages/ai/src/transports/openai-completions-transport.ts
-function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
-	const messages = params.messages;
-	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
-	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
-}
-const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
-const SSE_DONE_MAX_LINE_CHARS = 1024;
-function createSseDoneDetector() {
-	const decoder = new TextDecoder();
-	let line = "";
-	let lineOverflowed = false;
-	let sawDone = false;
-	const finishLine = () => {
-		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
-		line = "";
-		lineOverflowed = false;
-	};
-	const observeText = (text) => {
-		for (const char of text) {
-			if (char === "\n" || char === "\r") {
-				finishLine();
-				continue;
-			}
-			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
-			else lineOverflowed = true;
-		}
+	ensureOpenAIResponsesNonEmptyInput(messages, context);
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const compat = getCompat(model);
+	const promptCacheKey = compat.supportsPromptCacheKey ? resolvePromptCacheKey(options, cacheRetention) : void 0;
+	const instructions = resolveOpenAIResponsesInstructions(model, context, payloadPolicy.usesInstructionsField);
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: promptCacheKey,
+		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
+		...instructions ? { instructions } : {},
+		...metadata ? { metadata } : {}
 	};
-	return {
-		observe(chunk) {
-			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
-		},
-		finish() {
-			if (sawDone) return;
-			observeText(decoder.decode());
-			if (line || lineOverflowed) finishLine();
-		},
-		sawDone: () => sawDone
+	const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
+	if (effectiveMaxTokens) params.max_output_tokens = Math.max(effectiveMaxTokens, 16);
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
+	if (options?.topP !== void 0 && (!isOpenAIGpt6Model(model) || resolveOpenAIThinkingApi(model.api) === "azure-openai-responses")) params.top_p = options.topP;
+	if (options?.responseFormat !== void 0) params.text = {
+		...params.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
 	};
-}
-function createOpenAICompletionsClient(model, apiKey, headers, opts) {
-	const clientConfig = buildOpenAICompletionsClientConfig(model, headers);
-	return new OpenAI({
-		apiKey,
-		baseURL: clientConfig.baseURL,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: clientConfig.defaultHeaders,
-		defaultQuery: clientConfig.defaultQuery,
-		fetch: opts?.fetch ?? buildGuardedModelFetch(model),
-		...buildOpenAISdkClientOptions(model)
-	});
-}
-function buildOpenAICompletionsClientConfig(model, headers) {
-	const defaultQuery = {};
-	let baseURL = model.baseUrl;
-	let isAzureHost = false;
-	try {
-		const parsed = new URL(model.baseUrl);
-		isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
-		parsed.searchParams.forEach((value, key) => {
-			if (value) defaultQuery[key] = value;
+	if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
+	if (context.tools) {
+		const tools = context.tools;
+		const strict = getAiTransportHost().resolveOpenAIStrictToolSetting(model, {
+			transport: "stream",
+			supportsStrictMode: compat.supportsStrictMode
 		});
-		parsed.search = "";
-		baseURL = parsed.toString().replace(/\/$/, "");
-	} catch {}
-	if (isAzureHost) {
-		const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
-		if (apiVersionHeader) {
-			const apiVersion = headers[apiVersionHeader]?.trim();
-			delete headers[apiVersionHeader];
-			if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
+		const { projection, tools: converted } = prepareResponsesTools(tools, strict, model);
+		if (converted.length > 0 || projection.inputToolCount === 0 && projection.diagnostics.length === 0) params.tools = converted;
+		if (options?.toolChoice) {
+			const toolChoice = reconcileOpenAIResponsesToolChoice(options.toolChoice, projection);
+			if (toolChoice !== void 0) params.tool_choice = toolChoice;
 		}
 	}
-	return {
-		baseURL: resolveOpenAIClientBaseUrl(model, baseURL),
-		defaultHeaders: headers,
-		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
-	};
-}
-function createOpenAICompletionsTransportStreamFn() {
-	return (model, context, options) => {
-		const { eventStream, stream } = createWritableTransportEventStream();
-		(async () => {
-			const output = createAssistantOutput(model);
-			let firstEventAbort;
-			try {
-				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-				const turnState = resolveProviderTransportTurnState(model, {
-					sessionId: options?.sessionId,
-					turnId: randomUUID(),
-					attempt: 1,
-					transport: "stream"
-				});
-				const optionHeaders = resolveOpencodeSessionHeaders(model, options);
-				const turnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
-				const doneDetector = createSseDoneDetector();
-				const baseFetch = buildGuardedModelFetch(model);
-				const doneDetectingFetch = async (url, init) => {
-					const response = await baseFetch(url, init);
-					if (!response.body || !response.ok) return response;
-					if (typeof TransformStream === "undefined" || !response.body.pipeThrough) return response;
-					const transformed = response.body.pipeThrough(new TransformStream({
-						transform(chunk, controller) {
-							doneDetector.observe(chunk);
-							controller.enqueue(chunk);
-						},
-						flush() {
-							doneDetector.finish();
-						}
-					}));
-					return new Response(transformed, {
-						headers: response.headers,
-						status: response.status,
-						statusText: response.statusText
-					});
-				};
-				const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-				const client = createOpenAICompletionsClient(model, apiKey, buildOpenAIClientHeaders(model, context, {
-					...turnHeaders,
-					...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) {
-					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
-					enforceCodeModeResponsesToolSurface(params, visibleToolNames, void 0, codeModeToolSurfaceObserver.get(options));
-					assertCodeModeResponsesToolSurface(params, visibleToolNames);
-				}
-				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 }),
-					...await encodeBody(params)
-				}).withResponse();
-				const hookedResponseStream = withProviderResponseHook({
-					stream: responseStream,
-					signal: firstEventAbort.signal,
-					abort: firstEventAbort.abort,
-					hook: createOpenAIProviderAcceptanceHook(options, response, model),
-					onReady: () => stream.push({
-						type: "start",
-						partial: output
-					})
-				});
-				await processCompletionsStream(hookedResponseStream, output, model, stream, {
-					signal: options?.signal,
-					emitReasoning,
-					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
-					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
-					abortFirstEventStream: firstEventAbort.abort,
-					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-					sawStreamDONE: doneDetector.sawDone
-				});
-				finalizeTransportStream({
-					stream,
-					output,
-					signal: options?.signal
-				});
-			} catch (error) {
-				failTransportStream({
-					stream,
-					output,
-					signal: options?.signal,
-					error,
-					cleanup: () => {
-						output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-						finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
-						tagUnresolvedTextAsCommentary(output);
-					}
-				});
-			} finally {
-				firstEventAbort?.dispose();
-			}
-		})();
-		return eventStream;
-	};
+	if (model.reasoning) {
+		const reasoning = options?.reasoning;
+		const requestedEffort = options?.reasoningEffort ?? (reasoning === "none" ? "none" : resolveOpenAISimpleReasoningEffort(model, reasoning)) ?? (options?.reasoningSummary ? "high" : payloadPolicy.defaultManagedReasoningEffort);
+		const resolvedEffort = requestedEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, requestedEffort).effort;
+		if (resolvedEffort !== void 0) {
+			const effort = raiseMinimalReasoningForResponsesWebSearch({
+				model,
+				effort: resolvedEffort,
+				tools: params.tools
+			});
+			const summary = effort !== "none" && (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) ? options.reasoningSummary || "auto" : void 0;
+			params.reasoning = {
+				effort,
+				...summary ? { summary } : {}
+			};
+			if (summary) params.include = ["reasoning.encrypted_content"];
+		}
+	}
+	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
+	return sanitizeOpenAICodexResponsesParams(model, params);
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-steering.ts
@@ -813,12 +593,8 @@ const websocketSessionCache = /* @__PURE__ */ new Map();
 const degradedWebSocketConnections = /* @__PURE__ */ new Map();
 function isOfficialOpenAIResponsesBaseUrl(baseUrl) {
 	if (!baseUrl) return false;
-	try {
-		const url = new URL(baseUrl);
-		return url.origin === "https://api.openai.com" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && url.pathname.replace(/\/+$/, "") === "/v1";
-	} catch {
-		return false;
-	}
+	const url = URL.parse(baseUrl);
+	return url !== null && url.origin === "https://api.openai.com" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && url.pathname.replace(/\/+$/, "") === "/v1";
 }
 function supportsNativeOpenAIResponsesEndpoint(params) {
 	return params.provider.trim().toLowerCase() === "openai" && params.api === "openai-responses" && isOfficialOpenAIResponsesBaseUrl(params.baseUrl);
@@ -853,7 +629,8 @@ function scheduleSessionWebSocketExpiry(cacheKey, entry) {
 function prepareWebSocketConnection(client, headers) {
 	if (!isOfficialOpenAIResponsesBaseUrl(client.baseURL)) throw new Error("OpenAI Responses WebSocket requires the official API endpoint");
 	if (typeof client.apiKey !== "string" || client.apiKey.length === 0) throw new Error("OpenAI Responses WebSocket requires an API key");
-	const resolvedApiKey = getAiTransportHost().resolveSecretSentinel(client.apiKey);
+	const owner = getAiTransportHost();
+	const resolvedApiKey = owner.resolveSecretSentinel(client.apiKey);
 	const resolvedHeaders = { ...resolveAiTransportHeaderSentinels(headers) };
 	for (const key of Object.keys(resolvedHeaders)) {
 		const normalizedKey = key.toLowerCase();
@@ -863,6 +640,8 @@ function prepareWebSocketConnection(client, headers) {
 	return {
 		client: client.withOptions({ apiKey: resolvedApiKey }),
 		headers: resolvedHeaders,
+		owner,
+		ownerId: getSessionResourceOwnerId(owner),
 		identity: sha256Hex(JSON.stringify([
 			resolvedApiKey,
 			client.baseURL,
@@ -909,7 +688,7 @@ function createCachedWebSocketLease(cacheKey, entry, reusedConnection) {
 }
 function acquireWebSocket(params, connection) {
 	if (!(params.mode !== "websocket" && Boolean(params.sessionId)) || !params.sessionId) return createTransientWebSocketLease(connection);
-	const cacheKey = `${params.sessionId}\0${connection.identity}`;
+	const cacheKey = `${connection.ownerId}\0${params.sessionId}\0${connection.identity}`;
 	const cached = websocketSessionCache.get(cacheKey);
 	if (cached) {
 		if (cached.idleTimer) {
@@ -928,6 +707,7 @@ function acquireWebSocket(params, connection) {
 			else closeWebSocketSilently(failedSocket, "transport_error");
 		}),
 		sessionId: params.sessionId,
+		owner: connection.owner,
 		busy: true,
 		createdAt: Date.now()
 	};
@@ -939,17 +719,8 @@ function sanitizeWebSocketRequest(request) {
 	return websocketRequest;
 }
 async function nextWebSocketMessage(iterator, signal) {
-	if (!signal) return iterator.next();
-	if (signal.aborted) throw transportAbortError(signal);
-	let onAbort;
-	try {
-		return await Promise.race([iterator.next(), new Promise((_resolve, reject) => {
-			onAbort = () => reject(transportAbortError(signal));
-			signal.addEventListener("abort", onAbort, { once: true });
-		})]);
-	} finally {
-		if (onAbort) signal.removeEventListener("abort", onAbort);
-	}
+	if (signal?.aborted) throw transportAbortError(signal);
+	return await racePromiseWithAbortSignal(iterator.next(), signal, transportAbortError);
 }
 function readServerEvent(message) {
 	if (message.type === "message") return message.message;
@@ -960,17 +731,24 @@ function createOpenAIResponsesWebSocketStream(params) {
 	const connection = prepareWebSocketConnection(params.client, params.headers);
 	let fullRequest = sanitizeWebSocketRequest(params.request);
 	const requestModel = typeof fullRequest.model === "string" ? fullRequest.model : "";
-	const degradationKey = `${params.sessionId ?? ""}\0${connection.identity}\0${requestModel}`;
+	const degradationKey = `${connection.ownerId}\0${params.sessionId ?? ""}\0${connection.identity}\0${requestModel}`;
 	const degraded = degradedWebSocketConnections.get(degradationKey);
 	if (degraded && degraded.retryAt > Date.now()) throw new OpenAIResponsesWebSocketPreDispatchError(/* @__PURE__ */ new Error("OpenAI Responses WebSocket is cooling down after a transport failure"));
+	if (degraded) clearTimeout(degraded.expiryTimer);
 	degradedWebSocketConnections.delete(degradationKey);
 	const markDegraded = () => {
 		const cooldownMs = params.degradeCooldownMs;
 		if (cooldownMs === void 0 || !Number.isFinite(cooldownMs) || cooldownMs <= 0) return;
-		degradedWebSocketConnections.set(degradationKey, {
+		const entry = {
 			sessionId: params.sessionId,
-			retryAt: Date.now() + cooldownMs
-		});
+			owner: connection.owner,
+			retryAt: Date.now() + cooldownMs,
+			expiryTimer: setTimeout(() => {
+				if (degradedWebSocketConnections.get(degradationKey) === entry) degradedWebSocketConnections.delete(degradationKey);
+			}, cooldownMs)
+		};
+		entry.expiryTimer.unref?.();
+		degradedWebSocketConnections.set(degradationKey, entry);
 	};
 	let lease;
 	try {
@@ -1164,12 +942,15 @@ function createOpenAIResponsesWebSocketStream(params) {
 		finish
 	};
 }
-function closeOpenAIResponsesWebSocketSessions(sessionId) {
+function closeOpenAIResponsesWebSocketSessions(sessionId, owner) {
 	for (const [cacheKey, entry] of websocketSessionCache) {
-		if (sessionId && entry.sessionId !== sessionId) continue;
+		if (owner && entry.owner !== owner || sessionId && entry.sessionId !== sessionId) continue;
 		invalidateOwnedWebSocketSession(cacheKey, entry, "session_cleanup");
 	}
-	for (const [key, entry] of degradedWebSocketConnections) if (!sessionId || entry.sessionId === sessionId) degradedWebSocketConnections.delete(key);
+	for (const [key, entry] of degradedWebSocketConnections) if ((!owner || entry.owner === owner) && (!sessionId || entry.sessionId === sessionId)) {
+		clearTimeout(entry.expiryTimer);
+		degradedWebSocketConnections.delete(key);
+	}
 }
 registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
 //#endregion
@@ -1238,10 +1019,6 @@ async function requestPreparedOpenAIResponsesCompaction(streamFn, model, context
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-reasoning-state.ts
-function inputReplay(message) {
-	const value = "openclawResponsesInputReplay" in message ? message.openclawResponsesInputReplay : void 0;
-	return isRecord(value) ? value : void 0;
-}
 /** Save only admitted settings and hashes, never another copy of the conversation. */
 function recordResponsesReasoningState(message, model, identity, request, output) {
 	if (!supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || message.providerReplay || output.some((item) => isRecord(item) && item.type === "compaction")) return;
@@ -1258,17 +1035,17 @@ function recordResponsesReasoningState(message, model, identity, request, output
 		requestHash: responsesContinuationRequestFingerprint(request)
 	};
 	Object.assign(message, { openclawResponsesInputReplay: {
-		...inputReplay(message),
+		...readResponsesInputReplayState(message),
 		reasoning
 	} });
 }
 /** A cold transport can replay controls, but cannot resurrect a server response handle. */
 function restoreResponsesReasoningState(context, model, identity, request) {
 	const latest = context.messages.findLast((message) => message.role === "assistant");
-	const state = latest ? inputReplay(latest)?.reasoning : void 0;
+	const state = latest ? readResponsesInputReplayState(latest)?.reasoning : void 0;
 	if (!isRecord(state)) return request;
 	const { effort, inputLength, outputLength, controls, prefixHash, requestHash } = state;
-	if (!isOpenAIResponsesReplayContext(state) || !providerReplayContextMatches(state, buildProviderReplayContext(model, identity)) || latest?.providerReplay || !supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || request.input.some(isConfigurationUpdate) || typeof effort !== "string" || typeof inputLength !== "number" || !Number.isSafeInteger(inputLength) || inputLength < 0 || typeof outputLength !== "number" || !Number.isSafeInteger(outputLength) || outputLength < 0 || !Array.isArray(controls) || controls.length > inputLength || inputLength + outputLength > request.input.length + controls.length) return request;
+	if (!isProviderReplayContext(state) || !providerReplayContextMatches(state, buildProviderReplayContext(model, identity)) || latest?.providerReplay || !supportsResponsesReasoningUpdate(request) || !isRecord(request.reasoning) || !request.input || request.previous_response_id || request.input.some(isConfigurationUpdate) || typeof effort !== "string" || typeof inputLength !== "number" || !Number.isSafeInteger(inputLength) || inputLength < 0 || typeof outputLength !== "number" || !Number.isSafeInteger(outputLength) || outputLength < 0 || !Array.isArray(controls) || controls.length > inputLength || inputLength + outputLength > request.input.length + controls.length) return request;
 	const previousInput = request.input.slice(0, inputLength - controls.length);
 	let lastIndex = -1;
 	for (const control of controls) {
@@ -1324,11 +1101,7 @@ function createResponsesRequestFetch(model, options) {
 function resolveNativeOpenAIResponsesWebSocketMode(model, transport) {
 	if (transport !== "websocket" && transport !== "websocket-cached" && transport !== "auto") return;
 	if (getAiTransportHost().requiresManagedTransport(model)) return;
-	return supportsNativeOpenAIResponsesEndpoint({
-		provider: model.provider,
-		api: model.api,
-		baseUrl: model.baseUrl
-	}) ? transport : void 0;
+	return supportsNativeOpenAIResponsesEndpoint(model) ? transport : void 0;
 }
 function combineWebSocketTimeoutSignal(signal, model, timeoutMs) {
 	const resolvedTimeoutMs = timeoutMs !== void 0 && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : getAiTransportHost().resolveModelRequestTimeoutMs(model);
@@ -1384,7 +1157,7 @@ function createResponsesTransportExecutor(config) {
 					if (nextParams !== void 0) params = nextParams;
 					params = sanitizeOpenAICodexResponsesParams(model, params);
 					params = sanitizeResponsesImagePayload(params);
-					if (options?.openclawCodeModeToolSurface === true) {
+					if (responsesOptions?.openclawCodeModeToolSurface === true) {
 						const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
 						const allowedHostedToolTypes = responsesOptions?.openclawCodeModeAllowedHostedToolTypes;
 						enforceCodeModeResponsesToolSurface(params, visibleToolNames, allowedHostedToolTypes, codeModeToolSurfaceObserver.get(options));
@@ -1418,11 +1191,7 @@ function createResponsesTransportExecutor(config) {
 					return;
 				}
 				const sessionId = options?.sessionId;
-				if (config.httpContinuation && !websocketMode && !getAiTransportHost().requiresManagedTransport(model) && (supportsNativeOpenAIResponsesEndpoint({
-					provider: model.provider,
-					api: model.api,
-					baseUrl: model.baseUrl
-				}) || resolveOpenAIResponsesPayloadPolicy(model).explicitContinuationOptIn) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
+				if (config.httpContinuation && !websocketMode && !getAiTransportHost().requiresManagedTransport(model) && (supportsNativeOpenAIResponsesEndpoint(model) || resolveOpenAIResponsesPayloadPolicy(model).explicitContinuationOptIn) && sessionId && (params.store === true || supportsResponsesReasoningUpdate(params)) && !params.previous_response_id) {
 					continuationClaim = claimOpenAIResponsesHttpContinuation({
 						sessionId,
 						apiKey,
@@ -1457,6 +1226,7 @@ function createResponsesTransportExecutor(config) {
 				let continuationBaseline;
 				let dispatchedPreviousResponseId;
 				let contextUsageEligible = true;
+				let requestedTier;
 				const createSseStream = async (initialRequest = continuationClaim?.request ?? params, initialAttemptKind = "initial", initialRejectedCompaction) => {
 					const { stream: responseStream } = await createResponsesStreamWithEncryptedContentRetry({
 						client,
@@ -1471,6 +1241,7 @@ function createResponsesTransportExecutor(config) {
 						onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, responsesOptions, checkpoint),
 						canRetryStream: () => output.content.length === 0,
 						wrapStream: ({ stream: rawResponseStream, response, attempt }) => {
+							requestedTier = attempt.request.service_tier;
 							contextUsageEligible &&= attempt.kind === "initial";
 							dispatchedPreviousResponseId = attempt.request.previous_response_id;
 							continuationBaseline = attempt.request.previous_response_id ? params : attempt.request;
@@ -1521,6 +1292,7 @@ function createResponsesTransportExecutor(config) {
 						}
 					});
 					finishWebSocket = websocket.finish;
+					requestedTier = websocket.request.service_tier;
 					websocketBaseline = websocket.fullRequest;
 					recordResponsesInputReplay(output, websocket.inputReplay);
 					contextUsageEligible &&= websocket.inputReplay === void 0;
@@ -1577,6 +1349,7 @@ function createResponsesTransportExecutor(config) {
 					const terminal = await processResponsesStream(acceptedResponseStream, output, stream, model, {
 						canRetryIdentityConflict: () => hasOnlyResponsesFunctionTools(transport === "websocket" ? websocketBaseline : continuationBaseline),
 						...config.pricingOptions?.(responsesOptions, model),
+						onServiceTier: (responseTier) => responsesServiceTierObserver.observe(options, requestedTier, responseTier),
 						firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options) ?? config.firstEventTimeoutMs,
 						abortFirstEventStream: firstEvent.abort,
 						onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
@@ -1618,7 +1391,8 @@ function createResponsesTransportExecutor(config) {
 					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));
+				const incompleteReason = output.diagnostics?.find(({ type }) => type === "openai_responses_terminal")?.details?.incompleteReason;
+				log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error) + (typeof incompleteReason === "string" ? ` incompleteReason=${incompleteReason}` : ""));
 				failTransportStream({
 					stream,
 					output,
@@ -1651,7 +1425,10 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
 		createClient: createAzureOpenAIClient,
 		buildRequest: (model, context, options, metadata, replayMode) => {
-			const deploymentName = resolveAzureDeploymentName(model);
+			const deploymentName = resolveAzureDeploymentNameFromMap({
+				modelId: model.id,
+				deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
+			});
 			const params = buildOpenAIResponsesParams(model, context, options, metadata, replayMode);
 			params.model = deploymentName;
 			delete params.store;
@@ -1659,12 +1436,6 @@ function createAzureOpenAIResponsesTransportStreamFn() {
 		}
 	});
 }
-function resolveAzureDeploymentName(model) {
-	return resolveAzureDeploymentNameFromMap({
-		modelId: model.id,
-		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
-	});
-}
 function createAzureOpenAIClient(model, apiKey, defaultHeaders, fetchOverride) {
 	const baseURL = model.baseUrl.replace(/\/+$/, "");
 	const clientOptions = {
@@ -1682,6 +1453,20 @@ function createAzureOpenAIClient(model, apiKey, defaultHeaders, fetchOverride) {
 	});
 }
 //#endregion
+//#region packages/ai/src/transports/provider-compaction-checkpoint.ts
+/** 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" || type === "openai-responses-retained-compaction";
+}
+/** Strip prefix-bound checkpoints after local history rewrites. */
+function stripCompactionReplayCheckpoint(message) {
+	if (!isCompactionReplayCheckpoint(message.providerReplay)) return message;
+	const replaySafeMessage = { ...message };
+	delete replaySafeMessage.providerReplay;
+	return replaySafeMessage;
+}
+//#endregion
 //#region packages/ai/src/transports/provider-compaction-replay.ts
 function isAssistantReplayMessage(message) {
 	return message.role === "assistant";
@@ -1809,23 +1594,11 @@ function resolveCompactionReplayPressure(messages, model, identity, estimate, sy
 		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" || type === "openai-responses-retained-compaction";
-}
-/** Strip prefix-bound checkpoints after local history rewrites. */
-function stripCompactionReplayCheckpoint(message) {
-	if (!isCompactionReplayCheckpoint(message.providerReplay)) return message;
-	const replaySafeMessage = { ...message };
-	delete replaySafeMessage.providerReplay;
-	return replaySafeMessage;
-}
 /** Strip prefix-bound checkpoint state from an in-place message rewrite. */
 function stripCompactionReplayCheckpointInPlace(message) {
 	if (isCompactionReplayCheckpoint(message.providerReplay)) delete message.providerReplay;
 }
-/** Reindex a prefix-bound checkpoint after known content removals. */
+/** Preserve the covered prefix and reindex checkpoints after known content removals. */
 function replaceCompactionReplayOwnerContent(message, content) {
 	const next = {
 		...message,
@@ -1836,6 +1609,7 @@ function replaceCompactionReplayOwnerContent(message, content) {
 	if (replay.type === "openai-responses-retained-compaction") return next;
 	const replayIndex = replay.replayIndex ?? 0;
 	if (content.length === 0 && message.content.length > 0 || replayIndex > message.content.length) return stripCompactionReplayCheckpoint(next);
+	if (content.length === message.content.length && content.slice(0, replayIndex).every((block, index) => block === message.content[index])) return next;
 	let sourceIndex = 0;
 	let nextReplayIndex = 0;
 	if (!content.every((block) => {
@@ -1915,13 +1689,6 @@ function createTransportAwareStreamFnForModel(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) {
-	return createSupportedTransportStreamFn(model, ctx);
-}
-function createBoundaryAwareStreamFnForModel(model, ctx) {
-	return createSupportedTransportStreamFn(model, ctx);
-}
 function prepareTransportAwareSimpleModel(model, ctx) {
 	const streamFn = createTransportAwareStreamFnForModel(model, ctx);
 	const alias = resolveTransportAwareSimpleApi(model.api);
@@ -1931,16 +1698,8 @@ function prepareTransportAwareSimpleModel(model, ctx) {
 		api: alias
 	});
 }
-function buildTransportAwareSimpleStreamFn(model, ctx) {
-	return createTransportAwareStreamFnForModel(model, ctx);
-}
 //#endregion
 //#region packages/ai/src/transports/simple-completion-transport.ts
-/**
-* Simple completion transport preparation.
-*
-* Registers provider-specific stream functions and rewrites models that need OpenClaw-managed transport semantics.
-*/
 /** Standalone completions have no durable session, but may require routing identity. */
 function prepareHeadersForSimpleCompletion(model, options) {
 	return resolveOpencodeSessionHeaders(model, {
@@ -1966,32 +1725,29 @@ function resolveAnthropicVertexSimpleApi(baseUrl) {
 }
 function normalizeCodexResponsesBaseUrlForOpenAISdk(baseUrl) {
 	const normalized = baseUrl?.trim() || "https://chatgpt.com/backend-api";
-	try {
-		const parsed = new URL(normalized);
-		const pathname = parsed.pathname.replace(/\/+$/u, "");
-		const path = pathname.toLowerCase();
-		if (parsed.hostname.toLowerCase() === "chatgpt.com" && [
-			"/backend-api",
-			"/backend-api/v1",
-			"/backend-api/codex",
-			"/backend-api/codex/v1",
-			"/backend-api/codex/responses"
-		].includes(path)) {
-			parsed.pathname = "/backend-api/codex";
-			parsed.search = "";
-			parsed.hash = "";
-			return parsed.toString().replace(/\/$/u, "");
-		}
-		if (normalized.includes("?") || normalized.includes("#")) throw new Error(INVALID_CODEX_BASE_URL_MESSAGE);
+	const parsed = URL.parse(normalized);
+	const pathname = parsed?.pathname.replace(/\/+$/u, "") ?? "";
+	const path = pathname.toLowerCase();
+	if (parsed?.hostname.toLowerCase() === "chatgpt.com" && [
+		"/backend-api",
+		"/backend-api/v1",
+		"/backend-api/codex",
+		"/backend-api/codex/v1",
+		"/backend-api/codex/responses"
+	].includes(path)) {
+		parsed.pathname = "/backend-api/codex";
+		parsed.search = "";
+		parsed.hash = "";
+		return parsed.toString().replace(/\/$/u, "");
+	}
+	if (normalized.includes("?") || normalized.includes("#")) throw new Error(INVALID_CODEX_BASE_URL_MESSAGE);
+	if (parsed) {
 		parsed.pathname = path.endsWith("/codex/responses") ? pathname.slice(0, -10) : path.endsWith("/codex") ? pathname : `${pathname}/codex`;
 		return parsed.toString();
-	} catch (error) {
-		if (error instanceof Error && error.message === INVALID_CODEX_BASE_URL_MESSAGE) throw error;
 	}
-	if (normalized.includes("?") || normalized.includes("#")) throw new Error(INVALID_CODEX_BASE_URL_MESSAGE);
-	const path = normalized.replace(/\/+$/u, "");
-	if (path.endsWith("/codex/responses")) return path.slice(0, -10);
-	return path.endsWith("/codex") ? path : `${path}/codex`;
+	const customPath = normalized.replace(/\/+$/u, "");
+	if (customPath.endsWith("/codex/responses")) return customPath.slice(0, -10);
+	return customPath.endsWith("/codex") ? customPath : `${customPath}/codex`;
 }
 function resolveProviderSimpleCompletionApi(model, auth, agentId) {
 	const parts = [
@@ -2042,7 +1798,7 @@ function prepareCodexSimpleTransportModel(registry, model, cfg) {
 	if (model.provider !== "openai" || model.api !== "openai-chatgpt-responses") return;
 	const transportModel = projectModel(model, { baseUrl: normalizeCodexResponsesBaseUrlForOpenAISdk(model.baseUrl) });
 	const api = resolveTransportAwareSimpleApi(model.api);
-	const streamFn = createOpenClawTransportStreamFnForModel(transportModel, { cfg });
+	const streamFn = createSupportedTransportStreamFn(transportModel, { cfg });
 	if (!api || !streamFn) return;
 	if (!registerCustomApi(registry, api, streamFn)) return;
 	return projectModel(transportModel, { api });
@@ -2099,7 +1855,7 @@ function prepareModelForSimpleCompletion(params) {
 	if (codexTransportModel) return wrap(codexTransportModel);
 	const transportAwareModel = prepareTransportAwareSimpleModel(model, { cfg });
 	if (transportAwareModel !== model) {
-		const streamFn = buildTransportAwareSimpleStreamFn(model, { cfg });
+		const streamFn = createTransportAwareStreamFnForModel(model, { cfg });
 		if (streamFn && registerCustomApi(apiRegistry, transportAwareModel.api, streamFn)) return wrap(transportAwareModel);
 	}
 	if (model.provider === "anthropic-vertex") {
@@ -2109,4 +1865,4 @@ function prepareModelForSimpleCompletion(params) {
 	return wrap(model);
 }
 //#endregion
-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 };
+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, createTransportAwareStreamFnForModel as buildTransportAwareSimpleStreamFn, createTransportAwareStreamFnForModel, canonicalizeMaxTokensParam, captureOpenAIResponsesCompaction, coerceTransportToolCallArguments, consumeGoogleGenerateContentStream, convertGoogleTools, copyProviderAcceptanceObserver, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createSupportedTransportStreamFn as createBoundaryAwareStreamFnForModel, createSupportedTransportStreamFn as createOpenClawTransportStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIProviderAcceptanceHook, createOpenAIResponseHook, createOpenAIResponsesTransportStreamFn, createResponseModelTracker, 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, supportsAnthropicServerSideFallback, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };