@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.2

package/dist/{openai-completions-BaIpl93j.mjs → openai-completions-BPnt4Sml.mjs}

@@ -1,19 +1,18 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
-import { r as clampThinkingLevel } from "./model-utils-Dau5dlgm.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { i as clampThinkingLevel } from "./sanitize-unicode-BYqrYtC_.mjs";
+import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { c as buildBaseOptions, m as splitSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
-import { a as convertMessages, c as resolveOpenAICompletionsResponseFormat, d as rememberPendingCommentaryTags, f as tagPendingCommentaryText, i as finalizeOpenAICompletionsToolCalls, l as shouldOmitOllamaCompatResponseFormat, n as mapOpenAIStopReason, r as createOpenAICompletionsToolCallDeltaNormalizer, s as resolveOpenAICompletionsCompat, t as resolveOpenAIReasoningEffortMap, u as clearPendingCommentaryText } from "./openai-reasoning-compat-DKebnIBL.mjs";
-import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-CPNv7A3r.mjs";
-import { a as parseOpenAICompletionsUsage, l as projectOpenAITools, o as readOpenAICompletionsContentDeltas, r as isOpenAICompletionsThinkingEnabled, u as reconcileOpenAICompletionsToolChoice } from "./openai-transport-shared-Cipt7egQ.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-CGDyLWUR.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-DI0Ts28U.mjs";
+import { c as splitSystemPromptCacheBoundary, f as sortPromptCacheToolsByName, n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
+import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagPendingCommentaryText, r as convertMessages, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-BkFkqqK0.mjs";
+import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
+import { n as notifyLlmRequestActivity } from "./headers-DdOQtGuU.mjs";
+import { f as transportAbortError, p as withProviderResponseHook } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+import { d as readOpenAICompletionsContentDeltas, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIResponseHook, s as isOpenAICompletionsThinkingEnabled, t as projectOpenAITools, u as parseOpenAICompletionsUsage } from "./openai-tool-projection-CY04OcvQ.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-rnPwX2pg.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-completions.ts
@@ -22,20 +21,6 @@ var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAICompletions: () => streamOpenAICompletions,
 	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
 });
-/**
-* Check if conversation messages contain tool calls or tool results.
-* This is needed because Anthropic (via proxy) requires the tools param
-* to be present when messages include tool_calls or tool role messages.
-*/
-function hasToolHistory(messages) {
-	for (const msg of messages) {
-		if (msg.role === "toolResult") return true;
-		if (msg.role === "assistant") {
-			if (Array.isArray(msg.content) && msg.content.some((block) => block.type === "toolCall")) return true;
-		}
-	}
-	return false;
-}
 function isEncryptedReasoningDetail(detail) {
 	if (typeof detail !== "object" || detail === null) return false;
 	const candidate = detail;
@@ -85,13 +70,15 @@ const streamOpenAICompletions = (model, context, options) => {
 				maxRetries: options?.maxRetries ?? 0
 			};
 			const { data: openaiStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			stream.push({
-				type: "start",
-				partial: output
+			const hookedOpenAIStream = withProviderResponseHook({
+				stream: openaiStream,
+				signal: firstEventAbort.signal,
+				abort: firstEventAbort.abort,
+				hook: createOpenAIResponseHook(options?.onResponse, response, model),
+				onReady: () => stream.push({
+					type: "start",
+					partial: output
+				})
 			});
 			let textBlock = null;
 			let thinkingBlock = null;
@@ -239,7 +226,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const flushPartitionedContent = () => {
 				for (const delta of reasoningTagTextPartitioner.flush()) if (delta.kind === "text") appendTextDelta(delta.text);
 			};
-			const guardedOpenaiStream = withFirstStreamEventTimeout(openaiStream, {
+			const guardedOpenaiStream = withFirstStreamEventTimeout(hookedOpenAIStream, {
 				provider: model.provider,
 				api: model.api,
 				model: model.id,
@@ -355,19 +342,17 @@ const streamOpenAICompletions = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			const terminal = projectProviderError(error, options?.signal);
+			Object.assign(output, terminal);
 			finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
 			for (const block of output.content) {
 				delete block.index;
 				delete block.partialArgs;
 				delete block.streamIndex;
 			}
-			output.errorMessage = formatProviderError(error);
-			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata && !output.errorMessage.includes(rawMetadata)) output.errorMessage += `\n${rawMetadata}`;
 			stream.push({
 				type: "error",
-				reason: output.stopReason,
+				reason: terminal.stopReason,
 				error: output
 			});
 			stream.end();
@@ -458,9 +443,9 @@ function buildParams(model, context, options, compat = resolveOpenAICompletionsC
 		const converted = convertTools(context.tools, compat);
 		toolProjection = converted.projection;
 		if (converted.tools.length > 0) params.tools = converted.tools;
-		else if (hasToolHistory(context.messages)) params.tools = [];
+		else if (hasToolCallHistory(context.messages)) params.tools = [];
 		if (compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
-	} else if (hasToolHistory(context.messages)) params.tools = [];
+	} else if (hasToolCallHistory(context.messages)) params.tools = [];
 	if (cacheControl) applyAnthropicCacheControl(messages, params.tools, cacheControl, cacheOptOutIndexes);
 	if (options?.toolChoice) {
 		const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, toolProjection ?? projectOpenAITools([]));
@@ -596,7 +581,7 @@ function convertTools(tools, compat) {
 	const projection = projectOpenAITools(tools);
 	return {
 		projection,
-		tools: projection.tools.map((tool) => ({
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => ({
 			type: "function",
 			function: {
 				name: tool.name,

package/dist/openai-completions-compat-Dt3dcawL.d.mts

@@ -0,0 +1,43 @@
+import { E as Model, O as OpenAICompletionsCompat } from "./types-BHNrPS1l.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-vWgMMhiJ.mjs";
+
+//#region packages/ai/src/transports/openai-completions-compat.d.ts
+type ProviderRequestCapabilities = AiProviderRequestCapabilities;
+type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
+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;
+  supportsJsonSchemaResponseFormat: boolean;
+  requiresReasoningContentOnAssistantMessages: boolean;
+  requiresNonEmptyUserOrAssistantMessage: boolean;
+  cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+  sessionAffinityFormat: Exclude<OpenAICompletionsSessionAffinity, "none">;
+  supportsLongCacheRetention: boolean;
+};
+type DetectedOpenAICompletionsCompat = {
+  capabilities: ProviderRequestCapabilities;
+  defaults: OpenAICompletionsCompatDefaults;
+};
+type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "openRouterRouting" | "sendSessionAffinityHeaders"> & {
+  cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+  openRouterRouting?: OpenAICompletionsCompat["openRouterRouting"];
+  sessionAffinity: OpenAICompletionsSessionAffinity;
+  visibleReasoningDetailTypes: string[];
+  requiresNonEmptyUserOrAssistantMessage: boolean;
+};
+/** 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;
+/** Applies explicit model overrides once on top of the canonical transport defaults. */
+declare function resolveOpenAICompletionsCompat(model: Model<"openai-completions">, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): ResolvedOpenAICompletionsCompat;
+//#endregion
+export { detectOpenAICompletionsCompat as n, resolveOpenAICompletionsCompat as r, ResolvedOpenAICompletionsCompat as t };

package/dist/{openai-responses-Bdx3V_Yu.mjs → openai-responses-DhIKtOup.mjs}

@@ -1,12 +1,12 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { S as supportsOpenAITemperature } from "./openai-responses-contracts-CyfIkQi5.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { c as buildBaseOptions } from "./tool-result-text-Dvkp2Dus.mjs";
-import { pt as supportsOpenAITemperature } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
+import { n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
+import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, o as runResponsesStreamLifecycle, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-DXIt3iY5.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, o as runResponsesStreamLifecycle, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-CCyMvg7M.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
@@ -23,19 +23,6 @@ function getCompat(model) {
 function getPromptCacheRetention(compat, cacheRetention) {
 	return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0;
 }
-function formatOpenAIResponsesError(error) {
-	if (error instanceof Error) {
-		const status = error.status;
-		const statusCode = typeof status === "number" ? status : void 0;
-		if (statusCode !== void 0) return `OpenAI API error (${statusCode}): ${error.message}`;
-		return error.message;
-	}
-	try {
-		return JSON.stringify(error);
-	} catch {
-		return String(error);
-	}
-}
 /**
 * Generate function for OpenAI Responses API
 */
@@ -51,12 +38,11 @@ const streamOpenAIResponses = (model, context, options) => {
 			const cacheSessionId = resolveCacheRetention(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
 			return createClient(model, context, apiKey, options?.headers, cacheSessionId);
 		},
-		buildParams: () => buildParams(model, context, options),
+		buildParams: (_requestModel, replayMode) => buildParams(model, context, options, replayMode),
 		processStreamOptions: {
 			serviceTier: options?.serviceTier,
 			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
-		},
-		formatError: formatOpenAIResponsesError
+		}
 	});
 	return stream;
 };
@@ -64,10 +50,12 @@ const streamSimpleOpenAIResponses = (model, context, options) => {
 	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const base = buildBaseOptions(model, options, apiKey);
+	const replayOptions = options;
 	return streamOpenAIResponses(model, context, {
 		...base,
+		authProfileId: replayOptions?.authProfileId,
 		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),
-		replayResponsesItemIds: options?.replayResponsesItemIds
+		replayResponsesItemIds: replayOptions?.replayResponsesItemIds
 	});
 };
 function createClient(model, context, apiKey, optionsHeaders, sessionId) {
@@ -100,8 +88,13 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
 		fetch: getAiTransportHost().buildModelFetch(model)
 	});
 }
-function buildParams(model, context, options) {
-	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, { replayResponsesItemIds: options?.replayResponsesItemIds ?? false });
+function buildParams(model, context, options, replayMode = "checkpoint") {
+	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+		replayResponsesItemIds: options?.replayResponsesItemIds ?? false,
+		sessionId: options?.sessionId,
+		authProfileId: options?.authProfileId,
+		replayMode
+	});
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const compat = getCompat(model);
 	const params = {

package/dist/openai-responses-contracts-CyfIkQi5.mjs

@@ -0,0 +1,253 @@
+import { n as PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE, t as PROVIDER_FAILURE_WITH_OUTPUT_ERROR_CODE } from "./types-BDdaOVi2.mjs";
+import "./src-D2H6yKkH.mjs";
+import { a as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+//#region packages/normalization-core/src/string-normalization.ts
+/** Coerces entries to strings, trims them, and drops empty results. */
+function normalizeStringEntries(list) {
+	return (list ?? []).map((entry) => normalizeOptionalString(String(entry)) ?? "").filter(Boolean);
+}
+/** Returns first-seen unique values while preserving insertion order. */
+function uniqueValues(values) {
+	return [...new Set(values)];
+}
+/** Returns first-seen unique strings while preserving insertion order. */
+function uniqueStrings(values) {
+	return uniqueValues(values);
+}
+//#endregion
+//#region packages/ai/src/providers/openai-reasoning-effort.ts
+/**
+* OpenAI-compatible reasoning-effort normalization. Different GPT families
+* expose different accepted effort enums, so callers map requested values here
+* before constructing provider payloads.
+*/
+const GPT_5_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_51_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_52_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_56_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_CODEX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_5_PRO_REASONING_EFFORTS = ["high"];
+const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
+	"none",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
+const GENERIC_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"off"
+]);
+function normalizeModelId(id) {
+	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+}
+/** Return whether a model is the GPT-5.4 mini family. */
+function isOpenAIGpt54MiniModel(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+}
+/** Return whether a model is the GPT-5.5 family. */
+function isOpenAIGpt55Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model is the GPT-5.6 family. */
+function isOpenAIGpt56Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+}
+/** Normalize user-facing reasoning effort names to API effort names. */
+function normalizeOpenAIReasoningEffort(effort) {
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+}
+function readCompatReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object") return;
+	if (compat.supportsReasoningEffort === false) return [];
+	const raw = compat.supportedReasoningEfforts;
+	if (!Array.isArray(raw)) return;
+	const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
+	return supported.length > 0 ? supported : void 0;
+}
+function isDisabledReasoningEffort(effort) {
+	return effort === "none" || effort === "off";
+}
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+function resolveOpenAISupportedReasoningEfforts(model) {
+	const compatEfforts = readCompatReasoningEfforts(model.compat);
+	if (compatEfforts) return compatEfforts;
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	if (/^gpt-5\.6(?:-|$)/u.test(id)) return GPT_56_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
+	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
+	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
+	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
+	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
+	return GENERIC_REASONING_EFFORTS;
+}
+/**
+* Return whether a model accepts the temperature parameter. The GPT-5.6
+* family rejects it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return !/^gpt-5\.6(?:-|$)/u.test(id);
+}
+/** Return whether a model accepts a requested reasoning effort. */
+function supportsOpenAIReasoningEffort(model, effort) {
+	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
+}
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+function resolveOpenAIReasoningEffortForModel(params) {
+	const requested = normalizeOpenAIReasoningEffort(params.effort);
+	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
+	const normalized = mapped === void 0 ? requested : mapped.trim();
+	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
+	if (supported.includes(normalized)) return normalized;
+	if (requested === "off" && supported.includes("none")) return "none";
+	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
+	if (requested === "minimal" && supported.includes("low")) return "low";
+	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
+	if (requested === "xhigh" && supported.includes("high")) return "high";
+	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
+	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-contracts.ts
+const DEFAULT_AZURE_OPENAI_API_VERSION = "preview";
+const OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS = "Follow the user request.";
+const AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS = 3e4;
+const RESPONSE_FAILED_NO_DETAILS_MESSAGE = "Unknown error (no error details in response)";
+const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
+const OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY = "openclawReasoningReplay";
+const OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE = "openai-responses-compaction";
+const OPENAI_RESPONSES_APIS = /* @__PURE__ */ new Set([
+	"openai-responses",
+	"azure-openai-responses",
+	"openai-chatgpt-responses",
+	"openclaw-openai-responses-transport",
+	"openclaw-openai-chatgpt-responses-transport",
+	"openclaw-azure-openai-responses-transport"
+]);
+var OpenAIResponsesWebSocketResponseFailedError = class extends Error {
+	constructor(hasOutput) {
+		super("OpenAI Responses WebSocket returned response.failed");
+		this.name = "OpenAIResponsesWebSocketResponseFailedError";
+		this.code = hasOutput ? PROVIDER_FAILURE_WITH_OUTPUT_ERROR_CODE : PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE;
+	}
+};
+var OpenAIResponsesWebSocketPreDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed before request dispatch", { cause });
+		this.name = "OpenAIResponsesWebSocketPreDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketPostDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed after request dispatch; outcome is unknown", { cause });
+		this.code = PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE;
+		this.name = "OpenAIResponsesWebSocketPostDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketServerError = class extends Error {
+	constructor(code, status, param, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.status = status;
+		this.param = param;
+		this.name = "OpenAIResponsesWebSocketServerError";
+	}
+};
+var OpenAIResponsesWebSocketSafeRetryError = class extends OpenAIResponsesWebSocketServerError {};
+function readWebSocketServerError(value) {
+	if (!isRecord(value) || value.type !== "error") return;
+	const details = isRecord(value.error) ? value.error : value;
+	if (typeof details.code !== "string" || typeof details.message !== "string") return;
+	const rawStatus = value.status ?? value.status_code;
+	return {
+		code: details.code,
+		message: details.message,
+		param: typeof details.param === "string" ? details.param : null,
+		status: typeof rawStatus === "number" ? rawStatus : void 0
+	};
+}
+function parseOpenAIResponsesWebSocketServerError(cause) {
+	if (!isRecord(cause)) return;
+	let details = readWebSocketServerError(cause.error) ?? readWebSocketServerError(cause);
+	if (!details && typeof cause.message === "string") try {
+		details = readWebSocketServerError(JSON.parse(cause.message));
+	} catch {}
+	if (!details) return;
+	return new (details.code === "previous_response_not_found" || details.code === "websocket_connection_limit_reached" || details.code === "invalid_encrypted_content" || details.code === "thinking_signature_invalid" ? OpenAIResponsesWebSocketSafeRetryError : OpenAIResponsesWebSocketServerError)(details.code, details.status, details.param, details.message, cause);
+}
+const PROMPT_OBSERVER = Symbol("openaiResponsesPromptObserver");
+const responsesPromptObserver = {
+	set(options, observer) {
+		Reflect.set(options, PROMPT_OBSERVER, observer);
+	},
+	get(options) {
+		return Reflect.get(options, PROMPT_OBSERVER);
+	},
+	copy(source, target) {
+		const observer = source && responsesPromptObserver.get(source);
+		if (observer) responsesPromptObserver.set(target, observer);
+	}
+};
+//#endregion
+export { normalizeStringEntries as C, supportsOpenAITemperature as S, uniqueValues as T, isOpenAIGpt56Model as _, OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE as a, resolveOpenAISupportedReasoningEfforts as b, OpenAIResponsesWebSocketPostDispatchError as c, OpenAIResponsesWebSocketSafeRetryError as d, RESPONSE_FAILED_NO_DETAILS_MESSAGE as f, isOpenAIGpt55Model as g, isOpenAIGpt54MiniModel as h, OPENAI_RESPONSES_APIS as i, OpenAIResponsesWebSocketPreDispatchError as l, responsesPromptObserver as m, DEFAULT_AZURE_OPENAI_API_VERSION as n, OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY as o, parseOpenAIResponsesWebSocketServerError as p, OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS as r, OPENAI_RESPONSES_REASONING_REPLAY_META_KEY as s, AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS as t, OpenAIResponsesWebSocketResponseFailedError as u, normalizeOpenAIReasoningEffort as v, uniqueStrings as w, supportsOpenAIReasoningEffort as x, resolveOpenAIReasoningEffortForModel as y };

package/dist/openai-responses-contracts-XpZJxrRG.d.mts

@@ -0,0 +1,68 @@
+import { n as Api } from "./types-BHNrPS1l.mjs";
+import { f as OpenAIApiReasoningEffort, i as BaseOpenAIStreamOptions, p as OpenAIReasoningEffort } from "./provider-options-B96RdNpH.mjs";
+import { FunctionTool, ResponseCompactionItem, ResponseCreateParamsStreaming, ResponseInput } from "openai/resources/responses/responses.js";
+
+//#region packages/ai/src/transports/openai-responses-contracts.d.ts
+declare const OPENAI_RESPONSES_APIS: ReadonlySet<Api>;
+type ReplayableResponseCompactionItem = Omit<ResponseCompactionItem, "id"> & {
+  id?: string;
+};
+type OpenAIResponsesReasoningReplayMetadata = {
+  v: 1;
+  source: "openai-responses";
+  provider: string;
+  api: Api;
+  model: string;
+  baseUrlHash?: string;
+  sessionHash?: string;
+  authProfileHash?: string;
+};
+type OpenAIResponsesOptions = BaseOpenAIStreamOptions & {
+  reasoning?: OpenAIReasoningEffort;
+  reasoningEffort?: OpenAIReasoningEffort;
+  reasoningSummary?: "auto" | "detailed" | "concise" | null;
+  replayResponsesItemIds?: boolean;
+  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+  toolChoice?: ResponseCreateParamsStreaming["tool_choice"];
+};
+type ResponsesPromptObservation = {
+  egress: "responses-sdk" | "responses-websocket" | "native-codex-websocket" | "native-codex-sse";
+  payloadVariant: "initial" | "reasoning-stripped" | "compaction-stripped" | "continuation-rejected";
+  promptSource: "instructions" | "input.developer" | "input.system" | "missing";
+  expectedChars: number;
+  observedChars: number;
+  matchesAssembledPrompt: boolean;
+};
+type ResponsesPromptObserver = (observation: ResponsesPromptObservation) => void;
+declare const responsesPromptObserver: {
+  set(options: object, observer: ResponsesPromptObserver): void;
+  get(options: object): ResponsesPromptObserver | undefined;
+  copy(source: object | undefined, target: object): void;
+};
+type OpenAIResponsesRequestParams = {
+  model: string;
+  input: ResponseInput;
+  stream: true;
+  instructions?: string;
+  prompt_cache_key?: string;
+  prompt_cache_retention?: "24h";
+  metadata?: Record<string, string>;
+  previous_response_id?: string;
+  store?: boolean;
+  max_output_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  text?: ResponseCreateParamsStreaming["text"];
+  service_tier?: ResponseCreateParamsStreaming["service_tier"];
+  tools?: FunctionTool[];
+  tool_choice?: ResponseCreateParamsStreaming["tool_choice"];
+  reasoning?: {
+    effort: OpenAIApiReasoningEffort;
+  } | {
+    effort: OpenAIApiReasoningEffort;
+    summary: NonNullable<OpenAIResponsesOptions["reasoningSummary"]>;
+  };
+  include?: string[];
+};
+//#endregion
+export { ReplayableResponseCompactionItem as a, OpenAIResponsesRequestParams as i, OpenAIResponsesOptions as n, ResponsesPromptObservation as o, OpenAIResponsesReasoningReplayMetadata as r, responsesPromptObserver as s, OPENAI_RESPONSES_APIS as t };