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

package/dist/stream-first-event-timeout-DvDeSucC.d.mts

@@ -0,0 +1,29 @@
+//#region packages/ai/src/utils/stream-first-event-timeout.d.ts
+type StreamStage = "responses" | "completions";
+type FirstStreamEventTimeoutContext = {
+  provider?: string;
+  api?: string;
+  model?: string;
+  timeoutMs: number;
+  stage?: StreamStage;
+  hint?: string;
+  abort?: (reason: Error) => void;
+  onTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventInternalOptions = {
+  firstEventTimeoutMs?: number;
+  abortFirstEventStream?: (reason: Error) => void;
+  onFirstEventTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventAbortController = {
+  signal: AbortSignal;
+  abort: (reason: Error) => void;
+  dispose: () => void;
+};
+declare function getFirstStreamEventTimeoutMs(options: unknown): number | undefined;
+declare function getFirstStreamEventTimeoutHandler(options: unknown): ((reason: Error) => void) | undefined;
+declare function createFirstStreamEventTimeoutError(context: FirstStreamEventTimeoutContext): Error;
+declare function createFirstStreamEventAbortController(parentSignal?: AbortSignal): FirstStreamEventAbortController;
+declare function withFirstStreamEventTimeout<T>(stream: AsyncIterable<T>, context: FirstStreamEventTimeoutContext): AsyncIterable<T>;
+//#endregion
+export { createFirstStreamEventTimeoutError as a, withFirstStreamEventTimeout as c, createFirstStreamEventAbortController as i, FirstStreamEventInternalOptions as n, getFirstStreamEventTimeoutHandler as o, FirstStreamEventTimeoutContext as r, getFirstStreamEventTimeoutMs as s, FirstStreamEventAbortController as t };

package/dist/transport-stream-shared-BbMELSI4.mjs

@@ -0,0 +1,297 @@
+import { r as createAssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { D as truncateUtf16Safe, b as normalizeOptionalString } from "./shared-CdjNZd35.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { i as parseStrictNonNegativeInteger, r as parseStrictFiniteNumber, t as asFiniteNumberInRange } from "./number-coercion-DvG7SNMg.mjs";
+import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
+import { createHash } from "node:crypto";
+//#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 sha256Hex(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function sha256HexPrefix(value, length) {
+	return sha256Hex(value).slice(0, length);
+}
+function redactIdentifier(value, opts) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return "-";
+	return `sha256:${sha256HexPrefix(trimmed, Number.isFinite(opts?.len) ? Math.max(1, Math.floor(opts?.len ?? 12)) : 12)}`;
+}
+function redactSensitiveText(text, _options) {
+	return getAiTransportHost().redactToolPayloadText(text);
+}
+function resolveSecretSentinel(value) {
+	return getAiTransportHost().resolveSecretSentinel(value);
+}
+function resolveModelHeaderSentinels(model) {
+	if (!model.headers) return model;
+	let headers;
+	for (const [name, value] of Object.entries(model.headers)) {
+		const resolved = 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) {
+	return name === "exec" || name === "wait" || name === "computer" || name === "image" || name === "message";
+}
+function isGoogleGemini3Model(modelId, family) {
+	const normalized = modelId.trim().toLowerCase();
+	const suffix = family === "pro" ? "pro" : "flash";
+	return new RegExp(`(?:^|/)gemini-(?:3(?:\\.\\d+)?-${suffix}|${suffix}${family === "flash" ? "(?:-lite)?" : ""}-latest)(?:-|$)`).test(normalized);
+}
+function isGoogleGemini3ProModel(modelId) {
+	return isGoogleGemini3Model(modelId, "pro");
+}
+function isGoogleGemini3FlashModel(modelId) {
+	return isGoogleGemini3Model(modelId, "flash");
+}
+function parseRetryAfterSeconds(headers) {
+	const retryAfterMs = headers.get("retry-after-ms");
+	if (retryAfterMs) {
+		const trimmed = retryAfterMs.trim();
+		if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+			const milliseconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmed), {
+				min: 0,
+				max: Number.MAX_SAFE_INTEGER
+			});
+			return milliseconds === void 0 ? Number.POSITIVE_INFINITY : milliseconds / 1e3;
+		}
+	}
+	const retryAfter = headers.get("retry-after")?.trim();
+	if (!retryAfter) return;
+	if (/^\d+$/.test(retryAfter)) return parseStrictNonNegativeInteger(retryAfter) ?? Number.POSITIVE_INFINITY;
+	const retryAt = parseRetryAfterHttpDateMs(retryAfter);
+	return retryAt === void 0 ? void 0 : Math.max(0, (retryAt - Date.now()) / 1e3);
+}
+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 ?? 8 * 1024;
+	const maxChars = options?.maxChars ?? 200;
+	const reader = response.body?.getReader();
+	if (!reader) return;
+	const chunks = [];
+	let bytes = 0;
+	let truncated = false;
+	try {
+		while (bytes < maxBytes) {
+			const result = options?.chunkTimeoutMs ? await readChunkWithIdleTimeout(reader, options.chunkTimeoutMs, options.onIdleTimeout) : await reader.read();
+			if (result.done) break;
+			if (!result.value?.length) continue;
+			const remaining = maxBytes - bytes;
+			chunks.push(result.value.subarray(0, remaining));
+			bytes += Math.min(result.value.length, remaining);
+			if (result.value.length >= remaining) {
+				truncated = true;
+				await reader.cancel().catch(() => void 0);
+				break;
+			}
+		}
+	} 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
+//#region packages/ai/src/transports/transport-stream-shared.ts
+const EMPTY_TOOL_RESULT_TEXT = "(no output)";
+function sanitizeTransportPayloadText(text) {
+	if (typeof text !== "string") return "";
+	return sanitizeSurrogates(text);
+}
+function sanitizeNonEmptyTransportPayloadText(text, fallback = EMPTY_TOOL_RESULT_TEXT) {
+	const sanitized = sanitizeTransportPayloadText(text);
+	return sanitized.trim().length > 0 ? sanitized : fallback;
+}
+function coerceTransportToolCallArguments(argumentsValue) {
+	if (argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue)) return argumentsValue;
+	if (typeof argumentsValue === "string") try {
+		const parsed = JSON.parse(argumentsValue);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+function mergeTransportHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeTransportMetadata(payload, metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return payload;
+	const existingMetadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : void 0;
+	return {
+		...payload,
+		metadata: {
+			...existingMetadata,
+			...metadata
+		}
+	};
+}
+function createEmptyTransportUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createWritableTransportEventStream() {
+	const eventStream = createAssistantMessageEventStream();
+	return {
+		eventStream,
+		stream: eventStream
+	};
+}
+/**
+* Abort error to surface for an aborted `signal`.
+*
+* Rethrows the caller's abort reason only when it carries a `code`, so that code
+* survives into `errorCode` on the persisted assistant message and consumers can
+* recognize an abort's origin without matching error text. A default
+* `abort()` reason is an uncoded DOMException that carries nothing the synthetic
+* error does not, so it keeps the "Request was aborted" text every transport
+* already emits rather than churning it.
+*/
+function transportAbortError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error && typeof reason.code === "string" ? reason : /* @__PURE__ */ new Error("Request was aborted");
+}
+function finalizeTransportStream(params) {
+	const { stream, output, signal } = params;
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+	stream.push({
+		type: "done",
+		reason: output.stopReason,
+		message: output
+	});
+	stream.end();
+}
+const MAX_TRANSPORT_ERROR_CAUSE_DEPTH = 8;
+function readStringLikeProperty(value, key) {
+	if (!value || typeof value !== "object") return;
+	const raw = value[key];
+	if (typeof raw === "string") return raw.trim() || void 0;
+	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+}
+function readObjectProperty(value, key) {
+	if (!value || typeof value !== "object") return;
+	const raw = value[key];
+	return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
+}
+function readCauseChainErrorCode(value) {
+	const seen = /* @__PURE__ */ new Set();
+	let cause = readObjectProperty(value, "cause");
+	for (let depth = 0; cause && depth < MAX_TRANSPORT_ERROR_CAUSE_DEPTH && !seen.has(cause); depth += 1) {
+		seen.add(cause);
+		const code = readStringLikeProperty(cause, "code");
+		if (code) return code;
+		cause = readObjectProperty(cause, "cause");
+	}
+}
+function stringifyErrorBody(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0 || value === null) return;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function stringifyTransportErrorMessage(value) {
+	if (value instanceof Error) return value.message;
+	const encoded = stringifyErrorBody(value);
+	if (encoded !== void 0) return encoded;
+	try {
+		return String(value);
+	} catch {
+		return;
+	}
+}
+function normalizeTransportErrorBody(value) {
+	const text = stringifyErrorBody(value);
+	if (!text?.trim()) return;
+	const redacted = redactSensitiveText(text);
+	return redacted.length > 500 ? `${truncateUtf16Safe(redacted, 499)}…` : redacted;
+}
+function extractTransportErrorDetails(error) {
+	const errorObject = error && typeof error === "object" ? error : void 0;
+	const nestedError = readObjectProperty(errorObject, "error");
+	const errorCode = readStringLikeProperty(errorObject, "errorCode") ?? readStringLikeProperty(errorObject, "code") ?? readStringLikeProperty(nestedError, "code") ?? readCauseChainErrorCode(errorObject);
+	const errorType = readStringLikeProperty(errorObject, "errorType") ?? readStringLikeProperty(errorObject, "type") ?? readStringLikeProperty(nestedError, "type");
+	const errorBody = normalizeTransportErrorBody(readStringLikeProperty(errorObject, "errorBody")) ?? normalizeTransportErrorBody(readStringLikeProperty(errorObject, "body")) ?? normalizeTransportErrorBody(readObjectProperty(errorObject, "body")) ?? normalizeTransportErrorBody(nestedError);
+	return {
+		...errorCode ? { errorCode } : {},
+		...errorType ? { errorType } : {},
+		...errorBody ? { errorBody } : {}
+	};
+}
+function assignTransportErrorDetails(output, error, signal) {
+	output.stopReason = signal?.aborted ? "aborted" : "error";
+	output.errorMessage = stringifyTransportErrorMessage(error);
+	Object.assign(output, extractTransportErrorDetails(error));
+}
+function failTransportStream(params) {
+	const { stream, output, signal, error, cleanup } = params;
+	cleanup?.();
+	assignTransportErrorDetails(output, error, signal);
+	stream.push({
+		type: "error",
+		reason: output.stopReason,
+		error: output
+	});
+	stream.end();
+}
+//#endregion
+export { resolveSecretSentinel as C, resolveModelHeaderSentinels as S, supportsModelTools as T, isGoogleGemini3ProModel as _, failTransportStream as a, redactIdentifier as b, mergeTransportMetadata as c, transportAbortError as d, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as f, isGoogleGemini3FlashModel as g, isCodeModeModelVisibleToolName as h, createWritableTransportEventStream as i, sanitizeNonEmptyTransportPayloadText as l, estimateStringChars as m, coerceTransportToolCallArguments as n, finalizeTransportStream as o, createAbortError as p, createEmptyTransportUsage as r, mergeTransportHeaders as s, assignTransportErrorDetails as t, sanitizeTransportPayloadText as u, parseRetryAfterSeconds as v, sha256Hex as w, redactSensitiveText as x, readResponseTextSnippet as y };

package/dist/transports.d.mts

@@ -1,8 +1,9 @@
-import { E as Model, L as StreamFn, O as OpenAICompletionsCompat, X as Usage, n as Api, u as Context } from "./types-AFwwWium.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-Douf9dob.mjs";
-import { n as ApiRegistry } from "./api-registry-BMphkFf1.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-WvWBo4h8.mjs";
-import { B as OpenAIApiReasoningEffort, V as OpenAIReasoningEffort, nt as OpenAICompletionsToolChoice, rt as OpenAIToolProjection } from "./openai-CoGicoDt.mjs";
+import { E as Model, L as StreamFn, O as OpenAICompletionsCompat, X as Usage, a as AssistantMessageEvent, i as AssistantMessage, n as Api, u as Context } from "./types-bzp5k29J.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-YjaPW20U.mjs";
+import { n as ApiRegistry } from "./api-registry-DlMgPR39.mjs";
+import { B as OpenAIApiReasoningEffort, V as OpenAIReasoningEffort, at as ResolvedOpenAICompletionsCompat, et as OpenAICompletionsToolChoice, ot as detectOpenAICompletionsCompat, st as resolveOpenAICompletionsCompat, tt as OpenAIToolProjection } from "./openai-BPor_3WI.mjs";
+import { n as FirstStreamEventInternalOptions } from "./stream-first-event-timeout-DvDeSucC.mjs";
+import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-Cwcjv_fx.mjs";
 import OpenAI from "openai";
 import { ChatCompletionChunk } from "openai/resources/chat/completions.js";
 import { FunctionTool, ResponseCreateParamsStreaming, ResponseInput, ResponseReasoningItem } from "openai/resources/responses/responses.js";
@@ -111,31 +112,6 @@ declare function formatModelTransportDebugBaseUrl(rawUrl: string | undefined): s
 /** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
 declare function hasOpenAICompatibleConversationTurn(messages: unknown): boolean;
 //#endregion
-//#region packages/ai/src/transports/openai-completions-compat.d.ts
-type ProviderRequestCapabilities = AiProviderRequestCapabilities;
-type OpenAICompletionsCompatDefaults = {
-  supportsStore: boolean;
-  supportsDeveloperRole: boolean;
-  supportsReasoningEffort: boolean;
-  supportsUsageInStreaming: boolean;
-  maxTokensField: "max_completion_tokens" | "max_tokens";
-  thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai";
-  visibleReasoningDetailTypes: string[];
-  supportsStrictMode: boolean;
-  requiresReasoningContentOnAssistantMessages: boolean;
-  requiresNonEmptyUserOrAssistantMessage: boolean;
-};
-type DetectedOpenAICompletionsCompat = {
-  capabilities: ProviderRequestCapabilities;
-  defaults: OpenAICompletionsCompatDefaults;
-};
-/** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
-declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "provider" | "baseUrl" | "id"> & {
-  compat?: {
-    supportsStore?: boolean;
-  } | null;
-}, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): DetectedOpenAICompletionsCompat;
-//#endregion
 //#region packages/ai/src/transports/openai-completions-string-content.d.ts
 /** Flatten string-only text block content arrays into newline-joined strings. */
 declare function flattenCompletionMessagesToStringContent(messages: unknown[]): unknown[];
@@ -216,10 +192,6 @@ declare function throwIfModelStreamAborted(signal?: AbortSignal): void;
 declare function createModelStreamCooperativeScheduler(signal?: AbortSignal): ModelStreamCooperativeScheduler;
 declare function resolveCacheRetention(cacheRetention: string | undefined): "short" | "long" | "none";
 declare function resolvePromptCacheKey(options: Pick<BaseOpenAIStreamOptions, "promptCacheKey" | "sessionId"> | undefined, cacheRetention: "short" | "long" | "none"): string | undefined;
-declare function sortTransportToolsByName<T extends {
-  name?: string;
-  description?: string;
-}>(tools: readonly T[]): T[];
 //#endregion
 //#region packages/ai/src/transports/openai-transport-params.d.ts
 declare function enforceCodeModeResponsesToolSurface(payload: unknown): void;
@@ -242,25 +214,29 @@ declare function buildOpenAISdkRequestOptions(model: Model, signal?: AbortSignal
   headers?: Record<string, string>;
 } | undefined;
 declare function getCompat(model: OpenAIModeModel): {
+  cacheControlFormat: "anthropic" | undefined;
+  reasoningEffortMap: Record<string, string>;
+  openRouterRouting: Record<string, unknown>;
+  vercelGatewayRouting: Record<string, unknown>;
+  requiresStringContent: boolean;
+  strictMessageKeys: boolean;
   supportsStore: boolean;
   supportsDeveloperRole: boolean;
   supportsReasoningEffort: boolean;
-  reasoningEffortMap: Record<string, string>;
   supportsUsageInStreaming: boolean;
-  maxTokensField: string;
+  maxTokensField: "max_completion_tokens" | "max_tokens";
   requiresToolResultName: boolean;
   requiresAssistantAfterToolResult: boolean;
   requiresThinkingAsText: boolean;
-  thinkingFormat: string;
-  openRouterRouting: Record<string, unknown>;
-  vercelGatewayRouting: {};
+  requiresReasoningContentOnAssistantMessages: boolean;
+  thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai" | "qwen" | "qwen-chat-template";
+  zaiToolStream: boolean;
   supportsStrictMode: boolean;
+  supportsJsonSchemaResponseFormat: boolean;
   supportsPromptCacheKey: boolean;
   supportsLongCacheRetention: boolean;
-  requiresStringContent: boolean;
-  strictMessageKeys: boolean;
+  sessionAffinity: "openai" | "openrouter" | "none";
   visibleReasoningDetailTypes: string[];
-  requiresReasoningContentOnAssistantMessages: boolean;
   requiresNonEmptyUserOrAssistantMessage: boolean;
 };
 //#endregion
@@ -360,7 +336,42 @@ declare function resolveReplayableResponsesMessageId(params: {
   previousReplayItemWasReasoning: boolean;
 }): string | undefined;
 //#endregion
-//#region packages/ai/src/transports/openai-responses-transport.d.ts
+//#region packages/ai/src/transports/openai-responses-client.d.ts
+declare function createOpenAIResponsesClient(model: Model, context: Context, apiKey: string, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>, sessionId?: string): OpenAI;
+declare function createOpenAIResponsesTransportStreamFn(): StreamFn;
+declare function createAzureOpenAIResponsesTransportStreamFn(): StreamFn;
+declare function createAzureOpenAIClient(model: Model, context: Context, apiKey: string, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>): OpenAI;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-debug.d.ts
+declare function summarizeResponsesTools(tools: unknown): string;
+declare function stringifyRedactedPayload(value: unknown): string;
+declare function stringifyRedactedEvent(value: unknown): string;
+type ResponsesFailedNoDetailsObservation = {
+  event: "openai_responses_response_failed_without_details";
+  provider: string;
+  api: Api;
+  transportModel: string;
+  providerRuntimeFailureKind: "no_error_details";
+  responseId: string;
+  responseStatus: string;
+  responseModel: string;
+  responseObject: string;
+  metadataKeys: string[];
+  requestIdHashes: string[];
+  failureFieldsPreview: string;
+  responsePreview: string;
+};
+type ResponsesFailedEventSummary = {
+  message: string;
+  responseId?: string;
+  observation?: ResponsesFailedNoDetailsObservation;
+};
+declare function buildResponsesFailedNoDetailsObservation(event: Record<string, unknown>, model: Model, response?: Record<string, unknown> | undefined): ResponsesFailedNoDetailsObservation;
+declare function summarizeResponsesFailedNoDetailsObservation(observation: ResponsesFailedNoDetailsObservation): string;
+declare function normalizeResponsesFailedEvent(event: Record<string, unknown>, model: Model): ResponsesFailedEventSummary;
+declare function summarizeResponsesPayload(params: unknown): string;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-contracts.d.ts
 declare const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
 type OpenAIResponsesReasoningReplayMetadata = {
   v: 1;
@@ -376,7 +387,6 @@ type ReplayableResponseReasoningItem = Omit<ResponseReasoningItem, "id"> & {
   id?: string;
   [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]?: OpenAIResponsesReasoningReplayMetadata;
 };
-type ResponsesClientLike = ReturnType<typeof createOpenAIResponsesClient>;
 type OpenAIResponsesOptions = BaseOpenAIStreamOptions & {
   reasoning?: OpenAIReasoningEffort;
   reasoningEffort?: OpenAIReasoningEffort;
@@ -393,63 +403,6 @@ type OpenAIResponsesReplayContext = {
   sessionHash?: string;
   authProfileHash?: string;
 };
-declare function summarizeResponsesTools(tools: unknown): string;
-declare function stringifyRedactedPayload(value: unknown): string;
-declare function stringifyRedactedEvent(value: unknown): string;
-type ResponsesFailedNoDetailsObservation = {
-  event: "openai_responses_response_failed_without_details";
-  provider: string;
-  api: Api;
-  transportModel: string;
-  providerRuntimeFailureKind: "no_error_details";
-  responseId: string;
-  responseStatus: string;
-  responseModel: string;
-  responseObject: string;
-  metadataKeys: string[];
-  requestIdHashes: string[];
-  failureFieldsPreview: string;
-  responsePreview: string;
-};
-type ResponsesFailedEventSummary = {
-  message: string;
-  responseId?: string;
-  observation?: ResponsesFailedNoDetailsObservation;
-};
-declare function buildResponsesFailedNoDetailsObservation(event: Record<string, unknown>, model: Model, response?: Record<string, unknown> | undefined): ResponsesFailedNoDetailsObservation;
-declare function summarizeResponsesFailedNoDetailsObservation(observation: ResponsesFailedNoDetailsObservation): string;
-declare function normalizeResponsesFailedEvent(event: Record<string, unknown>, model: Model): ResponsesFailedEventSummary;
-declare function summarizeResponsesPayload(params: unknown): string;
-declare function isInvalidEncryptedContentError(error: unknown): boolean;
-declare function stripResponsesRequestEncryptedContent(params: OpenAIResponsesRequestParams): OpenAIResponsesRequestParams;
-declare function buildOpenAIResponsesReasoningReplayMetadata(model: Model, options?: Pick<BaseOpenAIStreamOptions, "authProfileId" | "sessionId">): OpenAIResponsesReasoningReplayMetadata;
-declare function tagOpenAIResponsesReasoningReplayItem(item: Record<string, unknown>, model: Model, options?: Pick<BaseOpenAIStreamOptions, "authProfileId" | "sessionId">): Record<string, unknown>;
-declare function prepareOpenAIResponsesReasoningItemForReplay(item: ReplayableResponseReasoningItem, context: OpenAIResponsesReplayContext, blockMetadata?: OpenAIResponsesReasoningReplayMetadata): ReplayableResponseReasoningItem;
-declare function createResponsesStreamWithEncryptedContentRetry(params: {
-  client: ResponsesClientLike;
-  request: OpenAIResponsesRequestParams;
-  requestOptions: unknown;
-  model: Model;
-}): Promise<AsyncIterable<unknown>>;
-declare function resolveAzureOpenAIApiVersion(env?: NodeJS.ProcessEnv): string;
-declare function processResponsesStream(openaiStream: AsyncIterable<unknown>, output: MutableAssistantOutput, stream: {
-  push(event: unknown): void;
-}, model: Model, options?: {
-  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
-  applyServiceTierPricing?: (usage: MutableAssistantOutput["usage"], serviceTier?: ResponseCreateParamsStreaming["service_tier"]) => void;
-  firstEventTimeoutMs?: number;
-  abortFirstEventStream?: (reason: Error) => void;
-  onFirstEventTimeout?: (reason: Error) => void;
-  signal?: AbortSignal;
-  sessionId?: string;
-  authProfileId?: string;
-}): Promise<void>;
-declare function createOpenAIResponsesClient(model: Model, context: Context, apiKey: string, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>, sessionId?: string): OpenAI;
-declare function createOpenAIResponsesTransportStreamFn(): StreamFn;
-declare function sanitizeOpenAICodexResponsesParams<T extends Record<string, unknown>>(model: Model, params: T): T;
-declare function buildOpenAIResponsesParams(model: Model, context: Context, options: OpenAIResponsesOptions | undefined, metadata?: Record<string, string>): OpenAIResponsesRequestParams;
-declare function createAzureOpenAIResponsesTransportStreamFn(): StreamFn;
-declare function createAzureOpenAIClient(model: Model, context: Context, apiKey: string, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>): OpenAI;
 type OpenAIResponsesRequestParams = {
   model: string;
   input: ResponseInput;
@@ -474,6 +427,42 @@ type OpenAIResponsesRequestParams = {
   };
   include?: string[];
 };
+//#endregion
+//#region packages/ai/src/transports/openai-responses-params-internal.d.ts
+declare function sanitizeOpenAICodexResponsesParams<T extends Record<string, unknown>>(model: Model, params: T): T;
+declare function buildOpenAIResponsesParams(model: Model, context: Context, options: OpenAIResponsesOptions | undefined, metadata?: Record<string, string>): OpenAIResponsesRequestParams;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-replay-internal.d.ts
+type ResponsesClientLike = ReturnType<typeof createOpenAIResponsesClient>;
+declare function isInvalidEncryptedContentError(error: unknown): boolean;
+declare function stripResponsesRequestEncryptedContent(params: OpenAIResponsesRequestParams): OpenAIResponsesRequestParams;
+declare function buildOpenAIResponsesReasoningReplayMetadata(model: Model, options?: Pick<BaseOpenAIStreamOptions, "authProfileId" | "sessionId">): OpenAIResponsesReasoningReplayMetadata;
+declare function tagOpenAIResponsesReasoningReplayItem(item: Record<string, unknown>, model: Model, options?: Pick<BaseOpenAIStreamOptions, "authProfileId" | "sessionId">): Record<string, unknown>;
+declare function prepareOpenAIResponsesReasoningItemForReplay(item: ReplayableResponseReasoningItem, context: OpenAIResponsesReplayContext, blockMetadata?: OpenAIResponsesReasoningReplayMetadata): ReplayableResponseReasoningItem;
+declare function createResponsesStreamWithEncryptedContentRetry(params: {
+  client: ResponsesClientLike;
+  request: OpenAIResponsesRequestParams;
+  requestOptions: unknown;
+  model: Model;
+}): Promise<AsyncIterable<unknown>>;
+declare function resolveAzureOpenAIApiVersion(env?: NodeJS.ProcessEnv): string;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-terminal-internal.d.ts
+type ResponsesEventSink = {
+  push(event: AssistantMessageEvent): void;
+};
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-internal.d.ts
+type ResponsesStreamOptions = FirstStreamEventInternalOptions & {
+  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+  resolveServiceTier?: (responseServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined, requestServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => ResponseCreateParamsStreaming["service_tier"] | undefined;
+  applyServiceTierPricing?: (usage: Usage, serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => void;
+  signal?: AbortSignal;
+  reasoningReplayMetadata?: OpenAIResponsesReasoningReplayMetadata;
+};
+declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<unknown>, output: AssistantMessage, stream: ResponsesEventSink, model: Model<TApi>, options?: ResponsesStreamOptions): Promise<void>;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-transport.d.ts
 declare const responsesTesting: {
   getCompat: typeof getCompat;
   assertCodeModeResponsesToolSurface: typeof assertCodeModeResponsesToolSurface;
@@ -573,6 +562,17 @@ declare function createWritableTransportEventStream(): {
   eventStream: AssistantMessageEventStream;
   stream: WritableTransportStream;
 };
+/**
+ * Abort error to surface for an aborted `signal`.
+ *
+ * Rethrows the caller's abort reason only when it carries a `code`, so that code
+ * survives into `errorCode` on the persisted assistant message and consumers can
+ * recognize an abort's origin without matching error text. A default
+ * `abort()` reason is an uncoded DOMException that carries nothing the synthetic
+ * error does not, so it keeps the "Request was aborted" text every transport
+ * already emits rather than churning it.
+ */
+declare function transportAbortError(signal?: AbortSignal): Error;
 declare function finalizeTransportStream(params: {
   stream: WritableTransportStream;
   output: TransportOutputShape;
@@ -587,4 +587,7 @@ declare function failTransportStream(params: {
   cleanup?: () => void;
 }): void;
 //#endregion
-export { BaseOpenAIStreamOptions, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MutableAssistantOutput, OpenAICompletionsOptions, OpenAIModeModel, WritableTransportStream, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, coerceTransportToolCallArguments, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, hasOpenAICompatibleConversationTurn, isOpenAICodexResponsesModel, log, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, quoteUnsafeIntegerLiterals, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveCacheRetention, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortTransportToolsByName, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, usesNativeOpenAICodexResponsesBackend };
+//#region packages/ai/src/transports/transport-utils.d.ts
+declare function isCodeModeModelVisibleToolName(name: string): boolean;
+//#endregion
+export { BaseOpenAIStreamOptions, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, MutableAssistantOutput, OpenAICompletionsOptions, OpenAIModeModel, ResolvedOpenAICompletionsCompat, WritableTransportStream, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assertCodeModeResponsesToolSurface, assignTransportErrorDetails, buildOpenAIClientHeaders, buildOpenAICompletionsParams, buildOpenAISdkClientOptions, buildOpenAISdkRequestOptions, buildTransportAwareSimpleStreamFn, canonicalizeMaxTokensParam, coerceTransportToolCallArguments, createAnthropicMessagesTransportStreamFn, createAzureOpenAIResponsesTransportStreamFn, createBoundaryAwareStreamFnForModel, createDeepSeekTextFilter, createEmptyTransportUsage, createModelStreamCooperativeScheduler, createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn, createOpenClawTransportStreamFnForModel, createTransportAwareStreamFnForModel, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, enforceCodeModeResponsesToolSurface, failTransportStream, finalizeTransportStream, flattenCompletionMessagesToStringContent, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, getCompat, hasOpenAICompatibleConversationTurn, isCodeModeModelVisibleToolName, isOpenAICodexResponsesModel, log, mergeTransportHeaders, mergeTransportMetadata, normalizeCodexResponsesBaseUrlForOpenAISdk, parseJsonObjectPreservingUnsafeIntegers, parseJsonPreservingUnsafeIntegers, prepareModelForSimpleCompletion, prepareTransportAwareSimpleModel, quoteUnsafeIntegerLiterals, resolveAnthropicEphemeralCacheControl, resolveAnthropicMessagesUrl, resolveAnthropicPayloadPolicy, resolveCacheRetention, resolveMaxTokensParam, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIReasoningEffortMap, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIStrictToolFlagWithDiagnostics, resolvePromptCacheKey, resolveReplayableResponsesMessageId, resolveTransportAwareSimpleApi, sanitizeNonEmptyTransportPayloadText, sanitizeResponsesImagePayload, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, stripCompletionMessagesToRoleContent, throwIfModelStreamAborted, transportAbortError, usesNativeOpenAICodexResponsesBackend };