@openclaw/ai 2026.8.1-beta.3 → 2026.9.1-beta.1

package/dist/internal/shared.mjs

@@ -1,5 +1,5 @@
-import { t as sanitizeSurrogates } from "../sanitize-unicode-BP7HLLZn.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, i as transformMessages, l as formatToolResultText, o as describeUnsupportedToolResultMedia, s as extractToolResultBlockText, u as hasMediaPayload } from "../host-DF_yxOsA.mjs";
-import { A as splitSystemPromptCacheBoundary, D as SYSTEM_PROMPT_CACHE_BOUNDARY, M as normalizePromptCapabilityIds, N as normalizeStructuredPromptSection, O as ensureSystemPromptCacheBoundary, P as sortPromptCacheToolsByName, i as clampReasoning, j as stripSystemPromptCacheBoundary, k as prependSystemPromptAdditionAfterCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel, t as adjustMaxTokensForThinking } from "../simple-options-oqsXB6U3.mjs";
+import { t as sanitizeSurrogates } from "../sanitize-unicode-DCkltN94.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, i as transformMessages, l as formatToolResultText, o as describeUnsupportedToolResultMedia, s as extractToolResultBlockText, u as hasMediaPayload } from "../host-D51fmkH6.mjs";
+import { a as SYSTEM_PROMPT_CACHE_BOUNDARY, c as splitSystemPromptCacheBoundary, d as normalizeStructuredPromptSection, f as sortPromptCacheToolsByName, i as clampReasoning, l as stripSystemPromptCacheBoundary, n as buildBaseOptions, o as ensureSystemPromptCacheBoundary, r as clampMaxTokensToModel, s as prependSystemPromptAdditionAfterCacheBoundary, t as adjustMaxTokensForThinking, u as normalizePromptCapabilityIds } from "../simple-options-CFj7x3J4.mjs";
 import { t as inspectTlsCertificateError } from "../tls-certificate-errors-DXSpluKI.mjs";
 export { SYSTEM_PROMPT_CACHE_BOUNDARY, adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToModel, clampReasoning, describeToolResultMediaPlaceholder, describeUnsupportedToolResultMedia, ensureSystemPromptCacheBoundary, extractToolResultBlockText, extractToolResultText, formatToolResultText, hasMediaPayload, inspectTlsCertificateError, isImageWithMediaPayload, normalizePromptCapabilityIds, normalizeStructuredPromptSection, prependSystemPromptAdditionAfterCacheBoundary, sanitizeSurrogates, sortPromptCacheToolsByName, splitSystemPromptCacheBoundary, stripSystemPromptCacheBoundary, transformMessages };

package/dist/{json-parse-CDnesDM_.mjs → json-parse-BuAJEbdW.mjs}

@@ -1,4 +1,4 @@
-import { t as asNonArrayRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { n as asNonArrayRecord } from "./utf16-slice-qz3nsy87.mjs";
 import { parse } from "partial-json";
 //#region packages/ai/src/utils/json-parse.ts
 const VALID_JSON_ESCAPES = /* @__PURE__ */ new Set([
@@ -126,5 +126,21 @@ function parseStreamingJson(partialJson) {
 		}
 	}
 }
+const TOOL_ARGUMENT_PREVIEW_FIRST_CHECKPOINT_CHARS = 512;
+/**
+* Streamed tool-call arguments are preview-only; the terminal parse re-reads
+* the full buffer authoritatively at content_block_stop. Reparsing every delta
+* scans an ever-growing buffer and makes assembly quadratic in the argument
+* size, so refresh previews on a geometric length schedule instead — bounded
+* staleness, linear total parse work.
+*/
+function createToolArgumentPreviewSchedule() {
+	let nextCheckpointChars = TOOL_ARGUMENT_PREVIEW_FIRST_CHECKPOINT_CHARS;
+	return (accumulatedChars) => {
+		if (accumulatedChars < nextCheckpointChars) return false;
+		nextCheckpointChars = accumulatedChars * 2;
+		return true;
+	};
+}
 //#endregion
-export { parseStreamingJson as n, repairJson as r, parseJsonWithRepair as t };
+export { repairJson as i, parseJsonWithRepair as n, parseStreamingJson as r, createToolArgumentPreviewSchedule as t };

package/dist/{mistral-D6hRXI7A.mjs → mistral-EiHdymeb.mjs}

@@ -1,13 +1,15 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, l as formatToolResultText, n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
-import { P as sortPromptCacheToolsByName, d as finalizeTerminalToolCallArguments, g as notifyProviderHttpResponse, j as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
+import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-DCkltN94.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, l as formatToolResultText, n as getAiTransportHost } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel } from "./simple-options-CFj7x3J4.mjs";
+import { _ as transportAbortError, f as notifyProviderHttpResponse, s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-ljShVIZB.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform--gtf0ZbR.mjs";
-import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-C01bQ5a3.mjs";
+import { t as mapOpenAIStopReason } from "./openai-stop-reason-Drnn_6Qj.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 import { randomUUID } from "node:crypto";
 import { HTTPClient, Mistral } from "@mistralai/mistralai";
 //#region packages/ai/src/providers/mistral.ts
@@ -107,7 +109,7 @@ const streamMistral = (model, context, options) => {
 			});
 			await consumeChatStream(model, output, stream, mistralStream);
 			if (options?.signal?.aborted) throw transportAbortError(options.signal);
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -241,6 +243,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
 	const toolBlockIdentities = /* @__PURE__ */ new Map();
+	const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
 	const normalizeMissingToolCallId = createMistralToolCallIdNormalizer();
 	const missingToolCallIdScope = randomUUID();
 	const createMissingToolCallId = (contentIndex) => normalizeMissingToolCallId(`${missingToolCallIdScope}:toolcall:${contentIndex}`);
@@ -320,6 +323,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 	for await (const event of mistralStream) {
 		const chunk = event.data;
 		output.responseId ||= chunk.id;
+		if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
 		if (chunk.usage) {
 			const promptTokens = chunk.usage.promptTokens || 0;
 			const cachedPromptTokens = readMistralCachedPromptTokens(chunk.usage, promptTokens);
@@ -334,7 +338,9 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 		if (!choice) continue;
 		if (choice.finishReason) {
 			terminalFinishReason = choice.finishReason;
-			output.stopReason = mapChatStopReason(choice.finishReason);
+			const { stopReason, errorMessage } = mapOpenAIStopReason(choice.finishReason === "model_length" ? "length" : choice.finishReason);
+			output.stopReason = stopReason;
+			if (errorMessage) output.errorMessage = errorMessage;
 		}
 		const delta = choice.delta;
 		if (delta.content !== null && delta.content !== void 0) {
@@ -445,6 +451,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 					partialArgs: ""
 				};
 				output.content.push(block);
+				toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
 				toolBlockIdentities.set(contentIndex, {
 					explicitIds: new Set(providedCallId ? [providedCallId] : []),
 					functionNames: new Set(functionName ? [functionName] : []),
@@ -472,7 +479,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 			if (toolCallIndex !== void 0) identity.indexes.add(toolCallIndex);
 			const argsDelta = typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {});
 			block.partialArgs = (block.partialArgs || "") + argsDelta;
-			block.arguments = parseStreamingJson(block.partialArgs);
+			if (toolArgumentPreviewSchedules.get(block)?.(block.partialArgs.length)) block.arguments = parseStreamingJson(block.partialArgs);
 			stream.push({
 				type: "toolcall_delta",
 				contentIndex,
@@ -661,16 +668,5 @@ function mapToolChoice(choice, convertedToolNames) {
 		function: { name: toolName }
 	};
 }
-function mapChatStopReason(reason) {
-	if (reason === null) return "stop";
-	switch (reason) {
-		case "stop": return "stop";
-		case "length":
-		case "model_length": return "length";
-		case "tool_calls": return "toolUse";
-		case "error": return "error";
-		default: return "stop";
-	}
-}
 //#endregion
 export { createBoundedMistralFetcher, streamMistral, streamSimpleMistral };

package/dist/{openai-chatgpt-responses-C339VIfT.mjs → openai-chatgpt-responses-DHpF9o1e.mjs}

@@ -1,23 +1,23 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-DF_yxOsA.mjs";
-import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-BG-1AsBI.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-Cd4hJG-S.mjs";
 import { c as resolveTimerTimeoutMs, i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
-import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-DvILoqBk.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { C as withProviderResponseHook, _ as notifyProviderStreamOpened, j as stripSystemPromptCacheBoundary, n as buildBaseOptions, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
+import { l as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-CFj7x3J4.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-Bv0FHkd0.mjs";
-import { F as commitResponsesEncryptedContentAttempt, G as suppressOpenAIResponsesCompaction, L as isInvalidEncryptedContentError, U as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-Cvt5MgEm.mjs";
-import { o as createOpenAIProviderAcceptanceHook, s as createOpenAIResponseHook } from "./openai-tool-projection-CHGLt03m.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-LJ1_rbi-.mjs";
+import { C as headersToRecord, _ as transportAbortError, p as notifyProviderStreamOpened, y as withProviderResponseHook } from "./transport-stream-shared-ljShVIZB.mjs";
+import { F as commitResponsesEncryptedContentAttempt, G as suppressOpenAIResponsesCompaction, L as isInvalidEncryptedContentError, U as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DJThc6jW.mjs";
+import { C as createOpenAIProviderAcceptanceHook, w as createOpenAIResponseHook } from "./openai-tool-schema-ho-hIkQf.mjs";
 import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-QUY12X0B.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import "./diagnostics.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
-import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 import { t as inspectTlsCertificateError } from "./tls-certificate-errors-DXSpluKI.mjs";
 //#region packages/ai/src/internal/retry-sleep.ts
 function sleepWithAbort(ms, signal) {
@@ -154,6 +154,12 @@ function isRequestTimeoutError(error, callerSignal, requestSignal, timeoutMs) {
 	if (!(error instanceof Error)) return false;
 	return error.name === "AbortError" || error.name === "TimeoutError" || error.message === "Request was aborted";
 }
+/** Local-only failure category for transport diagnostics; never provider text. */
+function classifyStreamFailure(error, signal, requestTimedOut) {
+	if (requestTimedOut) return "timeout";
+	if (signal?.aborted) return "caller-abort";
+	return error instanceof ResponsesStreamFailure || error instanceof CodexApiError ? "provider-failure" : "transport";
+}
 function formatRequestTimeoutError(timeoutMs, cause) {
 	return new Error(`Request timed out after ${timeoutMs}ms`, { cause: cause instanceof Error ? cause : void 0 });
 }
@@ -171,6 +177,7 @@ function compressRequestBodyZstd(bodyJson) {
 const streamOpenAICodexResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	(async () => {
+		const startedAt = Date.now();
 		let requestTimeoutMs;
 		let requestTimeoutSignal;
 		let activeSignal;
@@ -364,9 +371,19 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
-			const normalizedError = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
+			const requestTimedOut = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0;
+			const normalizedError = requestTimedOut && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
 			for (const block of output.content) delete block.partialJson;
 			const terminal = projectProviderError(normalizedError, options?.signal);
+			getAiTransportHost().logWarn("openai-transport", "ChatGPT Responses stream terminated", {
+				provider: model.provider,
+				api: model.api,
+				model: model.id,
+				transport: options?.transport || "auto",
+				elapsedMs: Math.max(0, Date.now() - startedAt),
+				stopReason: terminal.stopReason,
+				failureKind: classifyStreamFailure(error, options?.signal, requestTimedOut)
+			});
 			Object.assign(output, terminal);
 			stream.push({
 				type: "error",

package/dist/openai-completions-EFPiUGfS.mjs

@@ -0,0 +1,399 @@
+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-DCkltN94.mjs";
+import { n as getAiTransportHost } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
+import { c as splitSystemPromptCacheBoundary, f as sortPromptCacheToolsByName, n as buildBaseOptions } from "./simple-options-CFj7x3J4.mjs";
+import { _ as transportAbortError, y as withProviderResponseHook } from "./transport-stream-shared-ljShVIZB.mjs";
+import { E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, _ as hasToolCallHistory, b as resolveOpenAICompletionsCompat, g as convertMessages, h as resolveOpenAIReasoningEffortMap, t as processCompletionsStream, v as finalizeOpenAICompletionsToolCalls, w as clearPendingCommentaryText, x as resolveOpenAICompletionsResponseFormat } from "./openai-completions-stream-DUlGwRMz.mjs";
+import { C as createOpenAIProviderAcceptanceHook, T as isOpenAICompletionsThinkingEnabled, j as resolveOpenAIClientBaseUrl, v as projectOpenAITools, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-ho-hIkQf.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.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
+});
+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 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
+				})
+			});
+			const finishedBlocks = /* @__PURE__ */ new Set();
+			const contentIndices = /* @__PURE__ */ new WeakMap();
+			let openTextBlock;
+			let openThinkingBlock;
+			const finishBlock = (block) => {
+				const contentIndex = contentIndices.get(block);
+				if (contentIndex === void 0 || finishedBlocks.has(block)) return;
+				finishedBlocks.add(block);
+				if (block.type === "text") {
+					openTextBlock = void 0;
+					stream.push({
+						type: "text_end",
+						contentIndex,
+						content: block.text,
+						partial: output
+					});
+				} else if (block.type === "thinking") {
+					openThinkingBlock = void 0;
+					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 directEventStream = { push(event) {
+				if (event.type === "text_start" || event.type === "thinking_start" || event.type === "toolcall_start") {
+					const block = output.content[event.contentIndex];
+					if (block) {
+						contentIndices.set(block, event.contentIndex);
+						if (block.type === "text") openTextBlock = block;
+						else if (block.type === "thinking") openThinkingBlock = block;
+					}
+				}
+				stream.push(event);
+			} };
+			try {
+				await processCompletionsStream(hookedOpenAIStream, output, model, directEventStream, {
+					mode: "direct",
+					beforeContentBlock(nextType) {
+						if (openThinkingBlock) finishBlock(openThinkingBlock);
+						if (openTextBlock && nextType !== "toolCall") finishBlock(openTextBlock);
+					},
+					provisionalCommentaryTags,
+					signal: options?.signal,
+					emitReasoning: shouldEmitReasoning,
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options)
+				});
+				if (options?.signal?.aborted) throw transportAbortError(options.signal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+			} catch (error) {
+				for (const block of output.content) if (block.type !== "toolCall") finishBlock(block);
+				throw error;
+			}
+			for (const block of output.content) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
+			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: resolveOpenAIClientBaseUrl(model, 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 };

package/dist/{openai-completions-compat-B0KTleXp.d.mts → openai-completions-compat-BefmHT26.d.mts}

@@ -1,6 +1,6 @@
-import { D as Model, k as OpenAICompletionsCompat } from "./types-DTAP49HF.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DJq_FGcz.mjs";
-
+import { D as Model, k as OpenAICompletionsCompat } from "./types-DhLoJbFm.mjs";
+import "./index-Qbej8io0.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DsbPMFU6.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";