@openclaw/ai 2026.9.2 → 2026.9.3

package/dist/transport-utils-CCooe-cr.mjs

@@ -0,0 +1,121 @@
+import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { o as parseStrictPositiveInteger } from "./base64-D-su8YVo.mjs";
+import "./internal/retry-after.mjs";
+//#region packages/normalization-core/src/response-bytes.ts
+async function consumeResponseBytes(options) {
+	let size = 0;
+	while (true) {
+		const { done, value } = await options.read();
+		if (done) return {
+			size,
+			truncated: false
+		};
+		if (options.skipEmptyChunks !== false && !value?.length) continue;
+		const remaining = options.maxBytes - size;
+		size += value.length;
+		if (size > options.maxBytes || options.stopAtLimit && size === options.maxBytes) {
+			if (remaining > 0) options.onChunk(value.subarray(0, remaining));
+			await options.onLimit(size);
+			return {
+				size,
+				truncated: true
+			};
+		}
+		options.onChunk(value);
+	}
+}
+//#endregion
+//#region packages/ai/src/transports/transport-utils.ts
+const MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE = "OpenClaw transport error: malformed_streaming_fragment";
+const NON_LATIN_RE = /[\u2E80-\u9FFF\uA000-\uA4FF\uAC00-\uD7AF\uF900-\uFAFF\uFF01-\uFF60\uFFE0-\uFFE6\u{20000}-\u{2FA1F}]/gu;
+const CJK_SURROGATE_HIGH_RE = /[\uD840-\uD87E][\uDC00-\uDFFF]/g;
+function parsePositiveInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	return typeof value === "string" ? parseStrictPositiveInteger(value) : void 0;
+}
+function redactSensitiveText(text, _options) {
+	return getAiTransportHost().redactToolPayloadText(text);
+}
+function resolveModelHeaderSentinels(model) {
+	if (!model.headers) return model;
+	let headers;
+	for (const [name, value] of Object.entries(model.headers)) {
+		const resolved = getAiTransportHost().resolveSecretSentinel(value);
+		if (resolved !== value) {
+			headers ??= { ...model.headers };
+			headers[name] = resolved;
+		}
+	}
+	return headers ? {
+		...model,
+		headers
+	} : model;
+}
+function createAbortError(message, options) {
+	const error = new Error(message, options);
+	error.name = "AbortError";
+	return error;
+}
+function estimateStringChars(text) {
+	if (!text) return 0;
+	const nonLatinCount = (text.match(NON_LATIN_RE) ?? []).length;
+	return (nonLatinCount === 0 ? text.length : text.length - (text.match(CJK_SURROGATE_HIGH_RE) ?? []).length) + nonLatinCount * 3;
+}
+function supportsModelTools(model) {
+	return (model.compat && typeof model.compat === "object" ? model.compat : void 0)?.supportsTools !== false;
+}
+function isCodeModeModelVisibleToolName(name, visibleToolNames) {
+	return visibleToolNames.has(name);
+}
+async function readChunkWithIdleTimeout(reader, timeoutMs, onIdleTimeout) {
+	let timer;
+	try {
+		return await Promise.race([reader.read(), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(onIdleTimeout?.({ chunkTimeoutMs: timeoutMs }) ?? /* @__PURE__ */ new Error("Read timed out")), timeoutMs);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+async function readResponseTextSnippet(response, options) {
+	const maxBytes = options?.maxBytes ?? 8192;
+	const maxChars = options?.maxChars ?? 200;
+	const reader = response.body?.getReader();
+	if (!reader) return;
+	const chunks = [];
+	let bytes = 0;
+	let truncated = false;
+	try {
+		if (bytes < maxBytes) {
+			const result = await consumeResponseBytes({
+				maxBytes,
+				stopAtLimit: true,
+				read: () => options?.chunkTimeoutMs ? readChunkWithIdleTimeout(reader, options.chunkTimeoutMs, options.onIdleTimeout) : reader.read(),
+				onChunk: (chunk) => chunks.push(chunk),
+				onLimit: async () => {
+					await reader.cancel().catch(() => void 0);
+				}
+			});
+			bytes = Math.min(result.size, maxBytes);
+			truncated = result.truncated;
+		}
+	} catch (error) {
+		await reader.cancel(error).catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.length;
+	}
+	const collapsed = new TextDecoder().decode(merged).replace(/\s+/g, " ").trim();
+	if (!collapsed) return;
+	if (collapsed.length > maxChars) return `${truncateUtf16Safe(collapsed, maxChars)}…`;
+	return truncated ? `${collapsed}…` : collapsed;
+}
+//#endregion
+export { parsePositiveInteger as a, resolveModelHeaderSentinels as c, isCodeModeModelVisibleToolName as i, supportsModelTools as l, createAbortError as n, readResponseTextSnippet as o, estimateStringChars as r, redactSensitiveText as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t };

package/dist/transports.d.mts

@@ -1,15 +1,20 @@
-import "./index-FnHM2FcI.mjs";
-import { D as Model, K as StreamFn, Q as ThinkingContent, Y as TextContent, a as AssistantMessage, at as Usage, d as Context, j as OpenAICompletionsCompat, n as Api, nt as ToolCall, o as AssistantMessageEvent, z as ProviderReplayState } from "./types-CJ1-Ht7A.mjs";
-import { n as ApiRegistry } from "./api-registry-DWtPjzyn.mjs";
-import { a as BaseOpenAIStreamOptions, c as OpenAIResponsesCompactionRejection, f as OpenAIToolProjection, o as CodeModeToolSurfaceObservation, s as OpenAICompletionsOptions } from "./provider-options-Bcc_p-TU.mjs";
-import "./types-3Lnm-QSJ.mjs";
-import { a as isAnthropicServerToolClearingEnabled, c as resolveAnthropicContextManagementBetaHeader, d as resolveAnthropicServerCompactionPlan, i as applyAnthropicPayloadPolicyToParams, l as resolveAnthropicEphemeralCacheControl, n as applyAnthropicContextManagementToRequest, o as isDirectAnthropicModel, r as applyAnthropicEphemeralCacheControlMarkers, s as logAnthropicContextEdits, t as applyAnthropicCacheControlToMessages, u as resolveAnthropicPayloadPolicy } from "./anthropic-payload-policy-d46X2pR0.mjs";
-import { a as ReplayableResponseCompactionItem, c as OpenAIResponsesCompactionOutput, i as OpenAIResponsesRequestParams, n as OpenAIResponsesOptions, o as ResponsesPromptObservation, r as OpenAIResponsesReasoningReplayMetadata } from "./openai-responses-contracts-rF5DDRNS.mjs";
+import "./index-CQ6LTHw8.mjs";
+import { D as Model, G as StopReason, K as StreamFn, Q as ThinkingContent, Y as TextContent, a as AssistantMessage, at as Usage, d as Context, j as OpenAICompletionsCompat, lt as ModelDataThinkingFormat, n as Api, nt as ToolCall, o as AssistantMessageEvent, tt as Tool, z as ProviderReplayState } from "./types-Dy1q0CSu.mjs";
+import { n as ApiRegistry } from "./api-registry-CB1-1oQ2.mjs";
+import { a as BaseOpenAIStreamOptions, c as OpenAIResponsesCompactionRejection, o as CodeModeToolSurfaceObservation, s as OpenAICompletionsOptions } from "./provider-options-BXr9Ec83.mjs";
+import { n as OpenAIToolProjection } from "./openai-tool-projection-793cE3QX.mjs";
+import "./types-BADKjDBI.mjs";
+import { a as buildAnthropicSystemBlocks, c as logAnthropicContextEdits, d as resolveAnthropicEphemeralCacheControl, f as resolveAnthropicPayloadPolicy, i as applyAnthropicRequestCacheControl, l as resolveAnthropicCacheOptions, n as applyAnthropicEphemeralCacheControlMarkers, o as isAnthropicServerToolClearingEnabled, p as resolveAnthropicServerCompactionPlan, r as applyAnthropicPayloadPolicyToParams, s as isDirectAnthropicModel, t as applyAnthropicContextManagementToRequest, u as resolveAnthropicContextManagementBetaHeader } from "./anthropic-payload-policy-wuRCb6MH.mjs";
+import { a as ReplayableResponseCompactionItem, c as OpenAIResponsesCompactionOutput, i as OpenAIResponsesRequestParams, n as OpenAIResponsesOptions, o as ResponsesPromptObservation, r as OpenAIResponsesReasoningReplayMetadata } from "./openai-responses-contracts-B55afwRo.mjs";
 import { i as resolveOpenAIResponsesServerCompactionPlan, n as resolveOpenAIResponsesCompactEndpointPlan, r as resolveOpenAIResponsesPayloadPolicy, t as applyOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy-rLRPsSmB.mjs";
-import { n as detectOpenAICompletionsCompat, r as resolveOpenAICompletionsCompat, t as ResolvedOpenAICompletionsCompat } from "./openai-completions-compat-CpjYUArk.mjs";
-import { C as FirstStreamEventInternalOptions, _ as sanitizeNonEmptyTransportPayloadText, a as copyProviderAcceptanceObserver, b as withProviderAcceptanceObserver, c as failTransportStream, d as mergeTransportHeaders, f as mergeTransportMetadata, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, i as coerceTransportToolCallArguments, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as WritableTransportStream, o as createEmptyTransportUsage, p as notifyProviderHttpMetadata, r as assignTransportErrorDetails, s as createWritableTransportEventStream, t as ProviderAcceptance, u as finalizeTransportStream, v as sanitizeTransportPayloadText, x as withProviderResponseHook, y as transportAbortError } from "./transport-stream-shared-xnaqxmbP.mjs";
+import { a as resolveOpenAICompletionsCompat, i as isOpenAICodexResponsesModel, n as detectOpenAICompletionsCompat, o as resolveOpenAIPromptCacheKeySupport, r as isNativeOpenAIEndpoint, s as usesNativeOpenAICodexResponsesBackend, t as ResolvedOpenAICompletionsCompat } from "./openai-completions-compat-CXn3T1we.mjs";
+import { C as FirstStreamEventInternalOptions, _ as sanitizeNonEmptyTransportPayloadText, a as copyProviderAcceptanceObserver, b as withProviderAcceptanceObserver, c as failTransportStream, d as mergeTransportHeaders, f as mergeTransportMetadata, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, i as coerceTransportToolCallArguments, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as WritableTransportStream, o as createEmptyTransportUsage, p as notifyProviderHttpMetadata, r as assignTransportErrorDetails, s as createWritableTransportEventStream, t as ProviderAcceptance, u as finalizeTransportStream, v as sanitizeTransportPayloadText, x as withProviderResponseHook, y as transportAbortError } from "./transport-stream-shared-DOxpGJ-H.mjs";
 import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-Cwcjv_fx.mjs";
+import { r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-ynZBgqW-.mjs";
+import { d as VideoContent, i as ProviderContext, s as ProviderModel } from "./provider-types-CAV0Og3m.mjs";
+import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./model-transport-url-DKocrEsb.mjs";
 import OpenAI from "openai";
+import { Part } from "@google/genai";
 import { ResponseCreateParamsStreaming, ResponseInput, ResponseInputItem as ResponseInputItem$1 } from "openai/resources/responses/responses.js";
 import { ChatCompletionChunk } from "openai/resources/chat/completions.js";
 //#region packages/ai/src/transports/anthropic-transport-stream.d.ts
@@ -52,37 +57,18 @@ export declare function canonicalizeMaxTokensParam(params: {
   sources: Array<Record<string, unknown> | undefined>;
 }): void;
 //#endregion
-//#region packages/ai/src/transports/model-transport-debug.d.ts
-type SubsystemLogger = {
-  info(message: string): void;
-  debug(message: string): void;
-};
-type ModelTransportDebugEnv = NodeJS.ProcessEnv;
-/** Payload debug detail levels accepted by `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
-type ModelPayloadDebugMode = "off" | "summary" | "tools" | "full-redacted";
-/** SSE debug detail levels accepted by `OPENCLAW_DEBUG_SSE`. */
-type ModelSseDebugMode = "off" | "events" | "peek";
-/** Resolves model payload debug verbosity from `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
-export declare function resolveModelPayloadDebugMode(env?: ModelTransportDebugEnv): ModelPayloadDebugMode;
-/** Resolves SSE stream debug verbosity from `OPENCLAW_DEBUG_SSE`. */
-export declare function resolveModelSseDebugMode(env?: ModelTransportDebugEnv): ModelSseDebugMode;
-/** Emits model-fetch metadata at info level by default; other diagnostics require debug env. */
-export declare function emitModelTransportDebug(log: SubsystemLogger, message: string): void;
-//#endregion
-//#region packages/ai/src/transports/model-transport-url.d.ts
-/**
- * Debug formatting helpers for model transport endpoints.
- * Keeps logs useful without exposing credentials, request params, or fragments.
- */
-/** Return a sanitized URL suitable for logs and diagnostics. */
-export declare function formatModelTransportDebugUrl(rawUrl: string): string;
-/** Format a configured base URL for debug output, or the implicit default. */
-export declare function formatModelTransportDebugBaseUrl(rawUrl: string | undefined): string;
-//#endregion
 //#region packages/ai/src/transports/openai-compatible-conversation-turn.d.ts
 /** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
 export declare function hasOpenAICompatibleConversationTurn(messages: unknown): boolean;
 //#endregion
+//#region packages/ai/src/transports/openai-completions-cache-control.d.ts
+type CacheControl = {
+  type: "ephemeral";
+  ttl?: "1h" | "5m";
+};
+/** Shared Chat Completions policy; repeated wrapper application preserves existing checkpoints. */
+export declare function applyCompletionsAnthropicCacheControl(payload: Record<string, unknown>, cacheControl?: CacheControl | null, cacheOptOutIndexes?: ReadonlySet<number>, markTools?: boolean, markMessages?: boolean): void;
+//#endregion
 //#region packages/ai/src/transports/openai-completions-string-content.d.ts
 /** Flatten string-only text block content arrays into newline-joined strings. */
 export declare function flattenCompletionMessagesToStringContent(messages: unknown[]): unknown[];
@@ -160,7 +146,25 @@ export declare function isOpenAICompletionsThinkingEnabled(effort: string): bool
 export declare function readOpenAICompletionsContentDeltas(content: unknown, topLevelRefusal?: unknown, mirroredThinking?: readonly string[]): OpenAICompletionsContentDelta[];
 //#endregion
 //#region packages/ai/src/transports/openai-completions-params.d.ts
-export declare function buildOpenAICompletionsParams(model: OpenAIModeModel, context: Context, options: OpenAICompletionsOptions | undefined): Record<string, unknown>;
+declare function convertTools(tools: NonNullable<Context["tools"]>, compat: ResolvedOpenAICompletionsCompat, model: OpenAIModeModel, mode: "direct" | "managed"): {
+  projection: OpenAIToolProjection;
+  tools: {
+    type: "function";
+    function: {
+      name: string;
+      description: string | undefined;
+      parameters: ReturnType<typeof normalizeOpenAIStrictToolParameters>;
+      strict?: boolean;
+    };
+  }[];
+};
+export declare function buildOpenAICompletionsParams(model: OpenAIModeModel, context: Context, options: OpenAICompletionsOptions | undefined): CompletionsRequest;
+type CompletionsRequest = Record<string, unknown> & {
+  model: string;
+  messages: unknown[];
+  stream: true;
+  tools?: ReturnType<typeof convertTools>["tools"];
+};
 //#endregion
 //#region packages/ai/src/transports/openai-completions-transport.d.ts
 export declare function createOpenAICompletionsTransportStreamFn(): StreamFn;
@@ -306,8 +310,6 @@ export declare function resolveOpenAIStrictToolFlagWithDiagnostics(projection: O
   transport: "responses" | "completions";
   model: OpenAIModeModel;
 }): boolean | undefined;
-export declare function isOpenAICodexResponsesModel(model: Model): boolean;
-export declare function usesNativeOpenAICodexResponsesBackend(model: Model): boolean;
 export declare function buildOpenAIClientHeaders(model: Model, context: Context, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>, sessionId?: string): Record<string, string>;
 export declare function buildOpenAISdkClientOptions(model: Model): {
   timeout?: number;
@@ -338,7 +340,7 @@ export declare function getCompat(model: OpenAIModeModel): {
   requiresAssistantAfterToolResult: boolean;
   requiresThinkingAsText: boolean;
   requiresReasoningContentOnAssistantMessages: boolean;
-  thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai" | "qwen" | "qwen-chat-template";
+  thinkingFormat: ModelDataThinkingFormat;
   zaiToolStream: boolean;
   supportsStrictMode: boolean;
   supportsJsonSchemaResponseFormat: boolean;
@@ -347,6 +349,7 @@ export declare function getCompat(model: OpenAIModeModel): {
   sessionAffinity: "openai" | "openrouter" | "none";
   visibleReasoningDetailTypes: string[];
   requiresNonEmptyUserOrAssistantMessage: boolean;
+  configuredSupportsLongCacheRetention?: boolean;
 };
 //#endregion
 //#region packages/ai/src/transports/openai-responses-compact-request.d.ts
@@ -470,4 +473,73 @@ export declare function prepareModelForSimpleCompletion<TApi extends Api>(params
 export declare const MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE = "OpenClaw transport error: malformed_streaming_fragment";
 export declare function isCodeModeModelVisibleToolName(name: string, visibleToolNames: ReadonlySet<string>): boolean;
 //#endregion
-export { type OpenAICompletionsOptions, type OpenAIResponsesCompactionRejection, ProviderAcceptance, ResolvedOpenAICompletionsCompat, WritableTransportStream, applyAnthropicCacheControlToMessages, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assignTransportErrorDetails, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createEmptyTransportUsage, createWritableTransportEventStream, detectOpenAICompletionsCompat, failTransportStream, finalizeTerminalToolCallArguments, finalizeTransportStream, isAnthropicServerToolClearingEnabled, isDirectAnthropicModel, logAnthropicContextEdits, mergeTransportHeaders, mergeTransportMetadata, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseTerminalToolCallArguments, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveOpenAICompletionsCompat, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, sanitizeNonEmptyTransportPayloadText, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, transportAbortError, withProviderAcceptanceObserver, withProviderResponseHook };
+//#region packages/ai/src/providers/google-stream.d.ts
+type GoogleStreamChunk = {
+  responseId?: string;
+  modelVersion?: string;
+  promptFeedback?: {
+    blockReason?: string;
+    blockReasonMessage?: string;
+  };
+  candidates?: Array<{
+    content?: {
+      parts?: Array<{
+        text?: string;
+        thought?: boolean;
+        thoughtSignature?: string;
+        functionCall?: {
+          id?: string;
+          name?: string;
+          args?: Record<string, unknown>;
+        };
+      }>;
+    };
+    finishReason?: string;
+    finishMessage?: string;
+  }>;
+  usageMetadata?: {
+    promptTokenCount?: number;
+    cachedContentTokenCount?: number;
+    candidatesTokenCount?: number;
+    thoughtsTokenCount?: number;
+    toolUsePromptTokenCount?: number;
+    totalTokenCount?: number;
+  };
+};
+/** @internal Directly tested provider implementation detail. */
+export declare function consumeGoogleGenerateContentStream(params: {
+  chunks: AsyncIterable<GoogleStreamChunk>;
+  model: Model;
+  output: AssistantMessage;
+  stream: WritableTransportStream;
+  signal?: AbortSignal;
+  nextToolCallId: (name: string | undefined) => string;
+  profile?: "sdk" | "managed";
+  normalizeModelId?: (id: string) => string;
+  resolveStopReason?: (reason: string) => StopReason;
+}): Promise<void>;
+//#endregion
+//#region packages/ai/src/providers/google-messages.d.ts
+type GoogleContentPart = Part & Record<string, unknown>;
+type GoogleContent = {
+  role: string;
+  parts: GoogleContentPart[];
+};
+export declare function requiresGoogleToolCallId(modelId: string): boolean;
+/** Project a prepared transcript; route repair and trusted video admission remain caller-owned. */
+export declare function projectGoogleMessages(params: {
+  model: Pick<ProviderModel, "id" | "api" | "provider" | "input">;
+  messages: ProviderContext["messages"];
+  replay: "signed-parts" | "managed";
+  requiresToolCallSignature: boolean;
+  videoPart?: (video: VideoContent) => GoogleContentPart;
+}): GoogleContent[];
+/**
+ * Convert tools to Gemini function declarations format.
+ * @internal Directly tested provider implementation detail.
+ */
+export declare function convertGoogleTools(tools: Tool[]): {
+  functionDeclarations: Record<string, unknown>[];
+}[] | undefined;
+//#endregion
+export { type GoogleStreamChunk, type OpenAICompletionsOptions, type OpenAIResponsesCompactionRejection, ProviderAcceptance, ResolvedOpenAICompletionsCompat, WritableTransportStream, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyOpenAIResponsesPayloadPolicy, assignTransportErrorDetails, buildAnthropicSystemBlocks, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createEmptyTransportUsage, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, failTransportStream, finalizeTerminalToolCallArguments, finalizeTransportStream, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, isAnthropicServerToolClearingEnabled, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, logAnthropicContextEdits, mergeTransportHeaders, mergeTransportMetadata, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseTerminalToolCallArguments, resolveAnthropicCacheOptions, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, sanitizeNonEmptyTransportPayloadText, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };