@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/mistral-CePVNdws.mjs

@@ -0,0 +1,563 @@
+import { n as getEnvApiKey } from "./env-api-keys-CtMlqaQ4.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
+import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-DgmOla96.mjs";
+import { n as parseStreamingJson } from "./json-parse-DzNSIQBq.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { b as stripSystemPromptCacheBoundary, i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as buildBaseOptions, t as transformMessages } from "./transform-messages-BhGF_fF4.mjs";
+import { t as shortHash } from "./hash-CHgqbJmD.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { HTTPClient, Mistral } from "@mistralai/mistralai";
+//#region packages/ai/src/providers/mistral.ts
+const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
+const MAX_MISTRAL_ERROR_BODY_CHARS = 4e3;
+const MISTRAL_STREAM_BODY_MAX_BYTES = 16 * 1024 * 1024;
+/**
+* Builds a `Fetcher` that wraps the default `fetch` with a 16 MiB byte cap
+* on streamed response bodies. The wrapped `Response.body` exposes a
+* `ReadableStream` whose chunks flow through `createSseByteGuard`, so the
+* SDK's internal SSE parser (`EventStream` in
+* `@mistralai/mistralai/lib/event-streams.ts`) reads exactly as it would on
+* an unbounded body — but bounded.
+*
+* Bodyless responses (no `body` or no `getReader`) are returned unchanged so
+* the SDK's error-path `res.arrayBuffer()` call still works.
+*/
+function createBoundedMistralFetcher(maxBytes = MISTRAL_STREAM_BODY_MAX_BYTES, upstreamFetch = fetch) {
+	return async (input, init) => {
+		const response = init == null ? await upstreamFetch(input) : await upstreamFetch(input, init);
+		if (!response.body || typeof response.body.getReader !== "function") return response;
+		const guard = createSseByteGuard(response.body.getReader(), {
+			maxBytes,
+			onOverflow: ({ size, maxBytes: cap }) => /* @__PURE__ */ new Error(`mistral: stream body exceeds ${cap} bytes (got ${size})`)
+		});
+		const guardedStream = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await guard.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(value);
+			},
+			async cancel(reason) {
+				await guard.cancel(reason);
+			}
+		});
+		return new Response(guardedStream, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	};
+}
+/**
+* Stream responses from Mistral using `chat.stream`.
+*/
+const streamMistral = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = createOutput(model);
+		try {
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+			if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+			const mistral = new Mistral({
+				apiKey,
+				serverURL: model.baseUrl,
+				httpClient: new HTTPClient({ fetcher: createBoundedMistralFetcher(MISTRAL_STREAM_BODY_MAX_BYTES, getAiTransportHost().buildModelFetch(model) ?? fetch) })
+			});
+			const normalizeMistralToolCallId = createMistralToolCallIdNormalizer();
+			let payload = buildChatPayload(model, context, transformMessages(context.messages, model, (id) => normalizeMistralToolCallId(id)), options);
+			const nextPayload = await options?.onPayload?.(payload, model);
+			if (nextPayload !== void 0) payload = nextPayload;
+			const mistralStream = await mistral.chat.stream(payload, buildRequestOptions(model, options));
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			await consumeChatStream(model, output, stream, mistralStream);
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) delete block.partialArgs;
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatMistralError(error);
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+/**
+* Maps provider-agnostic `SimpleStreamOptions` to Mistral options.
+*/
+const streamSimpleMistral = (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 reasoning = clampedReasoning === "off" ? void 0 : clampedReasoning;
+	const shouldUseReasoning = model.reasoning && reasoning !== void 0;
+	return streamMistral(model, context, {
+		...base,
+		promptMode: shouldUseReasoning && usesPromptModeReasoning(model) ? "reasoning" : void 0,
+		reasoningEffort: shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(model, reasoning) : void 0
+	});
+};
+function createOutput(model) {
+	return {
+		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()
+	};
+}
+function createMistralToolCallIdNormalizer() {
+	const idMap = /* @__PURE__ */ new Map();
+	const reverseMap = /* @__PURE__ */ new Map();
+	return (id) => {
+		const existing = idMap.get(id);
+		if (existing) return existing;
+		let attempt = 0;
+		while (true) {
+			const candidate = deriveMistralToolCallId(id, attempt);
+			const owner = reverseMap.get(candidate);
+			if (!owner || owner === id) {
+				idMap.set(id, candidate);
+				reverseMap.set(candidate, id);
+				return candidate;
+			}
+			attempt++;
+		}
+	};
+}
+function deriveMistralToolCallId(id, attempt) {
+	const normalized = id.replace(/[^a-zA-Z0-9]/g, "");
+	if (attempt === 0 && normalized.length === MISTRAL_TOOL_CALL_ID_LENGTH) return normalized;
+	const seedBase = normalized || id;
+	return shortHash(attempt === 0 ? seedBase : `${seedBase}:${attempt}`).replace(/[^a-zA-Z0-9]/g, "").slice(0, MISTRAL_TOOL_CALL_ID_LENGTH);
+}
+function formatMistralError(error) {
+	if (error instanceof Error) {
+		const sdkError = error;
+		const statusCode = typeof sdkError.statusCode === "number" ? sdkError.statusCode : void 0;
+		const bodyText = typeof sdkError.body === "string" ? sdkError.body.trim() : void 0;
+		if (statusCode !== void 0 && bodyText) return `Mistral API error (${statusCode}): ${truncateErrorText(bodyText, MAX_MISTRAL_ERROR_BODY_CHARS)}`;
+		if (statusCode !== void 0) return `Mistral API error (${statusCode}): ${error.message}`;
+		return error.message;
+	}
+	return safeJsonStringify(error);
+}
+function truncateErrorText(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function safeJsonStringify(value) {
+	try {
+		const serialized = JSON.stringify(value);
+		return serialized === void 0 ? String(value) : serialized;
+	} catch {
+		return String(value);
+	}
+}
+function buildRequestOptions(model, options) {
+	const requestOptions = { retries: { strategy: "none" } };
+	if (options?.signal) requestOptions.signal = options.signal;
+	const headers = {};
+	if (model.headers) Object.assign(headers, model.headers);
+	if (options?.headers) Object.assign(headers, options.headers);
+	if (options?.sessionId && !headers["x-affinity"]) headers["x-affinity"] = options.sessionId;
+	if (Object.keys(headers).length > 0) requestOptions.headers = headers;
+	return requestOptions;
+}
+function buildChatPayload(model, context, messages, options) {
+	const payload = {
+		model: model.id,
+		stream: true,
+		messages: toChatMessages(messages, model.input.includes("image"))
+	};
+	let convertedToolNames;
+	if (context.tools?.length) {
+		const tools = toFunctionTools(context.tools);
+		convertedToolNames = new Set(tools.map((tool) => tool.function.name));
+		if (tools.length > 0) payload.tools = tools;
+	}
+	if (options?.temperature !== void 0) payload.temperature = options.temperature;
+	if (options?.maxTokens !== void 0) payload.maxTokens = options.maxTokens;
+	if (options?.stop !== void 0 && options.stop.length > 0) payload.stop = options.stop;
+	if (options?.toolChoice) {
+		const toolChoice = mapToolChoice(options.toolChoice, convertedToolNames);
+		if (toolChoice) payload.toolChoice = toolChoice;
+	}
+	if (options?.promptMode) payload.promptMode = options.promptMode;
+	if (options?.reasoningEffort) payload.reasoningEffort = options.reasoningEffort;
+	if (context.systemPrompt) payload.messages.unshift({
+		role: "system",
+		content: sanitizeSurrogates(stripSystemPromptCacheBoundary(context.systemPrompt))
+	});
+	return payload;
+}
+async function consumeChatStream(model, output, stream, mistralStream) {
+	let currentBlock = null;
+	const blocks = output.content;
+	const blockIndex = () => blocks.length - 1;
+	const toolBlocksByKey = /* @__PURE__ */ new Map();
+	const finishCurrentBlock = (block) => {
+		if (!block) return;
+		if (block.type === "text") {
+			stream.push({
+				type: "text_end",
+				contentIndex: blockIndex(),
+				content: block.text,
+				partial: output
+			});
+			return;
+		}
+		if (block.type === "thinking") stream.push({
+			type: "thinking_end",
+			contentIndex: blockIndex(),
+			content: block.thinking,
+			partial: output
+		});
+	};
+	for await (const event of mistralStream) {
+		const chunk = event.data;
+		output.responseId ||= chunk.id;
+		if (chunk.usage) {
+			output.usage.input = chunk.usage.promptTokens || 0;
+			output.usage.output = chunk.usage.completionTokens || 0;
+			output.usage.cacheRead = 0;
+			output.usage.cacheWrite = 0;
+			output.usage.totalTokens = chunk.usage.totalTokens || output.usage.input + output.usage.output;
+			calculateCost(model, output.usage);
+		}
+		const choice = chunk.choices[0];
+		if (!choice) continue;
+		if (choice.finishReason) output.stopReason = mapChatStopReason(choice.finishReason);
+		const delta = choice.delta;
+		if (delta.content !== null && delta.content !== void 0) {
+			const contentItems = typeof delta.content === "string" ? [delta.content] : delta.content;
+			for (const item of contentItems) {
+				if (typeof item === "string") {
+					const textDelta = sanitizeSurrogates(item);
+					if (!currentBlock || currentBlock.type !== "text") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = {
+							type: "text",
+							text: ""
+						};
+						output.content.push(currentBlock);
+						stream.push({
+							type: "text_start",
+							contentIndex: blockIndex(),
+							partial: output
+						});
+					}
+					currentBlock.text += textDelta;
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta: textDelta,
+						partial: output
+					});
+					continue;
+				}
+				if (item.type === "thinking") {
+					const thinkingDelta = sanitizeSurrogates(item.thinking.map((part) => "text" in part ? part.text : "").filter((text) => text.length > 0).join(""));
+					if (!thinkingDelta) continue;
+					if (!currentBlock || currentBlock.type !== "thinking") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = {
+							type: "thinking",
+							thinking: ""
+						};
+						output.content.push(currentBlock);
+						stream.push({
+							type: "thinking_start",
+							contentIndex: blockIndex(),
+							partial: output
+						});
+					}
+					currentBlock.thinking += thinkingDelta;
+					stream.push({
+						type: "thinking_delta",
+						contentIndex: blockIndex(),
+						delta: thinkingDelta,
+						partial: output
+					});
+					continue;
+				}
+				if (item.type === "text") {
+					const textDelta = sanitizeSurrogates(item.text);
+					if (!currentBlock || currentBlock.type !== "text") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = {
+							type: "text",
+							text: ""
+						};
+						output.content.push(currentBlock);
+						stream.push({
+							type: "text_start",
+							contentIndex: blockIndex(),
+							partial: output
+						});
+					}
+					currentBlock.text += textDelta;
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta: textDelta,
+						partial: output
+					});
+				}
+			}
+		}
+		const toolCalls = delta.toolCalls || [];
+		for (const toolCall of toolCalls) {
+			if (currentBlock) {
+				finishCurrentBlock(currentBlock);
+				currentBlock = null;
+			}
+			const callId = toolCall.id && toolCall.id !== "null" ? toolCall.id : deriveMistralToolCallId(`toolcall:${toolCall.index ?? 0}`, 0);
+			const key = `${callId}:${toolCall.index || 0}`;
+			const existingIndex = toolBlocksByKey.get(key);
+			let block;
+			if (existingIndex !== void 0) {
+				const existing = output.content[existingIndex];
+				if (existing?.type === "toolCall") block = existing;
+			}
+			if (!block) {
+				block = {
+					type: "toolCall",
+					id: callId,
+					name: toolCall.function.name,
+					arguments: {},
+					partialArgs: ""
+				};
+				output.content.push(block);
+				toolBlocksByKey.set(key, output.content.length - 1);
+				stream.push({
+					type: "toolcall_start",
+					contentIndex: output.content.length - 1,
+					partial: output
+				});
+			}
+			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);
+			stream.push({
+				type: "toolcall_delta",
+				contentIndex: toolBlocksByKey.get(key),
+				delta: argsDelta,
+				partial: output
+			});
+		}
+	}
+	finishCurrentBlock(currentBlock);
+	for (const index of toolBlocksByKey.values()) {
+		const block = output.content[index];
+		if (block.type !== "toolCall") continue;
+		const toolBlock = block;
+		toolBlock.arguments = parseStreamingJson(toolBlock.partialArgs);
+		delete toolBlock.partialArgs;
+		stream.push({
+			type: "toolcall_end",
+			contentIndex: index,
+			toolCall: toolBlock,
+			partial: output
+		});
+	}
+}
+function toFunctionTools(tools) {
+	return tools.flatMap((tool) => {
+		try {
+			return {
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: stripSymbolKeys(tool.parameters),
+					strict: false
+				}
+			};
+		} catch {
+			return [];
+		}
+	});
+}
+function stripSymbolKeys(value) {
+	if (Array.isArray(value)) return value.map((item) => stripSymbolKeys(item));
+	if (value && typeof value === "object") {
+		const result = {};
+		for (const [key, entry] of Object.entries(value)) result[key] = stripSymbolKeys(entry);
+		return result;
+	}
+	return value;
+}
+function toChatMessages(messages, supportsImages) {
+	const result = [];
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				result.push({
+					role: "user",
+					content: sanitizeSurrogates(msg.content)
+				});
+				continue;
+			}
+			const hadImages = msg.content.some((item) => item.type === "image");
+			const content = msg.content.filter((item) => item.type === "text" || supportsImages).map((item) => {
+				if (item.type === "text") return {
+					type: "text",
+					text: sanitizeSurrogates(item.text)
+				};
+				return {
+					type: "image_url",
+					imageUrl: `data:${item.mimeType};base64,${item.data}`
+				};
+			});
+			if (content.length > 0) {
+				result.push({
+					role: "user",
+					content
+				});
+				continue;
+			}
+			if (hadImages && !supportsImages) result.push({
+				role: "user",
+				content: "(image omitted: model does not support images)"
+			});
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const contentParts = [];
+			const toolCalls = [];
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (block.text.trim().length > 0) contentParts.push({
+						type: "text",
+						text: sanitizeSurrogates(block.text)
+					});
+					continue;
+				}
+				if (block.type === "thinking") {
+					if (block.thinking.trim().length > 0) contentParts.push({
+						type: "thinking",
+						thinking: [{
+							type: "text",
+							text: sanitizeSurrogates(block.thinking)
+						}]
+					});
+					continue;
+				}
+				toolCalls.push({
+					id: block.id,
+					type: "function",
+					function: {
+						name: block.name,
+						arguments: JSON.stringify(block.arguments || {})
+					}
+				});
+			}
+			const assistantMessage = { role: "assistant" };
+			if (contentParts.length > 0) assistantMessage.content = contentParts;
+			if (toolCalls.length > 0) assistantMessage.toolCalls = toolCalls;
+			if (contentParts.length > 0 || toolCalls.length > 0) result.push(assistantMessage);
+			continue;
+		}
+		const toolContent = [];
+		const toolText = buildToolResultText(extractToolResultText(msg.content), describeToolResultMediaPlaceholder(msg.content), msg.content.some((part) => part.type === "image"), supportsImages, msg.isError);
+		toolContent.push({
+			type: "text",
+			text: toolText
+		});
+		for (const part of msg.content) {
+			if (!supportsImages) continue;
+			if (part.type !== "image") continue;
+			toolContent.push({
+				type: "image_url",
+				imageUrl: `data:${part.mimeType};base64,${part.data}`
+			});
+		}
+		result.push({
+			role: "tool",
+			toolCallId: msg.toolCallId,
+			name: msg.toolName,
+			content: toolContent
+		});
+	}
+	return result;
+}
+function buildToolResultText(text, mediaPlaceholder, hasImages, supportsImages, isError) {
+	const trimmed = text.trim();
+	const errorPrefix = isError ? "[tool error] " : "";
+	if (trimmed.length > 0) return `${errorPrefix}${trimmed}${hasImages && !supportsImages ? "\n[tool image omitted: model does not support images]" : ""}`;
+	if (mediaPlaceholder) {
+		if (!hasImages || supportsImages) return `${errorPrefix}${mediaPlaceholder}`;
+		return `${errorPrefix}${mediaPlaceholder === "(see attached media)" ? "(media omitted: model does not support images)" : "(image omitted: model does not support images)"}`;
+	}
+	return isError ? "[tool error] (no tool output)" : "(no tool output)";
+}
+function usesReasoningEffort(model) {
+	return model.id === "mistral-small-2603" || model.id === "mistral-small-latest" || model.id === "mistral-medium-3-5";
+}
+function usesPromptModeReasoning(model) {
+	return model.reasoning && !usesReasoningEffort(model);
+}
+function mapReasoningEffort(model, level) {
+	return model.thinkingLevelMap?.[level] ?? "high";
+}
+function mapToolChoice(choice, convertedToolNames) {
+	if (!choice) return;
+	if (convertedToolNames && convertedToolNames.size === 0) {
+		if (choice === "none" || choice === "auto") return choice === "none" ? "none" : void 0;
+		throw new Error("Mistral tool_choice requires a tool, but no tools survived schema conversion");
+	}
+	if (choice === "auto" || choice === "none" || choice === "any" || choice === "required") return choice;
+	const toolName = choice.function.name;
+	if (convertedToolNames && !convertedToolNames.has(toolName)) throw new Error(`Mistral tool_choice requested unavailable tool "${toolName}" after schema conversion`);
+	return {
+		type: "function",
+		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/model-utils-DgmOla96.mjs

@@ -0,0 +1,69 @@
+import { c as resolveClaudeNativeThinkingLevelMap, i as requiresClaudeMandatoryAdaptiveThinking } from "./src-CZ503MYJ.mjs";
+//#region packages/ai/src/model-utils.ts
+/** Calculates and stores model cost fields from token usage and per-million pricing. */
+function calculateCost(model, usage) {
+	usage.cost.input = model.cost.input / 1e6 * usage.input;
+	usage.cost.output = model.cost.output / 1e6 * usage.output;
+	usage.cost.cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
+	usage.cost.cacheWrite = model.cost.cacheWrite / 1e6 * usage.cacheWrite;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+/** Replaces the catalog estimate when the provider reports an authoritative billed total. */
+function applyProviderReportedUsageCost(usage, reportedCost) {
+	if (typeof reportedCost !== "number" || !Number.isFinite(reportedCost) || reportedCost < 0) return;
+	usage.cost.total = reportedCost;
+	usage.cost.totalOrigin = "provider-billed";
+}
+const EXTENDED_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function resolveThinkingLevelMap(model) {
+	return model.api === "anthropic-messages" ? resolveClaudeNativeThinkingLevelMap(model) ?? model.thinkingLevelMap : model.thinkingLevelMap;
+}
+/** Returns thinking levels exposed by a reasoning-capable model. */
+function getSupportedThinkingLevels(model) {
+	const mandatoryAdaptiveContract = model.api === "anthropic-messages" && requiresClaudeMandatoryAdaptiveThinking(model);
+	if (!model.reasoning && !mandatoryAdaptiveContract) return ["off"];
+	const thinkingLevelMap = resolveThinkingLevelMap(model);
+	return EXTENDED_THINKING_LEVELS.filter((level) => {
+		const mapped = thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+/** Clamps a requested thinking level to the closest supported level for a model. */
+function clampThinkingLevel(model, level) {
+	const availableLevels = getSupportedThinkingLevels(model);
+	if (availableLevels.includes(level)) return level;
+	const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+	if (requestedIndex === -1) return availableLevels[0] ?? "off";
+	const thinkingLevelMap = resolveThinkingLevelMap(model);
+	if ((level === "xhigh" || level === "max") && thinkingLevelMap?.[level] === null) for (let i = requestedIndex - 1; i >= 0; i--) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	for (let i = requestedIndex - 1; i >= 0; i--) {
+		const candidate = EXTENDED_THINKING_LEVELS[i];
+		if (availableLevels.includes(candidate)) return candidate;
+	}
+	return availableLevels[0] ?? "off";
+}
+/** Compares model identity by provider and id. */
+function modelsAreEqual(a, b) {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}
+//#endregion
+export { modelsAreEqual as a, getSupportedThinkingLevels as i, calculateCost as n, clampThinkingLevel as r, applyProviderReportedUsageCost as t };

package/dist/openai-chatgpt-jwt-DhAAzLkj.mjs

@@ -0,0 +1,39 @@
+//#region packages/ai/src/session-resources.ts
+const sessionResourceCleanups = /* @__PURE__ */ new Set();
+/** Registers a session-resource cleanup hook and returns an unregister function. */
+function registerSessionResourceCleanup(cleanup) {
+	sessionResourceCleanups.add(cleanup);
+	return () => {
+		sessionResourceCleanups.delete(cleanup);
+	};
+}
+/** Runs all registered cleanup hooks, aggregating failures after every hook has run. */
+function cleanupSessionResources(sessionId) {
+	const errors = [];
+	for (const cleanup of sessionResourceCleanups) try {
+		cleanup(sessionId);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Failed to cleanup session resources");
+}
+//#endregion
+//#region packages/ai/src/utils/oauth/openai-chatgpt-jwt.ts
+const OPENAI_CODEX_AUTH_CLAIM = "https://api.openai.com/auth";
+function decodeOpenAICodexJwtPayload(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3) return null;
+	try {
+		const decoded = Buffer.from(parts[1] ?? "", "base64url").toString("utf8");
+		const parsed = JSON.parse(decoded);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function resolveOpenAICodexAccountId(token) {
+	const accountId = decodeOpenAICodexJwtPayload(token)?.[OPENAI_CODEX_AUTH_CLAIM]?.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.length > 0 ? accountId : null;
+}
+//#endregion
+export { registerSessionResourceCleanup as i, resolveOpenAICodexAccountId as n, cleanupSessionResources as r, decodeOpenAICodexJwtPayload as t };