@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

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

@@ -1,21 +1,19 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-Dog2WQiR.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 { u as splitSystemPromptCacheBoundary } from "./tool-result-text-CTpIRbYd.mjs";
-import { n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-OhX64DoP.mjs";
-import { c as calculateCost, l as clampThinkingLevel, s as applyProviderReportedUsageCost } from "./number-coercion-DvG7SNMg.mjs";
-import { a as resolveOpenAICompletionsCompat, c as clearPendingCommentaryText, l as rememberPendingCommentaryTags, n as mapOpenAIStopReason, o as resolveOpenAICompletionsResponseFormat, r as convertMessages, s as shouldOmitOllamaCompatResponseFormat, t as resolveOpenAIReasoningEffortMap, u as tagPendingCommentaryText } from "./openai-reasoning-compat-YgeLncHw.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-D81p90xq.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-BBys9hSb.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-CAEvRjry.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 { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
@@ -23,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;
@@ -86,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;
@@ -100,6 +86,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
 			const toolCallBlocksById = /* @__PURE__ */ new Map();
 			const toolCallBlocksByFirstId = /* @__PURE__ */ new Map();
+			const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
 			const pendingReasoningDetailsByToolCallId = /* @__PURE__ */ new Map();
 			const blocks = output.content;
 			const finishedBlocks = /* @__PURE__ */ new Set();
@@ -134,16 +121,12 @@ const streamOpenAICompletions = (model, context, options) => {
 					content: block.thinking,
 					partial: output
 				});
-				else if (block.type === "toolCall") {
-					delete block.partialArgs;
-					delete block.streamIndex;
-					stream.push({
-						type: "toolcall_end",
-						contentIndex,
-						toolCall: block,
-						partial: output
-					});
-				}
+				else if (block.type === "toolCall") stream.push({
+					type: "toolcall_end",
+					contentIndex,
+					toolCall: block,
+					partial: output
+				});
 			};
 			const ensureTextBlock = () => {
 				if (!textBlock) {
@@ -165,7 +148,7 @@ const streamOpenAICompletions = (model, context, options) => {
 					thinkingBlock = {
 						type: "thinking",
 						thinking: "",
-						thinkingSignature
+						...thinkingSignature ? { thinkingSignature } : {}
 					};
 					appendBlock(thinkingBlock);
 					stream.push({
@@ -243,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,
@@ -258,26 +241,27 @@ const streamOpenAICompletions = (model, context, options) => {
 				notifyLlmRequestActivity(options?.signal);
 				output.responseId ||= chunk.id;
 				if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
-				if (chunk.usage) output.usage = parseChunkUsage(chunk.usage, model);
+				if (chunk.usage) output.usage = parseOpenAICompletionsUsage(chunk.usage, model, { includeReasoningTokens: false });
 				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
 				if (!choice) continue;
 				const choiceUsage = choice.usage;
-				if (!chunk.usage && choiceUsage) output.usage = parseChunkUsage(choiceUsage, model);
+				if (!chunk.usage && choiceUsage) output.usage = parseOpenAICompletionsUsage(choiceUsage, model, { includeReasoningTokens: false });
 				if (choice.finish_reason) {
 					const finishReasonResult = mapOpenAIStopReason(choice.finish_reason);
 					output.stopReason = finishReasonResult.stopReason;
 					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
 					hasFinishReason = true;
 				}
-				const choiceDelta = choice.delta ?? choice.message;
-				if (choiceDelta) {
+				const rawChoiceDelta = choice.delta ?? choice.message;
+				if (rawChoiceDelta) for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
+					const choiceDelta = normalizedDelta.delta;
 					const reasoningFields = [
 						"reasoning_content",
 						"reasoning",
 						"reasoning_text"
 					];
 					const deltaFields = choiceDelta;
-					const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort);
+					const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
 					let foundReasoningField = null;
 					for (const field of reasoningFields) {
 						const value = deltaFields[field];
@@ -291,14 +275,16 @@ const streamOpenAICompletions = (model, context, options) => {
 						const delta = deltaFields[foundReasoningField];
 						if (typeof delta === "string" && delta.length > 0) appendThinkingDelta(model.provider === "opencode-go" && foundReasoningField === "reasoning" ? "reasoning_content" : foundReasoningField, delta);
 					}
-					if (choiceDelta.content !== null && choiceDelta.content !== void 0 && choiceDelta.content.length > 0) appendPartitionedContent(choiceDelta.content, Boolean(foundReasoningField));
-					const refusalText = typeof choiceDelta.refusal === "string" ? choiceDelta.refusal : "";
-					if (refusalText.length > 0) appendPartitionedContent(refusalText, Boolean(foundReasoningField));
-					if (choiceDelta.tool_calls && choiceDelta.tool_calls.length > 0) {
+					for (const contentDelta of readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, foundReasoningField ? [deltaFields[foundReasoningField]] : [])) if (contentDelta.kind === "thinking") {
+						if (reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
+						if (shouldEmitReasoning) appendThinkingDelta(contentDelta.signature, contentDelta.text);
+					} else appendPartitionedContent(contentDelta.text, Boolean(foundReasoningField));
+					const toolCallDeltas = normalizedDelta.toolCalls;
+					if (toolCallDeltas.length > 0) {
 						flushPartitionedContent();
 						sealNativeReasoningBeforeText();
 						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-						for (const toolCall of choiceDelta.tool_calls) {
+						for (const toolCall of toolCallDeltas) {
 							const block = ensureToolCallBlock(toolCall);
 							if (!block.id && toolCall.id) {
 								block.id = toolCall.id;
@@ -332,16 +318,21 @@ const streamOpenAICompletions = (model, context, options) => {
 				}
 			}
 			flushPartitionedContent();
-			for (const block of blocks) finishBlock(block);
-			if (options?.signal?.aborted) throw transportAbortError(options.signal);
-			if (output.stopReason === "aborted") throw new Error("Request was aborted");
-			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
-			if (!hasFinishReason) throw new Error("Stream ended without finish_reason");
-			const hasToolCalls = output.content.some((block) => block.type === "toolCall");
-			const hasVisibleText = output.content.some((block) => block.type === "text" && block.text.trim().length > 0);
-			if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
-			if (output.stopReason === "stop" && hasToolCalls && !hasVisibleText) output.stopReason = "toolUse";
-			if (hasToolCalls && output.stopReason !== "toolUse") output.content = output.content.filter((block) => block.type !== "toolCall");
+			let terminalError;
+			if (options?.signal?.aborted) terminalError = transportAbortError(options.signal);
+			else if (output.stopReason === "aborted") terminalError = /* @__PURE__ */ new Error("Request was aborted");
+			else if (output.stopReason === "error") terminalError = new Error(output.errorMessage || "Provider returned an error stop reason");
+			else if (!hasFinishReason) terminalError = /* @__PURE__ */ new Error("Stream ended without finish_reason");
+			if (terminalError) {
+				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
+				throw terminalError;
+			}
+			finalizeOpenAICompletionsToolCalls(output);
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
+				throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+			}
+			for (const block of blocks) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
 			if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
 			if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 			stream.push({
@@ -351,18 +342,17 @@ const streamOpenAICompletions = (model, context, options) => {
 			});
 			stream.end();
 		} catch (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.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			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();
@@ -453,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([]));
@@ -591,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,
@@ -602,29 +592,5 @@ function convertTools(tools, compat) {
 		}))
 	};
 }
-function parseChunkUsage(rawUsage, model) {
-	const promptTokens = rawUsage.prompt_tokens || 0;
-	const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
-	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-	const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-	const outputTokens = rawUsage.completion_tokens || 0;
-	const usage = {
-		input,
-		output: outputTokens,
-		cacheRead: cacheReadTokens,
-		cacheWrite: cacheWriteTokens,
-		totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	applyProviderReportedUsageCost(usage, rawUsage.cost);
-	return usage;
-}
 //#endregion
 export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };

package/dist/{openai-completions-compat-DBWjXoMZ.d.mts → openai-completions-compat-Dt3dcawL.d.mts}

@@ -1,5 +1,5 @@
-import { E as Model, O as OpenAICompletionsCompat } from "./types-bzp5k29J.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-B9GUmcra.mjs";
+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;

package/dist/{openai-responses-BT7A3sLu.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-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-Dog2WQiR.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 { _t as supportsOpenAITemperature } from "./openai-responses-stream-internal-Cw5txaGW.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 { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
-import { a as runResponsesStreamLifecycle, i as resolveResponsesReasoningEffort, n as convertResponsesMessages, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-pXl6Wd8S.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) => applyServiceTierPricing(usage, serviceTier, model)
-		},
-		formatError: formatOpenAIResponsesError
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
+		}
 	});
 	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 = {
@@ -118,21 +111,5 @@ function buildParams(model, context, options) {
 	applyCommonResponsesParams(params, model, context, options, { setDefaultReasoningOff: model.provider !== "github-copilot" });
 	return params;
 }
-function getServiceTierCostMultiplier(model, serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
-		default: return 1;
-	}
-}
-function applyServiceTierPricing(usage, serviceTier, model) {
-	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
-	if (multiplier === 1) return;
-	usage.cost.input *= multiplier;
-	usage.cost.output *= multiplier;
-	usage.cost.cacheRead *= multiplier;
-	usage.cost.cacheWrite *= multiplier;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
 //#endregion
 export { streamOpenAIResponses as n, streamSimpleOpenAIResponses as r, openai_responses_exports as t };

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 };