@openclaw/ai 2026.8.1-beta.3 → 2026.8.2

package/dist/openai-completions-D88orSJ9.mjs

@@ -1,632 +0,0 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { i as clampThinkingLevel } from "./sanitize-unicode-BP7HLLZn.mjs";
-import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { A as splitSystemPromptCacheBoundary, C as withProviderResponseHook, P as sortPromptCacheToolsByName, n as buildBaseOptions, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
-import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, h as tagUnresolvedTextAsCommentary, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, m as tagPendingCommentaryText, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagInterruptedTextPhases, r as convertMessages, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-9OONKyAm.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { c as isOpenAICompletionsThinkingEnabled, d as parseOpenAICompletionsUsage, f as readOpenAICompletionsContentDeltas, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIProviderAcceptanceHook, p as readOpenAICompletionsReasoningBatch, t as projectOpenAITools } from "./openai-tool-projection-CHGLt03m.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-5ygO2rZc.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
-var openai_completions_exports = /* @__PURE__ */ __exportAll({
-	convertMessages: () => convertMessages,
-	streamOpenAICompletions: () => streamOpenAICompletions,
-	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
-});
-function isEncryptedReasoningDetail(detail) {
-	if (typeof detail !== "object" || detail === null) return false;
-	const candidate = detail;
-	return candidate.type === "reasoning.encrypted" && typeof candidate.id === "string" && candidate.id.length > 0 && typeof candidate.data === "string" && candidate.data.length > 0;
-}
-const streamOpenAICompletions = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const output = {
-			role: "assistant",
-			content: [],
-			api: model.api,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
-		const provisionalCommentaryTags = /* @__PURE__ */ new Map();
-		let firstEventAbort;
-		try {
-			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const compat = resolveOpenAICompletionsCompat(model);
-			const visibleReasoningDetailTypes = new Set(compat.visibleReasoningDetailTypes);
-			const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
-			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
-			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
-			let params = buildParams(model, context, options, compat, cacheRetention);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== void 0) params = nextParams;
-			firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-			const requestOptions = {
-				signal: firstEventAbort.signal,
-				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-				maxRetries: options?.maxRetries ?? 0
-			};
-			const { data: openaiStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
-			const hookedOpenAIStream = withProviderResponseHook({
-				stream: openaiStream,
-				signal: firstEventAbort.signal,
-				abort: firstEventAbort.abort,
-				hook: createOpenAIProviderAcceptanceHook(options, response, model),
-				onReady: () => stream.push({
-					type: "start",
-					partial: output
-				})
-			});
-			let textBlock = null;
-			let textBlockSource;
-			let thinkingBlock = null;
-			let pendingInterruptedTextBlock = null;
-			let confirmedInterruptedTextBlock = null;
-			let hasFinishReason = false;
-			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();
-			const contentIndices = /* @__PURE__ */ new WeakMap();
-			let explicitVisibleTextBlocks;
-			const appendBlock = (block) => {
-				contentIndices.set(block, blocks.length);
-				blocks.push(block);
-			};
-			const getContentIndex = (block) => contentIndices.get(block) ?? -1;
-			const rememberFirstToolCallById = (id, block) => {
-				if (toolCallBlocksByFirstId.has(id)) return;
-				toolCallBlocksByFirstId.set(id, block);
-				const pendingDetail = pendingReasoningDetailsByToolCallId.get(id);
-				if (pendingDetail) {
-					block.thoughtSignature = pendingDetail;
-					pendingReasoningDetailsByToolCallId.delete(id);
-				}
-			};
-			const finishBlock = (block) => {
-				const contentIndex = getContentIndex(block);
-				if (contentIndex === -1 || finishedBlocks.has(block)) return;
-				finishedBlocks.add(block);
-				if (block.type === "text") stream.push({
-					type: "text_end",
-					contentIndex,
-					content: block.text,
-					partial: output
-				});
-				else if (block.type === "thinking") stream.push({
-					type: "thinking_end",
-					contentIndex,
-					content: block.thinking,
-					partial: output
-				});
-				else if (block.type === "toolCall") stream.push({
-					type: "toolcall_end",
-					contentIndex,
-					toolCall: block,
-					partial: output
-				});
-			};
-			const finishTextBlock = () => {
-				if (!textBlock) return;
-				finishBlock(textBlock);
-				textBlock = null;
-				textBlockSource = void 0;
-			};
-			const ensureTextBlock = (source) => {
-				if (textBlock && textBlockSource !== source) finishTextBlock();
-				if (!textBlock) {
-					textBlock = {
-						type: "text",
-						text: ""
-					};
-					textBlockSource = source;
-					if (source === "reasoning_detail") (explicitVisibleTextBlocks ??= /* @__PURE__ */ new Set()).add(textBlock);
-					appendBlock(textBlock);
-					stream.push({
-						type: "text_start",
-						contentIndex: getContentIndex(textBlock),
-						partial: output
-					});
-				}
-				return textBlock;
-			};
-			const ensureThinkingBlock = (thinkingSignature) => {
-				if (!thinkingBlock) {
-					thinkingBlock = {
-						type: "thinking",
-						thinking: "",
-						...thinkingSignature ? { thinkingSignature } : {}
-					};
-					appendBlock(thinkingBlock);
-					stream.push({
-						type: "thinking_start",
-						contentIndex: getContentIndex(thinkingBlock),
-						partial: output
-					});
-				}
-				return thinkingBlock;
-			};
-			const sealNativeReasoningBeforeText = () => {
-				if (thinkingBlock && !reasoningTagTextPartitioner.isInsideReasoning()) {
-					finishBlock(thinkingBlock);
-					thinkingBlock = null;
-				}
-			};
-			const appendTextDelta = (delta, source) => {
-				sealNativeReasoningBeforeText();
-				const block = ensureTextBlock(source);
-				block.text += delta;
-				if (pendingInterruptedTextBlock && delta.trim()) {
-					confirmedInterruptedTextBlock = pendingInterruptedTextBlock;
-					pendingInterruptedTextBlock = null;
-				}
-				stream.push({
-					type: "text_delta",
-					contentIndex: getContentIndex(block),
-					delta,
-					partial: output
-				});
-			};
-			const appendThinkingDelta = (thinkingSignature, delta) => {
-				const block = ensureThinkingBlock(thinkingSignature);
-				block.thinking += delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: getContentIndex(block),
-					delta,
-					partial: output
-				});
-			};
-			const appendReasoningDeltas = (reasoningDeltas) => {
-				for (const reasoningDelta of reasoningDeltas) if (reasoningDelta.kind === "thinking") {
-					if (!shouldEmitReasoning) continue;
-					finishTextBlock();
-					const signature = reasoningDelta.signature;
-					const thinkingSignature = model.provider === "opencode-go" && signature === "reasoning" ? "reasoning_content" : signature;
-					appendThinkingDelta(thinkingSignature, reasoningDelta.text);
-				} else appendTextDelta(reasoningDelta.text, reasoningDelta.source);
-			};
-			const ensureToolCallBlock = (toolCall) => {
-				const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
-				let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
-				if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
-				if (!block) {
-					block = {
-						type: "toolCall",
-						id: toolCall.id || "",
-						name: toolCall.function?.name || "",
-						arguments: {},
-						partialArgs: "",
-						streamIndex
-					};
-					if (streamIndex !== void 0) toolCallBlocksByIndex.set(streamIndex, block);
-					if (toolCall.id) {
-						toolCallBlocksById.set(toolCall.id, block);
-						rememberFirstToolCallById(toolCall.id, block);
-					}
-					appendBlock(block);
-					stream.push({
-						type: "toolcall_start",
-						contentIndex: getContentIndex(block),
-						partial: output
-					});
-				}
-				if (streamIndex !== void 0 && block.streamIndex === void 0) {
-					block.streamIndex = streamIndex;
-					toolCallBlocksByIndex.set(streamIndex, block);
-				}
-				if (toolCall.id) toolCallBlocksById.set(toolCall.id, block);
-				return block;
-			};
-			const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
-			const appendPartitionedContent = (text, hasMirroredReasoning) => {
-				const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(text) : reasoningTagTextPartitioner.pushVisible(text);
-				for (const delta of routedDeltas) if (delta.kind === "text") appendTextDelta(delta.text);
-			};
-			const flushPartitionedContent = () => {
-				for (const delta of reasoningTagTextPartitioner.flush()) if (delta.kind === "text") appendTextDelta(delta.text);
-			};
-			const sealTextBeforeReasoning = () => {
-				if (!textBlock && !reasoningTagTextPartitioner.hasPending()) return;
-				flushPartitionedContent();
-				if (!textBlock) return;
-				if (textBlockSource !== "reasoning_detail" && textBlock.text.trim()) pendingInterruptedTextBlock = textBlock;
-				finishTextBlock();
-			};
-			const beginReasoning = (hasFollowingVisibleText, forceStrict = false) => {
-				if (!output.openclawDelivery?.textPhaseRequiresTerminal) output.openclawDelivery = {
-					...output.openclawDelivery,
-					textPhaseRequiresTerminal: true
-				};
-				if (forceStrict || reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
-				if (!hasFollowingVisibleText || !reasoningTagTextPartitioner.hasPendingSyntax()) sealTextBeforeReasoning();
-			};
-			const guardedOpenaiStream = withFirstStreamEventTimeout(hookedOpenAIStream, {
-				provider: model.provider,
-				api: model.api,
-				model: model.id,
-				timeoutMs: getFirstStreamEventTimeoutMs(options) ?? 0,
-				stage: "completions",
-				abort: firstEventAbort.abort,
-				onTimeout: getFirstStreamEventTimeoutHandler(options),
-				hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
-			});
-			for await (const chunk of guardedOpenaiStream) {
-				if (!chunk || typeof chunk !== "object") continue;
-				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 = 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 = 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 rawChoiceDelta = choice.delta ?? choice.message;
-				if (rawChoiceDelta) for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
-					const choiceDelta = normalizedDelta.delta;
-					const reasoningBatch = readOpenAICompletionsReasoningBatch(choiceDelta, visibleReasoningDetailTypes);
-					const reasoningDeltas = reasoningBatch.deltas;
-					const hasReasoningThinking = reasoningBatch.hasThinking;
-					const contentDeltas = readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, reasoningBatch.mirroredThinking);
-					const lastVisibleTextIndex = contentDeltas.findLastIndex((delta) => delta.kind === "text");
-					const hasSameChunkVisibleText = reasoningBatch.hasVisibleText || lastVisibleTextIndex !== -1;
-					if (hasReasoningThinking) {
-						beginReasoning(hasSameChunkVisibleText, true);
-						appendReasoningDeltas(reasoningDeltas);
-					}
-					for (const [contentDeltaIndex, contentDelta] of contentDeltas.entries()) if (contentDelta.kind === "thinking") {
-						beginReasoning(contentDeltaIndex < lastVisibleTextIndex);
-						if (shouldEmitReasoning) appendThinkingDelta(contentDelta.signature, contentDelta.text);
-					} else appendPartitionedContent(contentDelta.text, hasReasoningThinking);
-					if (!hasReasoningThinking) appendReasoningDeltas(reasoningDeltas);
-					const toolCallDeltas = normalizedDelta.toolCalls;
-					if (toolCallDeltas.length > 0) {
-						flushPartitionedContent();
-						sealNativeReasoningBeforeText();
-						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-						for (const toolCall of toolCallDeltas) {
-							const block = ensureToolCallBlock(toolCall);
-							if (!block.id && toolCall.id) {
-								block.id = toolCall.id;
-								toolCallBlocksById.set(toolCall.id, block);
-								rememberFirstToolCallById(toolCall.id, block);
-							}
-							if (!block.name && toolCall.function?.name) block.name = toolCall.function.name;
-							let delta = "";
-							if (toolCall.function?.arguments) {
-								delta = toolCall.function.arguments;
-								block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
-								block.arguments = parseStreamingJson(block.partialArgs);
-							}
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: getContentIndex(block),
-								delta,
-								partial: output
-							});
-						}
-					}
-					const reasoningDetails = choiceDelta.reasoning_details;
-					if (Array.isArray(reasoningDetails)) {
-						for (const detail of reasoningDetails) if (isEncryptedReasoningDetail(detail)) {
-							const serializedDetail = JSON.stringify(detail);
-							const matchingToolCall = toolCallBlocksByFirstId.get(detail.id);
-							if (matchingToolCall) matchingToolCall.thoughtSignature = serializedDetail;
-							else pendingReasoningDetailsByToolCallId.set(detail.id, serializedDetail);
-						}
-					}
-				}
-			}
-			flushPartitionedContent();
-			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"));
-			}
-			if (output.stopReason !== "toolUse" && confirmedInterruptedTextBlock) tagInterruptedTextPhases(output.content, confirmedInterruptedTextBlock, explicitVisibleTextBlocks);
-			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({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			const terminal = projectProviderError(error, options?.signal);
-			Object.assign(output, terminal);
-			finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
-			clearPendingCommentaryText(provisionalCommentaryTags);
-			tagUnresolvedTextAsCommentary(output);
-			for (const block of output.content) {
-				delete block.index;
-				delete block.partialArgs;
-				delete block.streamIndex;
-			}
-			stream.push({
-				type: "error",
-				reason: terminal.stopReason,
-				error: output
-			});
-			stream.end();
-		} finally {
-			firstEventAbort?.dispose();
-		}
-	})();
-	return stream;
-};
-const streamSimpleOpenAICompletions = (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 clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
-	const reasoningEffort = clampedReasoning === "off" ? void 0 : clampedReasoning === "max" ? "xhigh" : clampedReasoning;
-	const toolChoice = options?.toolChoice;
-	return streamOpenAICompletions(model, context, {
-		...base,
-		reasoningEffort,
-		toolChoice
-	});
-};
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = resolveOpenAICompletionsCompat(model)) {
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const headers = { ...model.headers };
-	if (model.provider === "github-copilot") {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-	if (sessionId && compat.sessionAffinity !== "none") if (compat.sessionAffinity === "openrouter") headers["x-session-id"] = sessionId;
-	else {
-		headers.session_id = sessionId;
-		headers["x-client-request-id"] = sessionId;
-		headers["x-session-affinity"] = sessionId;
-	}
-	if (optionsHeaders) Object.assign(headers, optionsHeaders);
-	const defaultHeaders = model.provider === "cloudflare-ai-gateway" ? {
-		...headers,
-		Authorization: headers.Authorization ?? null,
-		"cf-aig-authorization": `Bearer ${apiKey}`
-	} : headers;
-	return new OpenAI({
-		apiKey,
-		baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders,
-		fetch: getAiTransportHost().buildModelFetch(model)
-	});
-}
-function buildParams(model, context, options, compat = resolveOpenAICompletionsCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
-	const cacheControl = getCompatCacheControl(compat, cacheRetention);
-	const cacheOptOutIndexes = /* @__PURE__ */ new Set();
-	const messages = convertMessages(model, context, compat, {
-		cacheOptOutIndexes,
-		preserveSystemPromptCacheBoundary: cacheControl !== void 0
-	});
-	const supportsPromptCacheKey = model.baseUrl.includes("api.openai.com") || compat.supportsPromptCacheKey;
-	const promptCacheKey = supportsPromptCacheKey && cacheRetention !== "none" ? clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId) : void 0;
-	const params = {
-		model: model.id,
-		messages,
-		stream: true,
-		prompt_cache_key: promptCacheKey,
-		prompt_cache_retention: supportsPromptCacheKey && cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0
-	};
-	if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
-	if (compat.supportsStore) params.store = false;
-	if (options?.maxTokens) {
-		const maxTokens = clampOpenAICompletionsMaxTokens(model, options.maxTokens);
-		if (compat.maxTokensField === "max_tokens") params.max_tokens = maxTokens;
-		else params.max_completion_tokens = maxTokens;
-	}
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
-	const requestedResponseFormat = options?.responseFormat;
-	const responseFormat = requestedResponseFormat === void 0 ? void 0 : resolveOpenAICompletionsResponseFormat(shouldOmitOllamaCompatResponseFormat({
-		provider: model.provider,
-		baseUrl: model.baseUrl,
-		hasTools: () => Boolean(context.tools?.length)
-	}) ? void 0 : requestedResponseFormat, compat.supportsJsonSchemaResponseFormat);
-	if (responseFormat !== void 0) params.response_format = responseFormat;
-	let toolProjection;
-	if (context.tools) {
-		const converted = convertTools(context.tools, compat);
-		toolProjection = converted.projection;
-		if (converted.tools.length > 0) params.tools = converted.tools;
-		else if (hasToolCallHistory(context.messages)) params.tools = [];
-		if (compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
-	} 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([]));
-		if (toolChoice !== void 0) params.tool_choice = toolChoice;
-	}
-	const reasoningEffortMap = resolveOpenAIReasoningEffortMap(model);
-	const thinkingLevelMap = model.thinkingLevelMap;
-	const reasoningEffort = options?.reasoningEffort === void 0 ? void 0 : reasoningEffortMap[options.reasoningEffort] ?? thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	const reasoningEnabled = reasoningEffort !== void 0 && reasoningEffort !== "none";
-	const offReasoningEffort = reasoningEffortMap.off ?? model.thinkingLevelMap?.off;
-	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = reasoningEnabled ? {
-		type: "enabled",
-		clear_thinking: false
-	} : { type: "disabled" };
-	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = reasoningEnabled;
-	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = {
-		enable_thinking: reasoningEnabled,
-		preserve_thinking: true
-	};
-	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
-		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
-		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
-	} else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
-		const openRouterParams = params;
-		if (reasoningEnabled) openRouterParams.reasoning = { effort: reasoningEffort };
-		else if (offReasoningEffort !== null) openRouterParams.reasoning = { effort: offReasoningEffort ?? "none" };
-	} else if (compat.thinkingFormat === "together" && model.reasoning) {
-		const togetherParams = params;
-		togetherParams.reasoning = { enabled: reasoningEnabled };
-		if (reasoningEnabled && compat.supportsReasoningEffort) togetherParams.reasoning_effort = reasoningEffort;
-	} else if (reasoningEnabled && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
-	else if (model.reasoning && compat.supportsReasoningEffort) {
-		if (typeof offReasoningEffort === "string") params.reasoning_effort = offReasoningEffort;
-	}
-	if (compat.openRouterRouting) params.provider = compat.openRouterRouting;
-	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
-		const routing = model.compat.vercelGatewayRouting;
-		if (routing.only || routing.order) {
-			const gatewayOptions = {};
-			if (routing.only) gatewayOptions.only = routing.only;
-			if (routing.order) gatewayOptions.order = routing.order;
-			params.providerOptions = { gateway: gatewayOptions };
-		}
-	}
-	return params;
-}
-function clampOpenAICompletionsMaxTokens(model, requestedMaxTokens) {
-	const modelMaxTokens = typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
-	return modelMaxTokens === void 0 || requestedMaxTokens <= modelMaxTokens ? requestedMaxTokens : modelMaxTokens;
-}
-function getCompatCacheControl(compat, cacheRetention) {
-	if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") return;
-	const ttl = cacheRetention === "long" && compat.supportsLongCacheRetention ? "1h" : void 0;
-	return {
-		type: "ephemeral",
-		...ttl ? { ttl } : {}
-	};
-}
-function applyAnthropicCacheControl(messages, tools, cacheControl, cacheOptOutIndexes) {
-	addCacheControlToSystemPrompt(messages, cacheControl);
-	addCacheControlToLastTool(tools, cacheControl);
-	addCacheControlToLastConversationMessage(messages, cacheControl, cacheOptOutIndexes);
-}
-function addCacheControlToSystemPrompt(messages, cacheControl) {
-	for (const message of messages) if (message.role === "system" || message.role === "developer") {
-		addCacheControlToInstructionMessage(message, cacheControl);
-		return;
-	}
-}
-function addCacheControlToLastConversationMessage(messages, cacheControl, cacheOptOutIndexes) {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i];
-		if (!message || cacheOptOutIndexes.has(i)) continue;
-		if (message.role === "user" || message.role === "assistant") {
-			if (addCacheControlToMessage(message, cacheControl)) return;
-		}
-	}
-}
-function addCacheControlToLastTool(tools, cacheControl) {
-	if (!tools || tools.length === 0) return;
-	const lastTool = tools.at(-1);
-	if (!lastTool) return;
-	lastTool.cache_control = cacheControl;
-}
-function addCacheControlToInstructionMessage(message, cacheControl) {
-	return addCacheControlToTextContent(message, cacheControl);
-}
-function addCacheControlToMessage(message, cacheControl) {
-	if (message.role === "user" || message.role === "assistant") return addCacheControlToTextContent(message, cacheControl);
-	return false;
-}
-function addCacheControlToTextContent(message, cacheControl) {
-	const content = message.content;
-	if (typeof content === "string") {
-		if (content.length === 0) return false;
-		message.content = buildCacheControlledTextParts(content, cacheControl);
-		return true;
-	}
-	if (!Array.isArray(content)) return false;
-	for (let i = content.length - 1; i >= 0; i--) {
-		const part = content[i];
-		if (part?.type === "text") {
-			const text = part.text;
-			content.splice(i, 1, ...buildCacheControlledTextParts(text, cacheControl));
-			return true;
-		}
-	}
-	return false;
-}
-function buildCacheControlledTextParts(text, cacheControl) {
-	const split = splitSystemPromptCacheBoundary(text);
-	if (!split) return [{
-		type: "text",
-		text,
-		cache_control: cacheControl
-	}];
-	const parts = [];
-	if (split.stablePrefix) parts.push({
-		type: "text",
-		text: split.stablePrefix,
-		cache_control: cacheControl
-	});
-	if (split.dynamicSuffix) parts.push({
-		type: "text",
-		text: split.dynamicSuffix
-	});
-	return parts.length > 0 ? parts : [{
-		type: "text",
-		text: ""
-	}];
-}
-function convertTools(tools, compat) {
-	const projection = projectOpenAITools(tools);
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => ({
-			type: "function",
-			function: {
-				name: tool.name,
-				description: tool.description,
-				parameters: tool.parameters,
-				...compat.supportsStrictMode && { strict: false }
-			}
-		}))
-	};
-}
-//#endregion
-export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };