@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/openai-completions-DNr3mUsn.mjs

@@ -1,1430 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { r as __exportAll } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { C as warn, N as $env, _ as parseStreamingJson, v as parseStreamingJsonThrottled } from "./src-AELUUb5U.mjs";
-import { B as OpenAIHttpError, V as ProviderHttpError, _ as AbortError, c as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, C as kStreamingLastParseLen, F as normalizeSchemaForMoonshot, L as sanitizeSchemaForGrammar, M as adaptSchemaForStrict, T as renderDemotedThinking, _ as isDemotedThinking, c as resolveCacheRetention, h as transformMessages, j as NO_STRICT, k as flattenExclusiveRequiredRootUnion, o as normalizeSystemPrompts } from "./utils-cZX3f_Ls.mjs";
-import { At as withReplaySafeStreamRetry, C as applyChatCompletionsToolStream, D as applyOpenAIServiceTier, E as applyOpenAIGatewayRouting, H as createOpenAIStrictToolsState, I as calculateOpenAIUsageAccounting, L as clearOpenAIStrictToolsState, N as applyWireModelIdTransform, O as applyProviderReportedCost, S as applyChatCompletionsReasoningParams, St as shouldRetryWithoutStrictTools, T as applyOpenAIExtraBody, Tt as mapToOpenAICompletionsToolChoice, V as createInitialResponsesAssistantMessage, W as disableStrictToolsForScope, _t as resolveOpenAIOutputTokenParam, at as isCompiledGrammarTooLargeStrictError, dt as parseAzureDeploymentNameMap, et as getOpenAIPromptCacheKey, gt as resolveOpenAICompletionsOutputClamp, ht as resolveOpenAICompatPolicy, kt as hasVisibleAssistantContent, n as getEnvApiKey, nt as getOpenAIStrictToolsScope, st as isStrictToolsDisabledForScope, vt as resolveOpenAIRequestSetup, wt as isForcedToolChoice, xt as shouldDropAutoToolChoiceForReasoning } from "./stream-AVOoe5Hj.mjs";
-import { s as resolveWireModelId } from "./anthropic-wire-lbGAFzYb.mjs";
-import { t as createAbortSourceTracker } from "./abort-DZ54CaKU.mjs";
-import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
-import { i as resolveCopilotRequestIdentity, o as wrapFetchForCopilotFallback } from "./github-copilot-headers-DnjGEbko.mjs";
-import { n as isOpenAICompletionsVisionSupported, r as joinTextWithImagePlaceholder, t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-BCpXWUj3.mjs";
-import { t as findStrictToolSchemaViolation } from "./strict-tool-validation-CBTz1dAA.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { n as clinePassClientHeaders } from "./cline-pass-BT9CBEOj.mjs";
-import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs, s as iterateWithTerminalGrace } from "./idle-iterator-D0ZXEcUq.mjs";
-import { t as getKimiCommonHeaders } from "./kimi-T9NldEIJ.mjs";
-import { t as notifyProviderResponse } from "./provider-response-SqKSkkUc.mjs";
-import { a as getOpenAIReasoningEffortFallback, c as postOpenAIStream, i as createOpenAIReasoningEffortFallbackState, n as clearOpenAIReasoningEffortFallbackState, o as rememberOpenAIReasoningEffortFallback, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-Ju-5pSR8.mjs";
-import { t as StreamMarkupHealing } from "./stream-markup-healing-CN3RsqG9.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/openai-completions.ts
-var openai_completions_exports = /* @__PURE__ */ __exportAll({
-	convertMessages: () => convertMessages,
-	isOpenAICompletionsProgressChunk: () => isOpenAICompletionsProgressChunk,
-	parseChunkUsage: () => parseChunkUsage,
-	streamOpenAICompletions: () => streamOpenAICompletions
-});
-const GEMINI_THOUGHT_SIGNATURE_NAMESPACES = ["google", "vertex"];
-function getGeminiThoughtSignatureExtraContent(value) {
-	if (typeof value !== "object" || value === null) return void 0;
-	for (const namespace of GEMINI_THOUGHT_SIGNATURE_NAMESPACES) {
-		const providerContent = Reflect.get(value, namespace);
-		if (typeof providerContent !== "object" || providerContent === null) continue;
-		const thoughtSignature = Reflect.get(providerContent, "thought_signature");
-		if (typeof thoughtSignature !== "string" || thoughtSignature.length === 0) continue;
-		return namespace === "google" ? { google: { thought_signature: thoughtSignature } } : { vertex: { thought_signature: thoughtSignature } };
-	}
-}
-function parseGeminiThoughtSignatureExtraContent(thoughtSignature) {
-	if (!thoughtSignature) return void 0;
-	try {
-		return getGeminiThoughtSignatureExtraContent(JSON.parse(thoughtSignature));
-	} catch {
-		return;
-	}
-}
-function firstPositiveNumber(...values) {
-	for (const value of values) if (typeof value === "number" && value > 0) return value;
-	return 0;
-}
-function hasPositiveCacheReadTokenField(rawUsage) {
-	const usageLike = rawUsage;
-	if (typeof usageLike.cached_tokens === "number" && usageLike.cached_tokens > 0) return true;
-	if (typeof usageLike.prompt_cache_hit_tokens === "number" && usageLike.prompt_cache_hit_tokens > 0) return true;
-	if (typeof usageLike.cachedContentTokenCount === "number" && usageLike.cachedContentTokenCount > 0) return true;
-	const rawPromptTokenDetails = usageLike.prompt_tokens_details;
-	if (typeof rawPromptTokenDetails !== "object" || rawPromptTokenDetails === null) return false;
-	const promptTokenDetails = rawPromptTokenDetails;
-	return typeof promptTokenDetails.cached_tokens === "number" && promptTokenDetails.cached_tokens > 0;
-}
-/**
-* Normalize tool call ID for Mistral.
-* Mistral requires tool IDs to be exactly 9 alphanumeric characters (a-z, A-Z, 0-9).
-*/
-function normalizeMistralToolId(id, isMistral) {
-	if (!isMistral) return id;
-	let normalized = id.replace(/[^a-zA-Z0-9]/g, "");
-	if (normalized.length < 9) normalized = normalized + "ABCDEFGHI".slice(0, 9 - normalized.length);
-	else if (normalized.length > 9) normalized = normalized.slice(0, 9);
-	return normalized;
-}
-function resolveOpenAICompletionsRoutingEffort(model, effort) {
-	if (!effort) return void 0;
-	if (model.thinking?.efforts.includes(effort)) return effort;
-	const compatMappedEffort = model.compat.reasoningEffortMap?.[effort];
-	if (compatMappedEffort && model.thinking?.efforts.includes(compatMappedEffort)) return compatMappedEffort;
-	const thinkingMappedEffort = model.thinking?.effortMap?.[effort];
-	if (thinkingMappedEffort && model.thinking?.efforts.includes(thinkingMappedEffort)) return thinkingMappedEffort;
-	return effort;
-}
-function resolveOpenAICompletionsModelId(model, options) {
-	const effort = resolveOpenAICompletionsRoutingEffort(model, options?.reasoning && !options.disableReasoning && model.reasoning ? options.reasoning : void 0);
-	const wireId = resolveWireModelId(model, effort);
-	return applyWireModelIdTransform(wireId, model.compat.wireModelIdMode, options?.openrouterVariant);
-}
-/**
-* Normalize OpenAI-compatible streaming `delta.content` into plain text.
-* Most providers stream `delta.content` as a string, but some (notably Mistral
-* Medium 3.5 / `mistral-medium-2604`) return an array of typed content parts
-* — e.g. `[{ type: "text", text: "Hello" }]`. Without normalization those
-* parts get string-coerced via `text += array`, producing the literal
-* `[object Object]` sequences observed in issue #911.
-*
-* Returns the joined text. Non-text parts and unknown shapes are skipped so
-* we never emit JS object sigils as visible output.
-*/
-function normalizeStreamingContentText(content) {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) {
-		let out = "";
-		for (const part of content) if (typeof part === "string") out += part;
-		else if (part && typeof part === "object") {
-			const obj = part;
-			if ((obj.type === void 0 || obj.type === "text") && typeof obj.text === "string") out += obj.text;
-		}
-		return out;
-	}
-	if (content && typeof content === "object") {
-		const obj = content;
-		if ((obj.type === void 0 || obj.type === "text") && typeof obj.text === "string") return obj.text;
-	}
-	return "";
-}
-function serializeToolArguments(value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) try {
-		return JSON.stringify(value);
-	} catch {
-		return "{}";
-	}
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		if (trimmed.length === 0) return "{}";
-		try {
-			const parsed = JSON.parse(trimmed);
-			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return JSON.stringify(parsed);
-		} catch {}
-		return "{}";
-	}
-	return "{}";
-}
-function cloneStreamingArgumentValue(value) {
-	if (Array.isArray(value)) return value.map(cloneStreamingArgumentValue);
-	if (value !== null && typeof value === "object" && !Array.isArray(value)) return mergeStreamingArgumentObjects(void 0, value);
-	return value;
-}
-function streamingArgumentValuesEqual(left, right) {
-	if (left === right) return true;
-	if (Array.isArray(left) && Array.isArray(right)) {
-		if (left.length !== right.length) return false;
-		for (let i = 0; i < left.length; i++) if (!streamingArgumentValuesEqual(left[i], right[i])) return false;
-		return true;
-	}
-	if (left !== null && typeof left === "object" && !Array.isArray(left) && right !== null && typeof right === "object" && !Array.isArray(right)) {
-		const leftObject = left;
-		const rightObject = right;
-		let leftKeys = 0;
-		for (const key in leftObject) {
-			if (!Object.hasOwn(leftObject, key) || key === "__proto__" || key === "constructor" || key === "prototype") continue;
-			leftKeys++;
-			if (!Object.hasOwn(rightObject, key) || !streamingArgumentValuesEqual(leftObject[key], rightObject[key])) return false;
-		}
-		let rightKeys = 0;
-		for (const key in rightObject) {
-			if (!Object.hasOwn(rightObject, key) || key === "__proto__" || key === "constructor" || key === "prototype") continue;
-			rightKeys++;
-		}
-		return leftKeys === rightKeys;
-	}
-	return false;
-}
-function streamingArgumentArrayStartsWith(value, prefix) {
-	if (prefix.length > value.length) return false;
-	for (let i = 0; i < prefix.length; i++) if (!streamingArgumentValuesEqual(value[i], prefix[i])) return false;
-	return true;
-}
-function mergeStreamingArgumentArrays(prev, fragment) {
-	if (streamingArgumentArrayStartsWith(fragment, prev)) return fragment.map(cloneStreamingArgumentValue);
-	if (streamingArgumentArrayStartsWith(prev, fragment)) return prev.map(cloneStreamingArgumentValue);
-	const merged = prev.map(cloneStreamingArgumentValue);
-	for (const value of fragment) merged.push(cloneStreamingArgumentValue(value));
-	return merged;
-}
-function mergeStreamingArgumentValues(prev, fragment) {
-	if (typeof prev === "string" && typeof fragment === "string") return fragment.startsWith(prev) ? fragment : prev + fragment;
-	if (Array.isArray(prev) && Array.isArray(fragment)) return mergeStreamingArgumentArrays(prev, fragment);
-	if (prev !== null && typeof prev === "object" && !Array.isArray(prev) && fragment !== null && typeof fragment === "object" && !Array.isArray(fragment)) return mergeStreamingArgumentObjects(prev, fragment);
-	return cloneStreamingArgumentValue(fragment);
-}
-function mergeStreamingArgumentObjects(prev, fragment) {
-	const merged = {};
-	if (prev) for (const key in prev) {
-		if (!Object.hasOwn(prev, key) || key === "__proto__" || key === "constructor" || key === "prototype") continue;
-		merged[key] = cloneStreamingArgumentValue(prev[key]);
-	}
-	for (const key in fragment) {
-		if (!Object.hasOwn(fragment, key) || key === "__proto__" || key === "constructor" || key === "prototype") continue;
-		merged[key] = Object.hasOwn(merged, key) ? mergeStreamingArgumentValues(merged[key], fragment[key]) : cloneStreamingArgumentValue(fragment[key]);
-	}
-	return merged;
-}
-/**
-* 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 (msg.content.some((block) => block.type === "toolCall")) return true;
-		}
-	}
-	return false;
-}
-/**
-* Identify "real progress" stream chunks vs. keepalives, role-only preambles,
-* and empty `{choices:[]}` no-ops emitted by some OpenAI-compatible endpoints.
-* Without this filter, every keepalive resets `iterateWithIdleTimeout`'s
-* deadline, so a provider that streams nothing but pings keeps the watchdog
-* asleep indefinitely — observed against z.ai/GLM via OpenRouter where a
-* subagent stalled for hours with no error surfaced.
-*
-* A chunk counts as progress when it carries terminal usage, a finish reason,
-* or a model-produced delta (content / tool calls / reasoning / refusal).
-* Role-only `delta: { role: "assistant" }` preambles do NOT count; we want the
-* (longer) first-event timeout to keep governing until real output appears.
-*/
-function isOpenAICompletionsProgressChunk(chunk) {
-	if (!chunk || typeof chunk !== "object") return false;
-	const record = chunk;
-	if (record.usage) return true;
-	const choice = Array.isArray(record.choices) ? record.choices[0] : void 0;
-	if (!choice) return false;
-	if (choice.finish_reason) return true;
-	if (choice.usage) return true;
-	const delta = choice.delta;
-	if (!delta) return false;
-	const content = delta.content;
-	if (typeof content === "string" ? content.length > 0 : Array.isArray(content) && content.length > 0) return true;
-	if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) return true;
-	if (typeof delta.reasoning === "string" && delta.reasoning.length > 0) return true;
-	if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) return true;
-	if (typeof delta.reasoning_text === "string" && delta.reasoning_text.length > 0) return true;
-	if (typeof delta.refusal === "string" && delta.refusal.length > 0) return true;
-	return false;
-}
-const OPENAI_COMPLETIONS_PROVIDER_SESSION_STATE_PREFIX = "openai-completions:";
-function createOpenAICompletionsProviderSessionState() {
-	const strictToolsState = createOpenAIStrictToolsState();
-	const reasoningEffortFallbackState = createOpenAIReasoningEffortFallbackState();
-	const state = {
-		...strictToolsState,
-		...reasoningEffortFallbackState,
-		close: () => {
-			clearOpenAIStrictToolsState(state);
-			clearOpenAIReasoningEffortFallbackState(state);
-		}
-	};
-	return state;
-}
-function getOpenAICompletionsProviderSessionState(model, baseUrl, providerSessionState) {
-	if (!providerSessionState) return void 0;
-	const key = `${OPENAI_COMPLETIONS_PROVIDER_SESSION_STATE_PREFIX}${model.provider}:${baseUrl ?? ""}:${model.id}`;
-	const existing = providerSessionState.get(key);
-	if (existing) return existing;
-	const created = createOpenAICompletionsProviderSessionState();
-	providerSessionState.set(key, created);
-	return created;
-}
-const DEEPSEEK_SPECIAL_TOKEN_REGEX = /<(?:｜|\|)[A-Za-z0-9_.｜|▁]{1,64}(?:｜|\|)>/g;
-const DEEPSEEK_SPECIAL_TOKEN_AT_START_REGEX = /^\s*<(?:｜|\|)[A-Za-z0-9_.｜|▁]{1,64}(?:｜|\|)>/;
-const DEEPSEEK_SPECIAL_TOKEN_AT_END_REGEX = /<(?:｜|\|)[A-Za-z0-9_.｜|▁]{1,64}(?:｜|\|)>\s*$/;
-const DEEPSEEK_OPEN_DELIMS = ["<｜", "<|"];
-function stripDeepseekSpecialTokens(text) {
-	const stripped = text.replace(DEEPSEEK_SPECIAL_TOKEN_REGEX, "");
-	if (stripped === text) return text;
-	let normalized = stripped;
-	if (DEEPSEEK_SPECIAL_TOKEN_AT_START_REGEX.test(text)) normalized = normalized.replace(/^\s+/u, "");
-	if (DEEPSEEK_SPECIAL_TOKEN_AT_END_REGEX.test(text)) normalized = normalized.replace(/\s+$/u, "");
-	return normalized;
-}
-function getTrailingPartialDeepseekToken(text) {
-	let bestIdx = -1;
-	for (const delim of DEEPSEEK_OPEN_DELIMS) {
-		const idx = text.lastIndexOf(delim);
-		if (idx > bestIdx) bestIdx = idx;
-	}
-	if (bestIdx === -1) return text.endsWith("<") ? "<" : "";
-	const tail = text.slice(bestIdx);
-	if (tail.includes("｜>") || tail.includes("|>")) return "";
-	if (tail.length > 256) return "";
-	return tail;
-}
-const OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE = "OpenAI completions stream timed out while waiting for the first event";
-const OPENAI_COMPLETIONS_POST_FINISH_GRACE_MS = 2500;
-const OPENAI_COMPLETIONS_ERROR_STATUS_BY_TYPE = {
-	SERVICE_UNAVAILABLE: 503,
-	TOO_MANY_REQUESTS: 429,
-	REQUEST_TIMEOUT: 408
-};
-function parseOpenAICompletionsErrorStatus(value) {
-	const status = typeof value === "number" ? value : typeof value === "string" && /^\d{3}$/.test(value.trim()) ? Number(value) : void 0;
-	return status !== void 0 && Number.isInteger(status) && status >= 400 && status <= 599 ? status : void 0;
-}
-function createOpenAICompletionsStreamError(chunk, provider) {
-	if (!chunk || typeof chunk !== "object") return void 0;
-	const error = Reflect.get(chunk, "error");
-	const flatMessage = Reflect.get(chunk, "message");
-	const structuredError = error !== null && typeof error === "object";
-	if (!structuredError && typeof error !== "string" && typeof flatMessage !== "string") return void 0;
-	const parsed = OpenAIHttpError.parseEnvelope(chunk, void 0);
-	const detail = parsed.detail ?? "Provider returned an in-band OpenAI completions stream error";
-	if (!structuredError) return new ProviderResponseError(detail, {
-		provider,
-		kind: "runtime"
-	});
-	const typeValue = Reflect.get(error, "type");
-	const codeValue = Reflect.get(error, "code");
-	const type = typeof typeValue === "string" ? typeValue.trim() : void 0;
-	const status = parseOpenAICompletionsErrorStatus(codeValue) ?? (type ? OPENAI_COMPLETIONS_ERROR_STATUS_BY_TYPE[type.toUpperCase()] : void 0);
-	if (status === void 0) return new ProviderResponseError(detail, {
-		provider,
-		kind: "runtime"
-	});
-	return new ProviderHttpError(`${status} ${detail}`, status, { code: parsed.code });
-}
-const streamOpenAICompletionsOnce = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const startTime = performance.now();
-		let firstTokenTime;
-		const policy = resolveOpenAICompatForRequest(model, options);
-		const output = createInitialResponsesAssistantMessage(model.api, model.provider, model.id);
-		let rawRequestDump;
-		const abortTracker = createAbortSourceTracker(options?.signal);
-		const firstEventTimeoutAbortError = new StreamTimeoutError(OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE);
-		const { requestAbortController, requestSignal } = abortTracker;
-		const onSseEvent = options?.onSseEvent;
-		let sawDoneSentinel = false;
-		const rawSseObserver = (event) => {
-			if (event.data === "[DONE]") sawDoneSentinel = true;
-			if (onSseEvent) {
-				if (!event.event && event.data && event.data !== "[DONE]") try {
-					const parsed = JSON.parse(event.data);
-					const resolvedEvent = typeof parsed.type === "string" ? parsed.type : typeof parsed.object === "string" ? parsed.object : null;
-					if (resolvedEvent) {
-						event.event = resolvedEvent;
-						event.raw = [`event: ${resolvedEvent}`, ...event.raw];
-					}
-				} catch {}
-				onSseEvent(event, model);
-			}
-		};
-		let finishOpenBlocksOnError = () => {};
-		try {
-			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const idleTimeoutFallbackMs = model.compat.streamIdleTimeoutMs;
-			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(idleTimeoutFallbackMs);
-			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs, model.compat.streamFirstEventTimeoutMs);
-			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
-			const { copilotPremiumRequests, baseUrl, headers, query, requestHeaders } = createRequestSetup(model, context, apiKey, options?.headers, options?.initiatorOverride, getOpenAIPromptCacheKey(options), options?.sessionId);
-			const premiumRequestsTotal = copilotPremiumRequests;
-			let appliedStrictTools = false;
-			const requestReasoningEffortFallbacks = /* @__PURE__ */ new Map();
-			const attemptedReasoningEffortFallbacks = /* @__PURE__ */ new Set();
-			let activeReasoningEffortFallbackKey;
-			let activeRequestParams;
-			const providerSessionState = getOpenAICompletionsProviderSessionState(model, baseUrl, options?.providerSessionState);
-			const strictToolsScope = getOpenAIStrictToolsScope(model, baseUrl);
-			let disableStrictTools = isStrictToolsDisabledForScope(providerSessionState, strictToolsScope);
-			const trimmedBaseUrl = baseUrl.replace(/\/+$/, "");
-			const completionsUrl = query ? `${trimmedBaseUrl}/chat/completions?${new URLSearchParams(query)}` : `${trimmedBaseUrl}/chat/completions`;
-			const createCompletionsStream = async (toolStrictModeOverride) => {
-				const builtParams = buildParams(model, context, options, disableStrictTools ? "none" : toolStrictModeOverride);
-				appliedStrictTools = builtParams.strictToolsApplied;
-				let params = builtParams.params;
-				const reasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("chat-completions", trimmedBaseUrl, params.model);
-				const requestReasoningEffortFallback = requestReasoningEffortFallbacks.has(reasoningEffortFallbackKey) ? requestReasoningEffortFallbacks.get(reasoningEffortFallbackKey) : getOpenAIReasoningEffortFallback(providerSessionState, reasoningEffortFallbackKey);
-				if (requestReasoningEffortFallback !== void 0) applyOpenAIReasoningEffortFallback(params, requestReasoningEffortFallback);
-				activeReasoningEffortFallbackKey = reasoningEffortFallbackKey;
-				const replacedParams = await options?.onPayload?.(params, model);
-				if (replacedParams !== void 0) params = replacedParams;
-				activeRequestParams = params;
-				rawRequestDump = {
-					provider: model.provider,
-					api: output.api,
-					model: model.id,
-					method: "POST",
-					url: completionsUrl,
-					headers: requestHeaders,
-					body: params
-				};
-				let requestTimeout;
-				if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
-				try {
-					const headersWithTimeout = { ...headers };
-					if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
-					const { events, response, requestId } = await postOpenAIStream({
-						url: completionsUrl,
-						headers: headersWithTimeout,
-						body: params,
-						signal: requestSignal,
-						fetch: wrapFetchForCopilotFallback(options?.fetch, model.provider === "github-copilot", resolveCopilotRequestIdentity(options?.headers)),
-						onSseEvent: rawSseObserver
-					});
-					await notifyProviderResponse(options, response, model, requestId);
-					return events;
-				} finally {
-					clearTimeout(requestTimeout);
-				}
-			};
-			let openaiStream;
-			try {
-				openaiStream = await createCompletionsStream();
-			} catch (error) {
-				const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
-				const isExplicitDisable = options?.disableReasoning === true;
-				const reasoningEffortFallback = activeReasoningEffortFallbackKey && activeRequestParams && !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, activeRequestParams, { explicitDisable: isExplicitDisable }) : void 0;
-				if (reasoningEffortFallback !== void 0 && activeReasoningEffortFallbackKey) {
-					const retryMarker = `${activeReasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
-					if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
-					attemptedReasoningEffortFallbacks.add(retryMarker);
-					requestReasoningEffortFallbacks.set(activeReasoningEffortFallbackKey, reasoningEffortFallback);
-					openaiStream = await createCompletionsStream();
-					if (!isExplicitDisable) rememberOpenAIReasoningEffortFallback(providerSessionState, activeReasoningEffortFallbackKey, reasoningEffortFallback);
-				} else if (model.compat.retryWithoutStrictOnGrammarError && !disableStrictTools && isCompiledGrammarTooLargeStrictError(error, capturedErrorResponse)) {
-					disableStrictToolsForScope(providerSessionState, strictToolsScope);
-					disableStrictTools = true;
-					openaiStream = await createCompletionsStream("none");
-				} else {
-					if (!shouldRetryWithoutStrictTools(error, capturedErrorResponse, {
-						model,
-						strictToolsApplied: appliedStrictTools,
-						tools: context.tools
-					})) throw error;
-					disableStrictToolsForScope(providerSessionState, strictToolsScope);
-					disableStrictTools = true;
-					openaiStream = await createCompletionsStream("none");
-				}
-			}
-			if (premiumRequestsTotal !== void 0) output.usage.premiumRequests = premiumRequestsTotal;
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			const stripDeepseekChatTemplateTokens = policy.stream.stripSpecialTokens === "deepseek";
-			const pendingToolCallBlocks = [];
-			const toolCallBlockByIndex = /* @__PURE__ */ new Map();
-			const unkeyedBatchBlocks = [];
-			const clearUnkeyedBatchSlot = (block) => {
-				for (let index = 0; index < unkeyedBatchBlocks.length; index++) if (unkeyedBatchBlocks[index] === block) unkeyedBatchBlocks[index] = void 0;
-			};
-			let currentBlock;
-			const blockIndex = (block) => {
-				if (!block) return Math.max(0, output.content.length - 1);
-				return output.content.indexOf(block);
-			};
-			const finishToolCallBlock = (block) => {
-				if (block.partialArgs === void 0) return;
-				const contentIndex = blockIndex(block);
-				if (contentIndex < 0) return;
-				if (typeof block.partialArgs === "object" && !Array.isArray(block.partialArgs)) {
-					const fullJson = JSON.stringify(block.partialArgs);
-					if (fullJson.length > 0 && fullJson !== "{}") stream.push({
-						type: "toolcall_delta",
-						contentIndex,
-						delta: fullJson,
-						partial: output
-					});
-				}
-				block.arguments = typeof block.partialArgs === "string" ? parseStreamingJson(block.partialArgs) : block.partialArgs;
-				delete block.partialArgs;
-				if (block.streamIndex !== void 0) {
-					toolCallBlockByIndex.delete(block.streamIndex);
-					delete block.streamIndex;
-				}
-				const pendingIndex = pendingToolCallBlocks.indexOf(block);
-				if (pendingIndex >= 0) pendingToolCallBlocks.splice(pendingIndex, 1);
-				clearUnkeyedBatchSlot(block);
-				stream.push({
-					type: "toolcall_end",
-					contentIndex,
-					toolCall: block,
-					partial: output
-				});
-			};
-			const finishPendingToolCallBlocks = () => {
-				for (const block of Array.from(pendingToolCallBlocks)) finishToolCallBlock(block);
-			};
-			const finishCurrentBlock = (block) => {
-				if (!block) return;
-				const contentIndex = blockIndex(block);
-				if (contentIndex < 0) return;
-				if (block.type === "text") {
-					stream.push({
-						type: "text_end",
-						contentIndex,
-						content: block.text,
-						partial: output
-					});
-					return;
-				}
-				if (block.type === "thinking") {
-					stream.push({
-						type: "thinking_end",
-						contentIndex,
-						content: block.thinking,
-						partial: output
-					});
-					return;
-				}
-				finishToolCallBlock(block);
-			};
-			finishOpenBlocksOnError = () => {
-				if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
-				finishPendingToolCallBlocks();
-			};
-			const appendText = (message, eventStream, text) => {
-				if (currentBlock?.type !== "text") {
-					if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
-					currentBlock = {
-						type: "text",
-						text: ""
-					};
-					message.content.push(currentBlock);
-					eventStream.push({
-						type: "text_start",
-						contentIndex: blockIndex(currentBlock),
-						partial: message
-					});
-				}
-				currentBlock.text += text;
-				eventStream.push({
-					type: "text_delta",
-					contentIndex: blockIndex(currentBlock),
-					delta: text,
-					partial: message
-				});
-			};
-			const appendThinking = (message, eventStream, thinking, signature) => {
-				if (currentBlock?.type !== "thinking" || signature !== void 0 && currentBlock.thinkingSignature !== signature) {
-					if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
-					currentBlock = {
-						type: "thinking",
-						thinking: "",
-						thinkingSignature: signature
-					};
-					message.content.push(currentBlock);
-					eventStream.push({
-						type: "thinking_start",
-						contentIndex: blockIndex(currentBlock),
-						partial: message
-					});
-				}
-				if (signature !== void 0 && !currentBlock.thinkingSignature) currentBlock.thinkingSignature = signature;
-				currentBlock.thinking += thinking;
-				eventStream.push({
-					type: "thinking_delta",
-					contentIndex: blockIndex(currentBlock),
-					delta: thinking,
-					partial: message
-				});
-			};
-			const appendTextDelta = (text) => {
-				if (!text) return;
-				if (!firstTokenTime) firstTokenTime = performance.now();
-				appendText(output, stream, text);
-			};
-			const lastCumulativeReasoningBySignature = /* @__PURE__ */ new Map();
-			const appendThinkingDelta = (thinking, signature, source = "delta") => {
-				if (!thinking) return;
-				let emittedThinking = thinking;
-				if (source === "cumulative") {
-					const key = signature ?? "";
-					const lastSnapshot = lastCumulativeReasoningBySignature.get(key) ?? "";
-					if (thinking.startsWith(lastSnapshot)) emittedThinking = thinking.slice(lastSnapshot.length);
-					lastCumulativeReasoningBySignature.set(key, thinking);
-					if (!emittedThinking) return;
-				}
-				if (!firstTokenTime) firstTokenTime = performance.now();
-				appendThinking(output, stream, emittedThinking, signature);
-			};
-			let deepseekStripBuffer = "";
-			const flushDeepseekStripBuffer = (final) => {
-				if (deepseekStripBuffer.length === 0) return;
-				let flushable;
-				if (final) {
-					flushable = deepseekStripBuffer;
-					deepseekStripBuffer = "";
-				} else {
-					const trailing = getTrailingPartialDeepseekToken(deepseekStripBuffer);
-					flushable = deepseekStripBuffer.slice(0, deepseekStripBuffer.length - trailing.length);
-					deepseekStripBuffer = trailing;
-				}
-				const stripped = stripDeepseekSpecialTokens(flushable);
-				if (stripped && (stripped === flushable || stripped.trim().length > 0)) appendTextDelta(stripped);
-			};
-			const appendProcessedText = (processedText) => {
-				if (processedText.length === 0) return;
-				if (stripDeepseekChatTemplateTokens) {
-					deepseekStripBuffer += processedText;
-					flushDeepseekStripBuffer(false);
-				} else appendTextDelta(processedText);
-			};
-			const streamMarkupHealingPattern = policy.stream.markupHealingPattern;
-			const streamMarkupHealing = streamMarkupHealingPattern ? new StreamMarkupHealing({ pattern: streamMarkupHealingPattern }) : void 0;
-			const explicitReasoningDeltasMayBeCumulative = policy.stream.reasoningDeltasMayBeCumulative;
-			let suppressHealedThinking = false;
-			let healedToolCallEmitted = false;
-			const emitHealedToolCall = (call) => {
-				finishCurrentBlock(currentBlock);
-				const block = {
-					type: "toolCall",
-					id: call.id,
-					name: call.name,
-					arguments: {},
-					partialArgs: call.arguments
-				};
-				block.arguments = parseStreamingJson(call.arguments);
-				currentBlock = block;
-				output.content.push(block);
-				stream.push({
-					type: "toolcall_start",
-					contentIndex: blockIndex(block),
-					partial: output
-				});
-				stream.push({
-					type: "toolcall_delta",
-					contentIndex: blockIndex(block),
-					delta: call.arguments,
-					partial: output
-				});
-				finishCurrentBlock(block);
-				currentBlock = void 0;
-				healedToolCallEmitted = true;
-			};
-			const emitHealingEvent = (event, suppressThinking) => {
-				if (event.type === "text") appendProcessedText(event.text);
-				else if (event.type === "thinking") {
-					if (!suppressThinking) appendThinkingDelta(event.thinking);
-				} else emitHealedToolCall(event.call);
-			};
-			const flushHealedToolCalls = () => {
-				if (!streamMarkupHealing) return;
-				const calls = streamMarkupHealing.drainCompleted();
-				for (const call of calls) emitHealedToolCall(call);
-			};
-			let streamFinishedAt;
-			let sawUsagePayload = false;
-			let awaitTrailingUsageDetails = false;
-			const applyUsagePayload = (rawUsage) => {
-				output.usage = parseChunkUsage(rawUsage, model, premiumRequestsTotal, output.timestamp);
-				sawUsagePayload = true;
-				awaitTrailingUsageDetails = !hasPositiveCacheReadTokenField(rawUsage);
-			};
-			const timedOpenaiStream = iterateWithIdleTimeout(openaiStream, {
-				idleTimeoutMs,
-				firstItemTimeoutMs: firstEventTimeoutMs,
-				firstItemErrorMessage: OPENAI_COMPLETIONS_FIRST_EVENT_TIMEOUT_MESSAGE,
-				errorMessage: "OpenAI completions stream stalled while waiting for the next event",
-				onIdle: () => requestAbortController.abort(),
-				onFirstItemTimeout: () => abortTracker.abortLocally(firstEventTimeoutAbortError),
-				abortSignal: options?.signal,
-				isProgressItem: isOpenAICompletionsProgressChunk
-			});
-			const terminalAwareStream = iterateWithTerminalGrace(timedOpenaiStream, {
-				finishedAtMs: () => streamFinishedAt,
-				graceMs: OPENAI_COMPLETIONS_POST_FINISH_GRACE_MS,
-				onGraceEnd: () => requestAbortController.abort()
-			});
-			for await (const chunk of terminalAwareStream) {
-				if (!chunk || typeof chunk !== "object") continue;
-				const streamError = createOpenAICompletionsStreamError(chunk, model.provider);
-				if (streamError) throw streamError;
-				output.responseId ||= chunk.id;
-				if (!output.upstreamProvider) {
-					const upstreamProvider = chunk.provider;
-					output.upstreamProvider = typeof upstreamProvider === "string" && upstreamProvider.length > 0 ? upstreamProvider : void 0;
-				}
-				if (chunk.usage) applyUsagePayload(chunk.usage);
-				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
-				if (!choice) {
-					if (streamFinishedAt !== void 0 && sawUsagePayload) break;
-					continue;
-				}
-				if (!chunk.usage) {
-					const choiceUsage = choice.usage;
-					if (typeof choiceUsage === "object" && choiceUsage !== null) applyUsagePayload(choiceUsage);
-				}
-				if (choice.finish_reason) {
-					const finishReasonResult = mapStopReason(choice.finish_reason);
-					output.stopReason = finishReasonResult.stopReason;
-					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
-					streamFinishedAt ??= Date.now();
-				}
-				if (choice.delta) {
-					const reasoningFields = [
-						"reasoning_content",
-						"reasoning",
-						"reasoning_text"
-					];
-					const deltaRecord = choice.delta;
-					let foundReasoningField;
-					let foundReasoningDelta = "";
-					for (const field of reasoningFields) {
-						const reasoningDelta = deltaRecord[field];
-						if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
-							foundReasoningField = field;
-							foundReasoningDelta = reasoningDelta;
-							break;
-						}
-					}
-					if (foundReasoningField) {
-						appendThinkingDelta(foundReasoningDelta, foundReasoningField, explicitReasoningDeltasMayBeCumulative ? "cumulative" : "delta");
-						suppressHealedThinking = true;
-					}
-					const normalizedDeltaText = normalizeStreamingContentText(choice.delta.content);
-					if (normalizedDeltaText.length > 0) {
-						if (!firstTokenTime) firstTokenTime = performance.now();
-						const hasStructuredToolCalls = Array.isArray(choice.delta.tool_calls) && choice.delta.tool_calls.length > 0;
-						if (streamMarkupHealing) {
-							const healingEvents = hasStructuredToolCalls ? streamMarkupHealing.feedEventsWithoutCalls(normalizedDeltaText) : streamMarkupHealing.feedEvents(normalizedDeltaText);
-							for (const event of healingEvents) emitHealingEvent(event, suppressHealedThinking);
-						} else appendProcessedText(normalizedDeltaText);
-					}
-					if (choice?.delta?.tool_calls && choice.delta.tool_calls.length > 0) {
-						const toolCalls = choice.delta.tool_calls;
-						for (let toolCallOffset = 0; toolCallOffset < toolCalls.length; toolCallOffset++) {
-							const toolCall = toolCalls[toolCallOffset];
-							const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
-							const incomingName = toolCall.function?.name || "";
-							const unkeyedBatchedArrayEntry = toolCalls.length > 1 && streamIndex === void 0 && !toolCall.id;
-							let block = streamIndex !== void 0 ? toolCallBlockByIndex.get(streamIndex) : void 0;
-							if (!block && toolCall.id) block = pendingToolCallBlocks.find((candidate) => candidate.id === toolCall.id);
-							if (!block && unkeyedBatchedArrayEntry) {
-								const offsetBlock = unkeyedBatchBlocks[toolCallOffset];
-								if (offsetBlock && offsetBlock.partialArgs !== void 0) block = offsetBlock;
-							}
-							if (!block && !unkeyedBatchedArrayEntry && currentBlock?.type === "toolCall" && (!toolCall.id || currentBlock.id === toolCall.id)) block = currentBlock;
-							if (!block) {
-								if (currentBlock?.type !== "toolCall") finishCurrentBlock(currentBlock);
-								block = {
-									type: "toolCall",
-									id: toolCall.id || "",
-									name: incomingName,
-									arguments: {},
-									partialArgs: "",
-									streamIndex
-								};
-								if (streamIndex !== void 0) toolCallBlockByIndex.set(streamIndex, block);
-								pendingToolCallBlocks.push(block);
-								currentBlock = block;
-								output.content.push(block);
-								stream.push({
-									type: "toolcall_start",
-									contentIndex: blockIndex(block),
-									partial: output
-								});
-								if (unkeyedBatchedArrayEntry) unkeyedBatchBlocks[toolCallOffset] = block;
-							} else {
-								if (currentBlock !== block && currentBlock && currentBlock.type !== "toolCall") finishCurrentBlock(currentBlock);
-								currentBlock = block;
-								if (streamIndex !== void 0 && block.streamIndex === void 0) {
-									block.streamIndex = streamIndex;
-									toolCallBlockByIndex.set(streamIndex, block);
-								}
-							}
-							if (toolCall.id) block.id = toolCall.id;
-							if (incomingName) block.name = incomingName;
-							const extraContent = getGeminiThoughtSignatureExtraContent(Reflect.get(toolCall, "extra_content"));
-							if (extraContent) block.thoughtSignature = JSON.stringify(extraContent);
-							let delta = "";
-							const rawArgs = toolCall.function?.arguments;
-							if (typeof rawArgs === "string") {
-								if (rawArgs.length > 0) {
-									delta = rawArgs;
-									const prev = typeof block.partialArgs === "string" ? block.partialArgs : "";
-									block.partialArgs = prev + rawArgs;
-									const throttled = parseStreamingJsonThrottled(block.partialArgs, block[kStreamingLastParseLen] ?? 0);
-									if (throttled) {
-										block.arguments = throttled.value;
-										block[kStreamingLastParseLen] = throttled.parsedLen;
-									}
-								}
-							} else if (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)) {
-								const merged = mergeStreamingArgumentObjects(block.partialArgs !== null && typeof block.partialArgs === "object" && !Array.isArray(block.partialArgs) ? block.partialArgs : void 0, rawArgs);
-								block.partialArgs = merged;
-								block.arguments = merged;
-							}
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: blockIndex(block),
-								delta,
-								partial: output
-							});
-						}
-					}
-					const reasoningDetails = choice.delta.reasoning_details;
-					if (Array.isArray(reasoningDetails)) for (const detail of reasoningDetails) {
-						if (!detail || typeof detail !== "object") continue;
-						const detailObject = detail;
-						if (detailObject.type === "reasoning.encrypted" && detailObject.id && detailObject.data) {
-							const matchingToolCall = output.content.find((b) => b.type === "toolCall" && b.id === detailObject.id);
-							if (matchingToolCall) matchingToolCall.thoughtSignature = JSON.stringify(detailObject);
-						}
-					}
-				}
-				if (streamFinishedAt !== void 0 && sawUsagePayload && !awaitTrailingUsageDetails) break;
-			}
-			if (streamMarkupHealing) {
-				for (const event of streamMarkupHealing.flushEvents()) emitHealingEvent(event, suppressHealedThinking);
-				flushHealedToolCalls();
-				if (healedToolCallEmitted && output.stopReason === "stop") output.stopReason = "toolUse";
-			}
-			if (stripDeepseekChatTemplateTokens) flushDeepseekStripBuffer(true);
-			if (streamFinishedAt === void 0 && !sawDoneSentinel && output.content.length > 0) throw new ProviderResponseError("OpenAI completions stream closed before a finish_reason was received", {
-				provider: model.provider,
-				kind: "incomplete-stream"
-			});
-			if (currentBlock?.type === "toolCall") finishPendingToolCallBlocks();
-			else {
-				finishCurrentBlock(currentBlock);
-				finishPendingToolCallBlocks();
-			}
-			if (output.stopReason === "stop" && output.content.some((b) => b.type === "toolCall")) output.stopReason = "toolUse";
-			if (policy.stream.emptyLengthFinishIsContextError && output.stopReason === "length" && !hasVisibleAssistantContent(output)) {
-				output.stopReason = "error";
-				output.errorMessage = EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE;
-			}
-			const localAbortReason = abortTracker.getLocalAbortReason();
-			if (localAbortReason) throw localAbortReason;
-			if (abortTracker.wasCallerAbort()) throw new AbortError();
-			if (output.stopReason === "aborted") throw new AbortError();
-			if (output.stopReason === "error") throw new ProviderResponseError(output.errorMessage || "Provider returned an error stop reason", {
-				provider: model.provider,
-				kind: "runtime"
-			});
-			output.errorMessage = void 0;
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			try {
-				finishOpenBlocksOnError();
-			} catch {}
-			const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
-			const result = await finalize(error, {
-				api: model.api,
-				provider: model.provider,
-				abortTracker,
-				rawRequestDump,
-				capturedErrorResponse
-			});
-			output.stopReason = result.stopReason;
-			output.errorStatus = result.status;
-			output.errorId = result.id;
-			output.errorMessage = result.message;
-			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-/**
-* Retries benign empty completions and transient provider failures only before
-* assistant output commits the attempt.
-*/
-const streamOpenAICompletions = (model, context, options) => withReplaySafeStreamRetry(model, context, options, streamOpenAICompletionsOnce, {
-	retryEmptyCompletion: true,
-	retryProviderErrors: true,
-	maxProviderErrorRetries: 1
-});
-function createRequestSetup(model, context, apiKey, extraHeaders, initiatorOverride, promptCacheSessionId, sessionId) {
-	const apiVersion = $env.AZURE_OPENAI_API_VERSION || "2024-10-21";
-	const deploymentName = parseAzureDeploymentNameMap($env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP).get(model.id) ?? model.id;
-	const setup = resolveOpenAIRequestSetup(model, {
-		apiKey,
-		extraHeaders,
-		initiatorOverride,
-		promptCacheSessionId,
-		sessionId,
-		messages: context.messages,
-		defaultBaseUrl: "https://api.openai.com/v1",
-		prependHeaders: model.provider === "kimi-code" ? getKimiCommonHeaders : model.provider === "cline-pass" ? () => clinePassClientHeaders(promptCacheSessionId) : void 0,
-		alibabaCodingPlanAuth: true,
-		azureChatCompletions: {
-			apiVersion,
-			deploymentName
-		}
-	});
-	if (!setup.baseUrl) throw new ConfigurationError("OpenAI request setup did not resolve a base URL");
-	return setup;
-}
-function resolveOpenAICompatForRequest(model, options) {
-	return resolveOpenAICompatPolicy(model, {
-		endpoint: "chat-completions",
-		reasoning: options?.reasoning,
-		disableReasoning: options?.disableReasoning,
-		toolChoice: mapToOpenAICompletionsToolChoice(options?.toolChoice)
-	});
-}
-function dropOpenRouterKimiForcedToolReasoning(params, _model, policy) {
-	if (policy.reasoning.disableReason === "forced-tool-choice" && policy.reasoning.disableMode === "openrouter-enabled-false" && policy.compat.isOpenRouterHost) delete params.reasoning;
-}
-function hasActiveNativeKimiK3Reasoning(model, options) {
-	if (!model.compat.nativeKimiK3Reasoning || !model.reasoning) return false;
-	return options?.reasoning !== void 0 && !options.disableReasoning;
-}
-function isChatCompletionsPromptCacheableContentBlock(block) {
-	if (typeof block !== "object" || block === null || !("type" in block)) return false;
-	return block.type === "text" || block.type === "image_url" || block.type === "input_audio" || block.type === "file";
-}
-function markLatestStableChatCompletionsCacheBreakpoint(messages) {
-	let latestInputMessage = -1;
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i];
-		if (message.role === "user" || message.role === "developer") {
-			latestInputMessage = i;
-			break;
-		}
-	}
-	if (latestInputMessage <= 0) return false;
-	for (let i = latestInputMessage - 1; i >= 0; i--) {
-		const message = messages[i];
-		if (message.role !== "user" && message.role !== "developer" && message.role !== "system") continue;
-		if (typeof message.content === "string") {
-			messages[i] = {
-				...message,
-				content: [{
-					type: "text",
-					text: message.content,
-					prompt_cache_breakpoint: { mode: "explicit" }
-				}]
-			};
-			return true;
-		}
-		for (let j = message.content.length - 1; j >= 0; j--) {
-			const block = message.content[j];
-			if (!isChatCompletionsPromptCacheableContentBlock(block)) continue;
-			Object.assign(block, { prompt_cache_breakpoint: { mode: "explicit" } });
-			return true;
-		}
-	}
-	return false;
-}
-function applyOpenAIChatCompletionsPromptCachePolicy(params, model, options) {
-	const promptCacheKey = getOpenAIPromptCacheKey(options);
-	if (model.compat.supportsPromptCacheKey && promptCacheKey !== void 0) params.prompt_cache_key = promptCacheKey;
-	const promptCache = options?.promptCache;
-	if (!promptCache || resolveCacheRetention(options?.cacheRetention) === "none") return;
-	if (!model.compat.supportsPromptCacheBreakpoints) {
-		if (promptCache.mode === "explicit") throw new ConfigurationError(`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; enable compat.supportsPromptCacheBreakpoints only for a compatible endpoint.`);
-		return;
-	}
-	params.prompt_cache_key = promptCacheKey;
-	params.prompt_cache_options = {
-		mode: promptCache.mode,
-		ttl: promptCache.ttl ?? model.compat.promptCacheBreakpointTtl
-	};
-	if (promptCache.mode === "explicit" && promptCache.breakpoint !== "none") markLatestStableChatCompletionsCacheBreakpoint(params.messages);
-}
-function buildParams(model, context, options, toolStrictModeOverride) {
-	const initialCompat = resolveOpenAICompatForRequest(model, options).compat;
-	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-	const params = {
-		model: resolveOpenAICompletionsModelId(model, options),
-		messages: [],
-		stream: true
-	};
-	let toolStrictMode = "none";
-	let strictToolsApplied = false;
-	if (initialCompat.supportsUsageInStreaming !== false) params.stream_options = { include_usage: true };
-	if (initialCompat.supportsStore) params.store = false;
-	if (initialCompat.supportsSamplingParams) {
-		if (options?.temperature !== void 0) params.temperature = options.temperature;
-		if (options?.topP !== void 0) params.top_p = options.topP;
-		if (options?.topK !== void 0) params.top_k = options.topK;
-		if (options?.minP !== void 0) params.min_p = options.minP;
-		if (initialCompat.supportsPenaltyAndStopParams) {
-			if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
-			if (options?.repetitionPenalty !== void 0) params.repetition_penalty = options.repetitionPenalty;
-			if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
-		}
-	}
-	if (options?.stopSequences?.length && initialCompat.supportsPenaltyAndStopParams) {
-		const seqs = options.stopSequences;
-		params.stop = seqs.length === 1 ? seqs[0] : seqs.slice(0, 4);
-	}
-	applyOpenAIServiceTier(params, options?.serviceTier, model);
-	if (context.tools?.length) {
-		const builtTools = convertTools(context.tools, initialCompat, toolStrictModeOverride);
-		params.tools = builtTools.tools;
-		toolStrictMode = builtTools.toolStrictMode;
-		strictToolsApplied = builtTools.strictToolsApplied;
-	} else if (context.tools === void 0 && hasToolHistory(context.messages)) params.tools = [];
-	if (options?.toolChoice && initialCompat.supportsToolChoice) params.tool_choice = mapToOpenAICompletionsToolChoice(options.toolChoice);
-	const forcedToolName = typeof params.tool_choice === "object" && params.tool_choice !== null && "function" in params.tool_choice ? params.tool_choice.function.name : void 0;
-	if (typeof params.tool_choice === "object" && params.tool_choice !== null && !initialCompat.supportsNamedToolChoice) {
-		if (forcedToolName !== void 0 && Array.isArray(params.tools) && params.tools.some((tool) => tool.type === "function" && tool.function.name === forcedToolName)) params.tools = params.tools.filter((tool) => tool.type === "function" && tool.function.name === forcedToolName);
-		params.tool_choice = "required";
-	}
-	if (forcedToolName !== void 0 && Array.isArray(params.tools) && params.tools.some((tool) => tool.type === "function" && tool.function.name === forcedToolName) && hasActiveNativeKimiK3Reasoning(model, options)) params.tool_choice = "required";
-	if (isForcedToolChoice(params.tool_choice) && !initialCompat.supportsForcedToolChoice) params.tool_choice = "auto";
-	if ((!Array.isArray(params.tools) || params.tools.length === 0) && (params.tool_choice === "none" || isForcedToolChoice(params.tool_choice))) delete params.tool_choice;
-	if (forcedToolName !== void 0 && (!Array.isArray(params.tools) || !params.tools.some((tool) => tool.type === "function" && tool.function.name === forcedToolName))) delete params.tool_choice;
-	if (shouldDropAutoToolChoiceForReasoning(model, initialCompat, params.tool_choice, options)) delete params.tool_choice;
-	const finalPolicy = resolveOpenAICompatPolicy(model, {
-		endpoint: "chat-completions",
-		reasoning: options?.reasoning,
-		disableReasoning: options?.disableReasoning,
-		toolChoice: params.tool_choice
-	});
-	const compat = finalPolicy.compat;
-	const messages = convertMessages(model, context, compat);
-	maybeAddAnthropicCacheControl(compat, messages);
-	params.messages = messages;
-	const outputToken = resolveOpenAIOutputTokenParam({
-		field: compat.maxTokensField,
-		maxTokens: options?.maxTokens,
-		maxTokensExplicit: options?.maxTokensExplicit ?? options?.maxTokens !== void 0,
-		modelMaxTokens: model.maxTokens,
-		omitMaxOutputTokens: model.omitMaxOutputTokens ?? false,
-		isOpenRouterHost: compat.isOpenRouterHost,
-		alwaysSendMaxTokens: compat.alwaysSendMaxTokens,
-		providerOutputClamp: resolveOpenAICompletionsOutputClamp(model, compat)
-	});
-	if (outputToken) {
-		if (outputToken.field === "max_tokens") params.max_tokens = outputToken.value;
-		else if (outputToken.field === "max_completion_tokens") params.max_completion_tokens = outputToken.value;
-	}
-	applyChatCompletionsToolStream(params, model, compat);
-	applyChatCompletionsReasoningParams(params, model, compat, {
-		...options,
-		toolChoice: params.tool_choice
-	});
-	dropOpenRouterKimiForcedToolReasoning(params, model, finalPolicy);
-	applyOpenAIGatewayRouting(params, compat, cacheRetention !== "none");
-	applyOpenAIExtraBody(params, compat.extraBody, { dropThinkingWhenReasoningEffort: compat.dropThinkingWhenReasoningEffort });
-	applyOpenAIChatCompletionsPromptCachePolicy(params, model, options);
-	return {
-		params,
-		toolStrictMode,
-		strictToolsApplied
-	};
-}
-function parseChunkUsage(rawUsage, model, premiumRequests, timestamp) {
-	const usageLike = rawUsage;
-	const rawPromptTokenDetails = usageLike.prompt_tokens_details;
-	const promptTokenDetails = typeof rawPromptTokenDetails === "object" && rawPromptTokenDetails !== null ? rawPromptTokenDetails : void 0;
-	const rawCompletionTokenDetails = usageLike.completion_tokens_details;
-	const completionTokenDetails = typeof rawCompletionTokenDetails === "object" && rawCompletionTokenDetails !== null ? rawCompletionTokenDetails : void 0;
-	const completionTokens = usageLike.completion_tokens;
-	const promptTokens = usageLike.prompt_tokens;
-	const cachedTokens = usageLike.cached_tokens;
-	const promptCacheHitTokens = usageLike.prompt_cache_hit_tokens;
-	const promptCacheMissTokens = usageLike.prompt_cache_miss_tokens;
-	const promptTokenCachedTokens = promptTokenDetails?.cached_tokens;
-	const cachedContentTokenCount = usageLike.cachedContentTokenCount;
-	const completionReasoningTokens = completionTokenDetails?.reasoning_tokens;
-	const cacheWriteTokens = promptTokenDetails?.cache_write_tokens;
-	const usage = {
-		...calculateOpenAIUsageAccounting({
-			promptTokens: typeof promptTokens === "number" ? promptTokens : 0,
-			outputTokens: typeof completionTokens === "number" ? completionTokens : 0,
-			cachedTokens: firstPositiveNumber(cachedTokens, promptCacheHitTokens, promptTokenCachedTokens, cachedContentTokenCount),
-			reasoningTokens: typeof completionReasoningTokens === "number" ? completionReasoningTokens : 0,
-			cacheWriteOpenRouter: typeof cacheWriteTokens === "number" ? cacheWriteTokens : void 0,
-			cacheWriteDeepSeek: typeof promptCacheMissTokens === "number" ? promptCacheMissTokens : void 0,
-			hasDeepSeekCacheHitAndMiss: typeof promptCacheHitTokens === "number" && typeof promptCacheMissTokens === "number"
-		}),
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		},
-		...premiumRequests !== void 0 ? { premiumRequests } : {}
-	};
-	calculateCost(model, usage, timestamp);
-	applyProviderReportedCost(model, usage, rawUsage);
-	return usage;
-}
-function maybeAddAnthropicCacheControl(compat, messages) {
-	if (compat.cacheControlFormat !== "anthropic") return;
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "developer") continue;
-		const content = msg.content;
-		if (typeof content === "string") {
-			if (content.trim().length === 0) continue;
-			msg.content = [Object.assign({
-				type: "text",
-				text: content
-			}, { cache_control: { type: "ephemeral" } })];
-			return;
-		}
-		if (!Array.isArray(content)) continue;
-		for (let j = content.length - 1; j >= 0; j--) {
-			const part = content[j];
-			if (part?.type === "text" && part.text.trim().length > 0) {
-				Object.assign(part, { cache_control: { type: "ephemeral" } });
-				return;
-			}
-		}
-	}
-}
-function convertMessages(model, context, compat) {
-	const params = [];
-	const maxNormalizedToolCallIdLength = compat.requiresMistralToolIds ? 9 : compat.usesOpenAIToolCallIdLimit ? 40 : void 0;
-	const duplicateToolCallIdSuffixPrefix = compat.requiresMistralToolIds ? "dup" : void 0;
-	const normalizeToolCallId = (id, source) => {
-		if (compat.requiresMistralToolIds) return normalizeMistralToolId(id, true);
-		if (!(source !== void 0 && source.provider === model.provider && source.api === model.api && source.model === model.id) && id.includes("|")) {
-			const [callId] = id.split("|");
-			return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-		}
-		if (compat.usesOpenAIToolCallIdLimit) return id.length > 40 ? id.slice(0, 40) : id;
-		return id;
-	};
-	const transformedMessages = transformMessages(context.messages, model, (id, _target, source) => normalizeToolCallId(id, source), maxNormalizedToolCallIdLength, duplicateToolCallIdSuffixPrefix, compat);
-	const remappedToolCallIds = /* @__PURE__ */ new Map();
-	let generatedToolCallIdCounter = 0;
-	const generateFallbackToolCallId = (seed) => {
-		generatedToolCallIdCounter += 1;
-		return `call_${Bun.hash(`${model.provider}:${model.id}:${seed}:${generatedToolCallIdCounter}`).toString(36)}`;
-	};
-	const rememberToolCallId = (originalId, normalizedId) => {
-		const queue = remappedToolCallIds.get(originalId);
-		if (queue) {
-			queue.push(normalizedId);
-			return;
-		}
-		remappedToolCallIds.set(originalId, [normalizedId]);
-	};
-	const consumeToolCallId = (originalId) => {
-		const queue = remappedToolCallIds.get(originalId);
-		if (!queue || queue.length === 0) return null;
-		const nextId = queue.shift() ?? null;
-		if (queue.length === 0) remappedToolCallIds.delete(originalId);
-		return nextId;
-	};
-	const ensureToolCallId = (rawId, seed, source) => {
-		const normalized = normalizeToolCallId(rawId, source);
-		if (normalized.trim().length > 0) return normalized;
-		return generateFallbackToolCallId(seed);
-	};
-	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
-	if (systemPrompts.length > 0) {
-		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
-		if (compat.supportsMultipleSystemMessages) for (const systemPrompt of systemPrompts) params.push({
-			role,
-			content: systemPrompt
-		});
-		else params.push({
-			role,
-			content: systemPrompts.join("\n\n")
-		});
-	}
-	let lastRole = null;
-	for (let i = 0; i < transformedMessages.length; i++) {
-		const msg = transformedMessages[i];
-		if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && (msg.role === "user" || msg.role === "developer")) params.push({
-			role: "assistant",
-			content: "I have processed the tool results."
-		});
-		const devAsUser = !compat.supportsDeveloperRole;
-		if (msg.role === "user" || msg.role === "developer") {
-			const role = !devAsUser && msg.role === "developer" ? "developer" : "user";
-			if (typeof msg.content === "string") {
-				const text = msg.content.toWellFormed();
-				if (text.trim().length === 0) continue;
-				params.push({
-					role,
-					content: text
-				});
-			} else {
-				const supportsImages = isOpenAICompletionsVisionSupported(model);
-				const content = [];
-				let omittedImages = false;
-				for (const item of msg.content) if (item.type === "text") {
-					const text = item.text.toWellFormed();
-					if (text.trim().length === 0) continue;
-					content.push({
-						type: "text",
-						text
-					});
-				} else if (supportsImages) content.push({
-					type: "image_url",
-					image_url: {
-						url: item.url ?? `data:${item.mimeType};base64,${item.data}`,
-						...item.detail && item.detail !== "original" ? { detail: item.detail } : {}
-					}
-				});
-				else omittedImages = true;
-				if (omittedImages) content.push({
-					type: "text",
-					text: NON_VISION_IMAGE_PLACEHOLDER
-				});
-				if (content.length === 0) continue;
-				params.push({
-					role: "user",
-					content
-				});
-			}
-		} else if (msg.role === "assistant") {
-			const assistantMsg = {
-				role: "assistant",
-				content: null
-			};
-			const nonEmptyTextBlocks = msg.content.filter((b) => b.type === "text").filter((b) => b.text && b.text.trim().length > 0);
-			if (nonEmptyTextBlocks.length > 0) assistantMsg.content = nonEmptyTextBlocks.map((b, i) => {
-				const text = b.text.toWellFormed();
-				return isDemotedThinking(b) && i < nonEmptyTextBlocks.length - 1 ? `${text}\n` : text;
-			}).join("");
-			const nonEmptyThinkingBlocks = msg.content.filter((b) => b.type === "thinking").filter((b) => b.thinking && b.thinking.trim().length > 0);
-			if (nonEmptyThinkingBlocks.length > 0) {
-				if (compat.requiresThinkingAsText) {
-					const thinkingText = nonEmptyThinkingBlocks.map((b) => renderDemotedThinking(model.id, b.thinking)).join(" ");
-					assistantMsg.content = typeof assistantMsg.content === "string" && assistantMsg.content.length > 0 ? `${thinkingText} ${assistantMsg.content}` : thinkingText;
-				} else if (compat.requiresReasoningContentForToolCalls) {
-					const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-					const wireField = compat.allowsSyntheticReasoningContentForToolCalls && (signature === "reasoning_content" || signature === "reasoning" || signature === "reasoning_text") ? signature : signature === "reasoning_content" || signature === "reasoning" || signature === "reasoning_text" ? compat.reasoningContentField ?? "reasoning_content" : void 0;
-					if (wireField) assistantMsg[wireField] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
-				} else if (compat.thinkingFormat === "zai" && model.reasoning) {
-					const reasoningField = compat.reasoningContentField ?? "reasoning_content";
-					assistantMsg[reasoningField] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
-				} else if (compat.replayReasoningContent) {
-					const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-					const reasoningField = signature === "reasoning_content" || signature === "reasoning" || signature === "reasoning_text" ? signature : compat.reasoningContentField ?? "reasoning_content";
-					assistantMsg[reasoningField] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
-				}
-			}
-			if (compat.requiresReasoningContentForToolCalls) {
-				const streamedReasoningField = nonEmptyThinkingBlocks[0]?.thinkingSignature;
-				const reasoningField = compat.allowsSyntheticReasoningContentForToolCalls && (streamedReasoningField === "reasoning_content" || streamedReasoningField === "reasoning" || streamedReasoningField === "reasoning_text") ? streamedReasoningField : compat.reasoningContentField ?? "reasoning_content";
-				if (!assistantMsg[reasoningField]) {
-					const reasoning = assistantMsg.reasoning;
-					const reasoningText = assistantMsg.reasoning_text;
-					if (reasoning && reasoningField !== "reasoning") assistantMsg[reasoningField] = reasoning;
-					else if (reasoningText && reasoningField !== "reasoning_text") assistantMsg[reasoningField] = reasoningText;
-					else if (nonEmptyThinkingBlocks.length > 0) assistantMsg[reasoningField] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
-				}
-			}
-			const toolCalls = msg.content.filter((b) => b.type === "toolCall");
-			const canUseSyntheticReasoningContent = compat.requiresReasoningContentForToolCalls && compat.allowsSyntheticReasoningContentForToolCalls && (compat.thinkingFormat === "openai" || compat.thinkingFormat === "openrouter" || compat.thinkingFormat === "zai");
-			const needsReasoningField = compat.requiresReasoningContentForAllAssistantTurns || toolCalls.length > 0;
-			let hasReasoningField = assistantMsg.reasoning_content !== void 0 || assistantMsg.reasoning !== void 0 || assistantMsg.reasoning_text !== void 0;
-			if (needsReasoningField && !hasReasoningField && compat.requiresReasoningContentForToolCalls && !compat.allowsSyntheticReasoningContentForToolCalls) {
-				const allThinkingBlocks = msg.content.filter((b) => b.type === "thinking");
-				if (allThinkingBlocks.length > 0) {
-					const signature = allThinkingBlocks[0].thinkingSignature;
-					if (signature === "reasoning_content" || signature === "reasoning" || signature === "reasoning_text") {
-						const reasoningField = compat.reasoningContentField ?? "reasoning_content";
-						assistantMsg[reasoningField] = allThinkingBlocks.map((b) => b.thinking).join("\n");
-						hasReasoningField = true;
-					}
-				}
-			}
-			if (needsReasoningField && !hasReasoningField && compat.requiresReasoningContentForToolCalls && !compat.allowsSyntheticReasoningContentForToolCalls) {
-				const reasoningField = compat.reasoningContentField ?? "reasoning_content";
-				assistantMsg[reasoningField] = "";
-				hasReasoningField = true;
-			}
-			if (toolCalls.length > 0 && canUseSyntheticReasoningContent && !hasReasoningField) {
-				const reasoningField = compat.reasoningContentField ?? "reasoning_content";
-				assistantMsg[reasoningField] = ".";
-				hasReasoningField = true;
-			}
-			if (toolCalls.length > 0) {
-				assistantMsg.tool_calls = toolCalls.map((tc, toolCallIndex) => {
-					const toolCallId = ensureToolCallId(tc.id, `${i}:${toolCallIndex}:${tc.name}`, msg);
-					rememberToolCallId(tc.id, toolCallId);
-					const replayedToolCall = {
-						id: normalizeMistralToolId(toolCallId, compat.requiresMistralToolIds),
-						type: "function",
-						function: {
-							name: tc.name,
-							arguments: serializeToolArguments(tc.arguments)
-						}
-					};
-					const extraContent = parseGeminiThoughtSignatureExtraContent(tc.thoughtSignature);
-					if (extraContent) replayedToolCall.extra_content = extraContent;
-					return replayedToolCall;
-				});
-				const reasoningDetails = toolCalls.flatMap((tc) => {
-					const thoughtSignature = tc.thoughtSignature;
-					if (!thoughtSignature) return [];
-					try {
-						const parsed = JSON.parse(thoughtSignature);
-						return getGeminiThoughtSignatureExtraContent(parsed) ? [] : [parsed];
-					} catch {
-						return [];
-					}
-				});
-				if (reasoningDetails.length > 0) assistantMsg.reasoning_details = reasoningDetails;
-			}
-			if (assistantMsg.content === null && (hasReasoningField || assistantMsg.tool_calls)) assistantMsg.content = "";
-			const content = assistantMsg.content;
-			const hasContent = content !== null && content !== void 0 && (typeof content === "string" ? content.length > 0 : content.length > 0);
-			if (!hasContent && assistantMsg.tool_calls && compat.requiresAssistantContentForToolCalls) assistantMsg.content = ".";
-			if (!hasContent && !assistantMsg.tool_calls && !hasReasoningField) continue;
-			params.push(assistantMsg);
-		} else if (msg.role === "toolResult") {
-			const imageBlocks = [];
-			let j = i;
-			for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
-				const toolMsg = transformedMessages[j];
-				const textResult = toolMsg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-				const supportsImages = isOpenAICompletionsVisionSupported(model);
-				const hasImages = toolMsg.content.some((c) => c.type === "image");
-				const omittedImages = hasImages && !supportsImages;
-				const hasText = textResult.length > 0;
-				const resolvedToolCallId = consumeToolCallId(toolMsg.toolCallId) ?? ensureToolCallId(toolMsg.toolCallId, `${j}:${toolMsg.toolName ?? "tool"}`);
-				const toolResultMsg = {
-					role: "tool",
-					content: (omittedImages ? joinTextWithImagePlaceholder(textResult, true) : hasText ? textResult : hasImages ? "(see attached image)" : "").toWellFormed(),
-					tool_call_id: normalizeMistralToolId(resolvedToolCallId, compat.requiresMistralToolIds)
-				};
-				if (compat.requiresToolResultName && toolMsg.toolName) toolResultMsg.name = toolMsg.toolName;
-				params.push(toolResultMsg);
-				if (hasImages && supportsImages) {
-					for (const block of toolMsg.content) if (block.type === "image") imageBlocks.push({
-						type: "image_url",
-						image_url: { url: block.url ?? `data:${block.mimeType};base64,${block.data}` }
-					});
-				}
-			}
-			i = j - 1;
-			if (imageBlocks.length > 0) {
-				if (compat.requiresAssistantAfterToolResult) params.push({
-					role: "assistant",
-					content: "I have processed the tool results."
-				});
-				params.push({
-					role: "user",
-					content: [{
-						type: "text",
-						text: "Attached image(s) from tool result:"
-					}, ...imageBlocks]
-				});
-				lastRole = "user";
-			} else lastRole = "toolResult";
-			continue;
-		}
-		lastRole = msg.role === "developer" ? model.reasoning && compat.supportsDeveloperRole ? "developer" : "system" : msg.role;
-	}
-	return params;
-}
-function convertTools(tools, compat, toolStrictModeOverride) {
-	const rejectRootObjectUnion = compat.rejectRootObjectUnion;
-	const adaptedTools = tools.map((tool) => {
-		const strict = !NO_STRICT && compat.supportsStrictMode !== false && tool.strict !== false;
-		const baseParameters = rejectRootObjectUnion ? flattenExclusiveRequiredRootUnion(toolWireSchema(tool)) : toolWireSchema(tool);
-		const adapted = adaptSchemaForStrict(baseParameters, strict);
-		return {
-			tool,
-			baseParameters,
-			parameters: adapted.schema,
-			strict: adapted.strict
-		};
-	});
-	const requestedStrictMode = toolStrictModeOverride ?? compat.toolStrictMode;
-	const toolStrictMode = requestedStrictMode === "none" ? "none" : requestedStrictMode === "all_strict" ? adaptedTools.every((tool) => tool.strict) ? "all_strict" : "none" : "mixed";
-	const wireTools = [];
-	let anyStrictEmitted = false;
-	for (const { tool, baseParameters, parameters, strict } of adaptedTools) {
-		const includeStrict = toolStrictMode === "all_strict" || toolStrictMode === "mixed" && strict;
-		const includeExplicitFalse = !includeStrict && tool.strict === false && toolStrictMode === "mixed" && compat.supportsStrictMode !== false;
-		const wireParameters = includeStrict ? parameters : baseParameters;
-		const emittedParameters = compat.toolSchemaFlavor === "moonshot-mfjs" ? normalizeSchemaForMoonshot(wireParameters) : compat.toolSchemaFlavor === "grammar" ? sanitizeSchemaForGrammar(wireParameters) : wireParameters;
-		const violation = findStrictToolSchemaViolation(emittedParameters, "#", { rejectRootObjectUnion });
-		if (violation) {
-			warn(`Tool "${tool.name}" omitted from the openai-completions request: its parameter schema is invalid for this provider at ${violation} (an enum/const value cannot match its declared type, or leftover xAI object-root union). Other tools are unaffected.`);
-			continue;
-		}
-		if (includeStrict) anyStrictEmitted = true;
-		wireTools.push({
-			type: "function",
-			function: {
-				name: tool.name,
-				description: tool.description || "",
-				parameters: emittedParameters,
-				...includeStrict ? { strict: true } : includeExplicitFalse ? { strict: false } : {}
-			}
-		});
-	}
-	return {
-		tools: wireTools,
-		toolStrictMode,
-		strictToolsApplied: wireTools.length > 0 && anyStrictEmitted
-	};
-}
-const EMPTY_OLLAMA_LENGTH_COMPLETION_MESSAGE = "Model returned no content: prompt filled the context window; raise Ollama num_ctx or shorten the prompt.";
-function mapStopReason(reason) {
-	if (reason === null) return { stopReason: "stop" };
-	switch (typeof reason === "string" ? reason.toLowerCase() : reason) {
-		case "stop":
-		case "end": return { stopReason: "stop" };
-		case "length":
-		case "max_tokens": return { stopReason: "length" };
-		case "function_call":
-		case "tool_calls": return { stopReason: "toolUse" };
-		case "content_filter": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: content_filter"
-		};
-		case "network_error": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: network_error"
-		};
-		case "error": return {
-			stopReason: "error",
-			errorMessage: "Provider returned error finish_reason"
-		};
-		case "insufficient_system_resource": return {
-			stopReason: "error",
-			errorMessage: "Provider returned error finish_reason: insufficient_system_resource"
-		};
-		default: return {
-			stopReason: "error",
-			errorMessage: `Provider finish_reason: ${reason}`
-		};
-	}
-}
-//#endregion
-export { openai_completions_exports as t };