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

package/dist/{openai-reasoning-compat-YgeLncHw.mjs → openai-reasoning-compat-DKebnIBL.mjs}

@@ -1,7 +1,8 @@
-import { g as isRecord, i as transformMessages, p as normalizeLowercaseStringOrEmpty } from "./host-Dog2WQiR.mjs";
+import { _ as normalizeLowercaseStringOrEmpty, b as isRecord, i as transformMessages } from "./host-Bl7Kgddo.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
-import { c as resolveProviderRequestCapabilities } from "./openai-tool-projection-OhX64DoP.mjs";
+import { a as isImageWithMediaPayload, h as stripSystemPromptCacheBoundary, o as truncateUtf16Safe, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-Dvkp2Dus.mjs";
+import { o as resolveProviderRequestCapabilities } from "./tool-schema-json-projection-B1b-XCn5.mjs";
+import { randomUUID } from "node:crypto";
 //#region packages/ai/src/utils/assistant-text-phase.ts
 function isAssistantTextPhaseBlock(block) {
 	if (!block || typeof block !== "object") return false;
@@ -196,7 +197,7 @@ function convertMessages(model, context, compat, options = {}) {
 	const params = [];
 	const normalizeToolCallId = (id) => {
 		if (id.includes("|")) return id.slice(0, id.indexOf("|")).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-		if (model.provider === "openai") return id.length > 40 ? id.slice(0, 40) : id;
+		if (model.provider === "openai") return id.length > 40 ? truncateUtf16Safe(id, 40) : id;
 		return id;
 	};
 	const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
@@ -253,7 +254,7 @@ function convertMessages(model, context, compat, options = {}) {
 				type: "text",
 				text: sanitizeSurrogates(block.text)
 			}));
-			const assistantText = assistantTextParts.map((part) => part.text).join("");
+			const assistantText = assistantTextParts.map((part) => part.text).join("\n");
 			const nonEmptyThinkingBlocks = msg.content.filter(isThinkingContentBlock).filter((block) => block.thinking.trim().length > 0);
 			if (nonEmptyThinkingBlocks.length > 0) if (compat.requiresThinkingAsText) assistantMsg.content = [{
 				type: "text",
@@ -338,6 +339,146 @@ function convertMessages(model, context, compat, options = {}) {
 	return params;
 }
 //#endregion
+//#region packages/ai/src/providers/openai-completions-tool-calls.ts
+const MAX_BUFFERED_LEGACY_TOOL_CALL_ARGUMENT_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS = 1024;
+/** Normalize the SDK's legacy single-function lane into its modern tool-call shape. */
+function createOpenAICompletionsToolCallDeltaNormalizer() {
+	let sawModernToolCall = false;
+	let pendingLegacyArgumentBytes = 0;
+	let pendingFollowingDeltaBytes = 0;
+	let pendingLegacyToolCall;
+	const pendingFollowingDeltas = [];
+	const takePendingFollowingDeltas = () => {
+		pendingFollowingDeltaBytes = 0;
+		return pendingFollowingDeltas.splice(0).map((delta) => ({
+			delta,
+			toolCalls: []
+		}));
+	};
+	const bufferFollowingDelta = (delta) => {
+		const nextDeltaBytes = Buffer.byteLength(JSON.stringify(delta), "utf8");
+		if (pendingFollowingDeltaBytes + nextDeltaBytes > MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES || pendingFollowingDeltas.length >= MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS) throw new Error("Exceeded legacy tool-call content buffer limit");
+		pendingFollowingDeltaBytes += nextDeltaBytes;
+		pendingFollowingDeltas.push(delta);
+	};
+	const withoutToolCalls = (delta) => {
+		const ordinaryDelta = { ...delta };
+		delete ordinaryDelta.function_call;
+		delete ordinaryDelta.tool_calls;
+		return ordinaryDelta;
+	};
+	const hasObservableContent = (value) => {
+		if (typeof value === "string") return value.length > 0;
+		if (Array.isArray(value)) return value.some(hasObservableContent);
+		if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
+		return false;
+	};
+	const hasOrdinaryContent = (delta) => Object.entries(delta).some(([field, value]) => field !== "role" && hasObservableContent(value));
+	return (delta, finishReason) => {
+		const ordinaryDelta = withoutToolCalls(delta);
+		if (delta.tool_calls && delta.tool_calls.length > 0) {
+			const precedingDeltas = takePendingFollowingDeltas();
+			sawModernToolCall = true;
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...precedingDeltas, {
+				delta: ordinaryDelta,
+				toolCalls: delta.tool_calls
+			}];
+		}
+		const functionCall = delta.function_call;
+		if (sawModernToolCall) return [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
+		const leadingDeltas = [];
+		if (hasOrdinaryContent(ordinaryDelta)) if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
+		else leadingDeltas.push({
+			delta: ordinaryDelta,
+			toolCalls: []
+		});
+		if (functionCall && (functionCall.name || functionCall.arguments)) {
+			const nextFunctionName = pendingLegacyToolCall?.function?.name ? void 0 : functionCall.name;
+			const nextArgumentBytes = Buffer.byteLength(functionCall.arguments ?? "", "utf8") + Buffer.byteLength(nextFunctionName ?? "", "utf8");
+			if (pendingLegacyArgumentBytes + nextArgumentBytes > MAX_BUFFERED_LEGACY_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+			pendingLegacyArgumentBytes += nextArgumentBytes;
+			pendingLegacyToolCall ??= {
+				index: 0,
+				id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+				type: "function",
+				function: {}
+			};
+			const pendingFunction = pendingLegacyToolCall.function ??= {};
+			if (nextFunctionName) pendingFunction.name = nextFunctionName;
+			if (functionCall.arguments) pendingFunction.arguments = (pendingFunction.arguments ?? "") + functionCall.arguments;
+		}
+		if (!pendingLegacyToolCall) return leadingDeltas.length > 0 ? leadingDeltas : [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		if (finishReason === "function_call") {
+			const confirmedLegacyToolCall = pendingLegacyToolCall;
+			pendingLegacyToolCall = void 0;
+			pendingLegacyArgumentBytes = 0;
+			return [
+				...leadingDeltas,
+				{
+					delta: {},
+					toolCalls: [confirmedLegacyToolCall]
+				},
+				...takePendingFollowingDeltas()
+			];
+		}
+		if (finishReason) {
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...leadingDeltas, ...takePendingFollowingDeltas()];
+		}
+		return leadingDeltas;
+	};
+}
+/** Publish only executable calls; streaming scratch state never belongs in replay. */
+function finalizeOpenAICompletionsToolCalls(output, options = {}) {
+	const isToolCall = (block) => block.type === "toolCall";
+	const hasToolCalls = output.content.some(isToolCall);
+	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
+	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => {
+		const candidate = block;
+		return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
+	})) output.stopReason = "toolUse";
+	if (output.stopReason !== "toolUse") {
+		if (hasToolCalls) output.content = output.content.filter((block) => !isToolCall(block));
+		return;
+	}
+	for (const block of output.content) {
+		if (!isToolCall(block)) continue;
+		const toolCall = block;
+		let completeArguments;
+		try {
+			completeArguments = typeof toolCall.partialArgs === "string" && toolCall.partialArgs.trim().length > 0 ? JSON.parse(toolCall.partialArgs) : void 0;
+		} catch {
+			completeArguments = void 0;
+		}
+		if (typeof toolCall.name !== "string" || toolCall.name.trim().length === 0 || !isRecord(completeArguments)) {
+			output.stopReason = "error";
+			output.errorMessage = "Provider returned an incomplete or malformed tool call";
+			output.content = output.content.filter((candidate) => !isToolCall(candidate));
+			return;
+		}
+		toolCall.arguments = completeArguments;
+	}
+	for (let contentIndex = 0; contentIndex < output.content.length; contentIndex += 1) {
+		const block = output.content[contentIndex];
+		if (!block || !isToolCall(block)) continue;
+		delete block.partialArgs;
+		delete block.streamIndex;
+		options.onConfirmedToolCall?.(block, contentIndex);
+	}
+}
+//#endregion
 //#region packages/ai/src/providers/openai-stop-reason.ts
 function mapOpenAIStopReason(reason, options) {
 	if (reason === null) return { stopReason: "stop" };
@@ -393,4 +534,4 @@ function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
 	};
 }
 //#endregion
-export { resolveOpenAICompletionsCompat as a, clearPendingCommentaryText as c, detectOpenAICompletionsCompat as i, rememberPendingCommentaryTags as l, mapOpenAIStopReason as n, resolveOpenAICompletionsResponseFormat as o, convertMessages as r, shouldOmitOllamaCompatResponseFormat as s, resolveOpenAIReasoningEffortMap as t, tagPendingCommentaryText as u };
+export { convertMessages as a, resolveOpenAICompletionsResponseFormat as c, rememberPendingCommentaryTags as d, tagPendingCommentaryText as f, finalizeOpenAICompletionsToolCalls as i, shouldOmitOllamaCompatResponseFormat as l, mapOpenAIStopReason as n, detectOpenAICompletionsCompat as o, createOpenAICompletionsToolCallDeltaNormalizer as r, resolveOpenAICompletionsCompat as s, resolveOpenAIReasoningEffortMap as t, clearPendingCommentaryText as u };

package/dist/{openai-responses-BT7A3sLu.mjs → openai-responses-Bdx3V_Yu.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-CEV9t6da.mjs";
+import { n as getAiTransportHost } from "./host-Bl7Kgddo.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 { c as buildBaseOptions } from "./tool-result-text-Dvkp2Dus.mjs";
+import { pt as supportsOpenAITemperature } from "./openai-responses-stream-internal-Bl8YyVtF.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 { 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({
@@ -54,7 +54,7 @@ const streamOpenAIResponses = (model, context, options) => {
 		buildParams: () => buildParams(model, context, options),
 		processStreamOptions: {
 			serviceTier: options?.serviceTier,
-			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 		},
 		formatError: formatOpenAIResponsesError
 	});
@@ -118,21 +118,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-BBKBfAqR.d.mts

@@ -0,0 +1,116 @@
+import { E as Model, O as OpenAICompletionsCompat, n as Api } from "./types-CH7ReIcU.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-Dn4_SZI2.mjs";
+import { d as OpenAIApiReasoningEffort, f as OpenAIReasoningEffort, i as BaseOpenAIStreamOptions } from "./provider-options-C5kYML7i.mjs";
+import { FunctionTool, ResponseCreateParamsStreaming, ResponseInput, ResponseReasoningItem } from "openai/resources/responses/responses.js";
+
+//#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
+//#region packages/ai/src/transports/openai-responses-contracts.d.ts
+declare const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
+type OpenAIResponsesReasoningReplayMetadata = {
+  v: 1;
+  source: "openai-responses";
+  provider: string;
+  api: Api;
+  model: string;
+  baseUrlHash?: string;
+  sessionHash?: string;
+  authProfileHash?: string;
+};
+type ReplayableResponseReasoningItem = Omit<ResponseReasoningItem, "id"> & {
+  id?: string;
+  [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]?: OpenAIResponsesReasoningReplayMetadata;
+};
+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" | "native-codex-websocket" | "native-codex-sse";
+  payloadVariant: "initial" | "encrypted-content-retry";
+  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 OpenAIResponsesReplayContext = {
+  provider: string;
+  api: Api;
+  model: string;
+  baseUrlHash?: string;
+  sessionHash?: string;
+  authProfileHash?: string;
+};
+type OpenAIResponsesRequestParams = {
+  model: string;
+  input: ResponseInput;
+  stream: true;
+  instructions?: string;
+  prompt_cache_key?: string;
+  prompt_cache_retention?: "24h";
+  metadata?: Record<string, 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 { ReplayableResponseReasoningItem as a, ResolvedOpenAICompletionsCompat as c, OpenAIResponsesRequestParams as i, detectOpenAICompletionsCompat as l, OpenAIResponsesReasoningReplayMetadata as n, ResponsesPromptObservation as o, OpenAIResponsesReplayContext as r, responsesPromptObserver as s, OpenAIResponsesOptions as t, resolveOpenAICompletionsCompat as u };

package/dist/openai-responses-prompt-observer-internal-DDZPxRfr.mjs

@@ -0,0 +1,46 @@
+import { h as stripSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
+import { B as responsesPromptObserver } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
+import { u as sanitizeTransportPayloadText } from "./transport-stream-shared-CPNv7A3r.mjs";
+//#region packages/normalization-core/src/error-coercion.ts
+/**
+* Normalizes an unknown thrown value into an Error. Non-Error objects become
+* the `cause` and have their enumerable fields copied so structured details
+* (codes, statuses) survive the coercion.
+*/
+function toErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-prompt-observer-internal.ts
+function readFinalResponsesPrompt(request) {
+	if (typeof request.instructions === "string") return ["instructions", request.instructions];
+	const message = (Array.isArray(request.input) ? request.input : []).find((item) => {
+		const role = item.role;
+		return role === "developer" || role === "system";
+	});
+	if (!message) return ["missing", ""];
+	const content = message.content;
+	const observedPrompt = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part.type === "input_text" ? [part.text] : []).join("") : "";
+	return [message.role === "developer" ? "input.developer" : "input.system", observedPrompt];
+}
+function createResponsesPromptEgressObserver(options, assembledPrompt) {
+	const observer = options ? responsesPromptObserver.get(options) : void 0;
+	if (!observer) return;
+	const expectedPrompt = sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(assembledPrompt ?? ""));
+	return (request, metadata) => {
+		const [promptSource, observedPrompt] = readFinalResponsesPrompt(request);
+		observer({
+			...metadata,
+			promptSource,
+			expectedChars: expectedPrompt.length,
+			observedChars: observedPrompt.length,
+			matchesAssembledPrompt: promptSource !== "missing" && observedPrompt === expectedPrompt
+		});
+	};
+}
+//#endregion
+export { toErrorObject as n, createResponsesPromptEgressObserver as t };

package/dist/{openai-responses-shared-pXl6Wd8S.mjs → openai-responses-shared-CCyMvg7M.mjs}

@@ -1,14 +1,14 @@
-import { i as transformMessages, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
+import { i as transformMessages, n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { r as clampThinkingLevel } from "./model-utils-Dau5dlgm.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
-import { t as projectOpenAITools } from "./openai-tool-projection-OhX64DoP.mjs";
-import { l as clampThinkingLevel } from "./number-coercion-DvG7SNMg.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
-import { Y as normalizeOpenAIStrictToolParameters, Z as resolveOpenAIProjectedToolsStrictToolFlag, _t as supportsOpenAITemperature, gt as supportsOpenAIReasoningEffort, mt as resolveOpenAIReasoningEffortForModel, n as processResponsesStream, q as findOpenAIStrictToolProjectionDiagnostics } from "./openai-responses-stream-internal-Cw5txaGW.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BBys9hSb.mjs";
-import { t as shortHash } from "./hash-CHgqbJmD.mjs";
+import { a as isImageWithMediaPayload, h as stripSystemPromptCacheBoundary, r as extractToolResultText, t as describeToolResultMediaPlaceholder, v as sortPromptCacheToolsByName } from "./tool-result-text-Dvkp2Dus.mjs";
+import { G as normalizeOpenAIStrictToolParameters, U as findOpenAIStrictToolProjectionDiagnostics, ft as supportsOpenAIReasoningEffort, n as processResponsesStream, pt as supportsOpenAITemperature, q as resolveOpenAIProjectedToolsStrictToolFlag, ut as resolveOpenAIReasoningEffortForModel } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
+import { d as transportAbortError } from "./transport-stream-shared-CPNv7A3r.mjs";
+import { l as projectOpenAITools } from "./openai-transport-shared-Cipt7egQ.mjs";
+import { 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 "./transform-messages-C8mBqZxF.mjs";
+import { t as shortHash } from "./hash-CHgqbJmD.mjs";
+import "./transform-messages-DfjpNXNQ.mjs";
 import { createHash } from "node:crypto";
 //#region packages/ai/src/providers/openai-responses-tools.ts
 const LOG_SUBSYSTEM = "llm/openai-responses";
@@ -294,6 +294,17 @@ function createResponsesAssistantOutput(model, api = model.api) {
 		timestamp: Date.now()
 	};
 }
+function applyResponsesServiceTierPricing(usage, serviceTier, model) {
+	let multiplier = 1;
+	if (serviceTier === "flex") multiplier = .5;
+	else if (serviceTier === "priority") multiplier = model.id === "gpt-5.5" ? 2.5 : 2;
+	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;
+}
 function resolveResponsesReasoningEffort(model, reasoning) {
 	const clampedReasoning = reasoning ? clampThinkingLevel(model, reasoning) : void 0;
 	if (!clampedReasoning || clampedReasoning === "off") return;
@@ -389,4 +400,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-export { runResponsesStreamLifecycle as a, resolveResponsesReasoningEffort as i, convertResponsesMessages as n, convertResponsesToolPayload as o, createResponsesAssistantOutput as r, applyCommonResponsesParams as t };
+export { resolveResponsesReasoningEffort as a, createResponsesAssistantOutput as i, applyResponsesServiceTierPricing as n, runResponsesStreamLifecycle as o, convertResponsesMessages as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t };