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

package/dist/openai-responses-shared-pXl6Wd8S.mjs

@@ -1,392 +0,0 @@
-import { i as transformMessages, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
-import { t as projectOpenAITools } from "./openai-tool-projection-OhX64DoP.mjs";
-import { l as clampThinkingLevel } from "./number-coercion-DvG7SNMg.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
-import { Y as normalizeOpenAIStrictToolParameters, Z as resolveOpenAIProjectedToolsStrictToolFlag, _t as supportsOpenAITemperature, gt as supportsOpenAIReasoningEffort, mt as resolveOpenAIReasoningEffortForModel, n as processResponsesStream, q as findOpenAIStrictToolProjectionDiagnostics } from "./openai-responses-stream-internal-Cw5txaGW.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BBys9hSb.mjs";
-import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import "./transform-messages-C8mBqZxF.mjs";
-import { createHash } from "node:crypto";
-//#region packages/ai/src/providers/openai-responses-tools.ts
-const LOG_SUBSYSTEM = "llm/openai-responses";
-const MAX_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 64;
-const loggedStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
-/** Converts and returns the projection used to reconcile tool choices. */
-function convertResponsesToolPayload(tools, options) {
-	const projection = projectOpenAITools(tools);
-	const strict = resolveResponsesStrictToolFlag(projection, resolveResponsesStrictToolSetting(options), options?.model);
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const result = {
-				type: "function",
-				name: tool.name,
-				description: tool.description,
-				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, options?.model?.compat)
-			};
-			if (strict !== void 0) result.strict = strict;
-			return result;
-		})
-	};
-}
-function resolveResponsesStrictToolSetting(options) {
-	if (options?.strict !== void 0) return options.strict;
-	if (options?.model) return getAiTransportHost().resolveOpenAIStrictToolSetting(options.model, {
-		transport: "stream",
-		supportsStrictMode: options.supportsStrictMode
-	});
-	return false;
-}
-function resolveResponsesStrictToolFlag(projection, strictSetting, model) {
-	const strict = resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
-	if (strictSetting === true && strict === false && model) getAiTransportHost().logDebug(LOG_SUBSYSTEM, () => {
-		const diagnostics = findOpenAIStrictToolProjectionDiagnostics(projection);
-		if (!shouldLogStrictToolDowngradeDiagnostic(diagnostics, model)) return null;
-		const sample = diagnostics.slice(0, 5).map((entry) => ({
-			tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
-			violations: entry.violations.slice(0, 8)
-		}));
-		return {
-			message: `OpenAI responses tool schema strict mode downgraded to strict=false for ${model.provider ?? "unknown"}/${model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`,
-			data: {
-				provider: model.provider,
-				model: model.id,
-				incompatibleToolCount: diagnostics.length,
-				sample
-			}
-		};
-	});
-	return strict;
-}
-function shouldLogStrictToolDowngradeDiagnostic(diagnostics, model) {
-	const key = createHash("sha256").update(JSON.stringify({
-		provider: model.provider,
-		model: model.id,
-		diagnostics: diagnostics.map((entry) => ({
-			toolIndex: entry.toolIndex,
-			toolName: entry.toolName ?? null,
-			violations: entry.violations
-		}))
-	})).digest("hex");
-	if (loggedStrictToolDowngradeDiagnosticKeys.has(key)) return false;
-	if (loggedStrictToolDowngradeDiagnosticKeys.size >= MAX_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedStrictToolDowngradeDiagnosticKeys.clear();
-	loggedStrictToolDowngradeDiagnosticKeys.add(key);
-	return true;
-}
-//#endregion
-//#region packages/ai/src/providers/openai-responses-shared.ts
-const EMPTY_TOOL_RESULT_TEXT = "(no output)";
-function splitResponsesToolCallId(id) {
-	const separatorIndex = id.indexOf("|");
-	return separatorIndex === -1 ? [id, void 0] : [id.slice(0, separatorIndex), id.slice(separatorIndex + 1)];
-}
-function sanitizeToolResultText(text, fallback) {
-	const sanitized = sanitizeSurrogates(text);
-	return sanitized.trim().length > 0 ? sanitized : fallback;
-}
-function normalizeResponsesReasoningReplayItem(params) {
-	const next = { ...params.item };
-	if (!Array.isArray(next.summary)) next.summary = [];
-	if (!params.replayResponsesItemIds) delete next.id;
-	return next;
-}
-function parseTextSignature(signature) {
-	if (!signature) return;
-	if (signature.startsWith("{")) try {
-		const parsed = JSON.parse(signature);
-		if (parsed.v === 1) {
-			const id = typeof parsed.id === "string" ? parsed.id : void 0;
-			const phase = parsed.phase === "commentary" || parsed.phase === "final_answer" ? parsed.phase : void 0;
-			if (id !== void 0 || phase !== void 0) return {
-				id,
-				phase
-			};
-			return;
-		}
-	} catch {}
-	return { id: signature };
-}
-function resolveReplayableResponsesMessageId(params) {
-	if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
-	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
-}
-function isResponsesReasoningEffort(effort) {
-	return effort === "minimal" || effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh" || effort === "max";
-}
-function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
-	const messages = [];
-	const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
-	const normalizeIdPart = (part) => {
-		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
-		return (sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized).replace(/_+$/, "");
-	};
-	const buildForeignResponsesItemId = (itemId) => {
-		const normalized = `fc_${shortHash(itemId)}`;
-		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
-	};
-	const normalizeToolCallId = (id, targetModel, source) => {
-		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
-		if (!id.includes("|")) return normalizeIdPart(id);
-		const [callId, itemId = ""] = splitResponsesToolCallId(id);
-		const normalizedCallId = normalizeIdPart(callId);
-		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
-		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
-		return `${normalizedCallId}|${normalizedItemId}`;
-	};
-	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
-		const compat = model.compat;
-		const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
-		messages.push({
-			type: "message",
-			role,
-			content: [{
-				type: "input_text",
-				text: sanitizeSurrogates(stripSystemPromptCacheBoundary(context.systemPrompt))
-			}]
-		});
-	}
-	let msgIndex = 0;
-	for (const msg of transformedMessages) {
-		if (msg.role === "user") if (typeof msg.content === "string") messages.push({
-			type: "message",
-			role: "user",
-			content: [{
-				type: "input_text",
-				text: sanitizeSurrogates(msg.content)
-			}]
-		});
-		else {
-			const content = msg.content.map((item) => {
-				if (item.type === "text") return {
-					type: "input_text",
-					text: sanitizeSurrogates(item.text)
-				};
-				return {
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${item.mimeType};base64,${item.data}`
-				};
-			});
-			if (content.length === 0) continue;
-			messages.push({
-				type: "message",
-				role: "user",
-				content
-			});
-		}
-		else if (msg.role === "assistant") {
-			const output = [];
-			let textFallbackOrdinal = 0;
-			const assistantMsg = msg;
-			let previousReplayItemWasReasoning = false;
-			const isDifferentModel = assistantMsg.model !== model.id && assistantMsg.provider === model.provider && assistantMsg.api === model.api;
-			for (const block of msg.content) if (block.type === "thinking") {
-				if (block.thinkingSignature) {
-					const reasoningItem = normalizeResponsesReasoningReplayItem({
-						item: JSON.parse(block.thinkingSignature),
-						replayResponsesItemIds: shouldReplayResponsesItemIds
-					});
-					output.push(reasoningItem);
-					previousReplayItemWasReasoning = true;
-				}
-			} else if (block.type === "text") {
-				const textBlock = block;
-				const parsedSignature = parseTextSignature(textBlock.textSignature);
-				let msgId = shouldReplayResponsesItemIds ? resolveReplayableResponsesMessageId({
-					textSignatureId: parsedSignature?.id,
-					fallbackId: `msg_${msgIndex}`,
-					fallbackOrdinal: textFallbackOrdinal,
-					previousReplayItemWasReasoning
-				}) : void 0;
-				if (!parsedSignature?.id) textFallbackOrdinal += 1;
-				if (msgId && msgId.length > 64) msgId = `msg_${shortHash(msgId)}`;
-				const messageItem = {
-					type: "message",
-					role: "assistant",
-					content: [{
-						type: "output_text",
-						text: sanitizeSurrogates(textBlock.text),
-						annotations: []
-					}],
-					status: "completed",
-					...msgId ? { id: msgId } : {},
-					phase: parsedSignature?.phase
-				};
-				output.push(messageItem);
-				previousReplayItemWasReasoning = false;
-			} else if (block.type === "toolCall") {
-				const toolCall = block;
-				const [callId, itemIdRaw] = splitResponsesToolCallId(toolCall.id);
-				let itemId = shouldReplayResponsesItemIds ? itemIdRaw : void 0;
-				if (shouldReplayResponsesItemIds && isDifferentModel && itemId?.startsWith("fc_")) itemId = void 0;
-				output.push({
-					type: "function_call",
-					...itemId ? { id: itemId } : {},
-					call_id: callId,
-					name: toolCall.name,
-					arguments: JSON.stringify(toolCall.arguments)
-				});
-				previousReplayItemWasReasoning = false;
-			}
-			if (output.length === 0) continue;
-			messages.push(...output);
-		} else if (msg.role === "toolResult") {
-			const textResult = extractToolResultText(msg.content);
-			const sanitizedTextResult = sanitizeSurrogates(textResult);
-			const hasImages = msg.content.some(isImageWithMediaPayload);
-			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
-			const hasText = sanitizedTextResult.trim().length > 0;
-			const [callId] = splitResponsesToolCallId(msg.toolCallId);
-			let output;
-			if (hasImages && model.input.includes("image")) {
-				const contentParts = [];
-				if (hasText) contentParts.push({
-					type: "input_text",
-					text: sanitizedTextResult
-				});
-				else if (mediaPlaceholder === "(see attached media)") contentParts.push({
-					type: "input_text",
-					text: mediaPlaceholder
-				});
-				for (const block of msg.content) if (isImageWithMediaPayload(block)) contentParts.push({
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${block.mimeType};base64,${block.data}`
-				});
-				output = contentParts;
-			} else output = sanitizeToolResultText(textResult, mediaPlaceholder ?? EMPTY_TOOL_RESULT_TEXT);
-			messages.push({
-				type: "function_call_output",
-				call_id: callId,
-				output
-			});
-		}
-		msgIndex++;
-	}
-	return messages;
-}
-function createResponsesAssistantOutput(model, api = model.api) {
-	return {
-		role: "assistant",
-		content: [],
-		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 resolveResponsesReasoningEffort(model, reasoning) {
-	const clampedReasoning = reasoning ? clampThinkingLevel(model, reasoning) : void 0;
-	if (!clampedReasoning || clampedReasoning === "off") return;
-	if (clampedReasoning === "max") return supportsOpenAIReasoningEffort(model, "max") ? "max" : "xhigh";
-	if (clampedReasoning === "minimal" && model.provider === "openai" && supportsOpenAIReasoningEffort(model, "max")) {
-		const effort = resolveOpenAIReasoningEffortForModel({
-			model,
-			effort: "minimal"
-		});
-		return isResponsesReasoningEffort(effort) ? effort : void 0;
-	}
-	return clampedReasoning;
-}
-function applyCommonResponsesParams(params, model, context, options, config) {
-	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
-	if (context.tools) {
-		const converted = convertResponsesToolPayload(context.tools, { model });
-		if (converted.tools.length > 0) params.tools = converted.tools;
-	}
-	if (!model.reasoning) return;
-	if (options?.reasoningEffort || options?.reasoningSummary) {
-		params.reasoning = {
-			effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium",
-			summary: options?.reasoningSummary || "auto"
-		};
-		params.include = ["reasoning.encrypted_content"];
-	} else if ((config?.setDefaultReasoningOff ?? true) && model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
-}
-function buildResponsesRequestOptions(options) {
-	return {
-		...options?.signal ? { signal: options.signal } : {},
-		...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-		maxRetries: options?.maxRetries ?? 0
-	};
-}
-function cleanStreamingScratchBuffers(output) {
-	for (const block of output.content) {
-		delete block.index;
-		delete block.partialJson;
-	}
-}
-async function runResponsesStreamLifecycle(params) {
-	const { stream, model, output, options } = params;
-	let firstEventAbort;
-	try {
-		const client = params.createClient();
-		let requestParams = params.buildParams();
-		const nextParams = await options?.onPayload?.(requestParams, model);
-		if (nextParams !== void 0) requestParams = nextParams;
-		firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-		const { data: openaiStream, response } = await client.responses.create(requestParams, {
-			...buildResponsesRequestOptions(options),
-			signal: firstEventAbort.signal
-		}).withResponse();
-		await options?.onResponse?.({
-			status: response.status,
-			headers: headersToRecord(response.headers)
-		}, model);
-		stream.push({
-			type: "start",
-			partial: output
-		});
-		const firstEventTimeoutMs = getFirstStreamEventTimeoutMs(options);
-		const onFirstEventTimeout = getFirstStreamEventTimeoutHandler(options);
-		await processResponsesStream(openaiStream, output, stream, model, params.processStreamOptions || firstEventTimeoutMs !== void 0 || onFirstEventTimeout !== void 0 ? {
-			...params.processStreamOptions,
-			firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
-			abortFirstEventStream: params.processStreamOptions?.abortFirstEventStream ?? firstEventAbort.abort,
-			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
-			signal: params.processStreamOptions?.signal ?? options?.signal
-		} : void 0);
-		if (options?.signal?.aborted) throw transportAbortError(options.signal);
-		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
-		stream.push({
-			type: "done",
-			reason: output.stopReason,
-			message: output
-		});
-		stream.end();
-	} catch (error) {
-		cleanStreamingScratchBuffers(output);
-		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-		output.errorMessage = params.formatError(error);
-		stream.push({
-			type: "error",
-			reason: output.stopReason,
-			error: output
-		});
-		stream.end();
-	} finally {
-		firstEventAbort?.dispose();
-	}
-}
-//#endregion
-export { runResponsesStreamLifecycle as a, resolveResponsesReasoningEffort as i, convertResponsesMessages as n, convertResponsesToolPayload as o, createResponsesAssistantOutput as r, applyCommonResponsesParams as t };

package/dist/openai-tool-projection-OhX64DoP.mjs

@@ -1,215 +0,0 @@
-import { g as isRecord, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
-//#region packages/ai/src/transports/host-policy.ts
-function buildGuardedModelFetch(model, timeoutMs, options) {
-	const host = getAiTransportHost();
-	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
-	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
-	return host.buildModelFetch(model) ?? globalThis.fetch;
-}
-function resolveProviderEndpoint(baseUrl) {
-	return { endpointClass: getAiTransportHost().resolveProviderEndpointClass(baseUrl) };
-}
-function resolveProviderRequestCapabilities(input) {
-	return getAiTransportHost().resolveProviderRequestCapabilities(input);
-}
-function resolveProviderRequestPolicyConfig(input) {
-	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
-}
-function resolveModelRequestTimeoutMs(model, timeoutMs) {
-	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
-}
-function resolveOpenAIStrictToolSetting(model, options) {
-	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
-}
-function transformTransportMessages(messages, model, normalizeToolCallId, options) {
-	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-projection.ts
-function unreadableToolDiagnostic(toolIndex) {
-	return {
-		toolIndex,
-		violations: [`tool[${toolIndex}] is unreadable`]
-	};
-}
-/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
-function projectOpenAITools(tools) {
-	let inputToolCount;
-	try {
-		inputToolCount = tools.length;
-	} catch {
-		return {
-			inputToolCount: 0,
-			tools: [],
-			diagnostics: [unreadableToolDiagnostic(0)]
-		};
-	}
-	const projectedTools = [];
-	const diagnostics = [];
-	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
-		let tool;
-		try {
-			const candidate = tools[toolIndex];
-			if (!candidate) {
-				diagnostics.push(unreadableToolDiagnostic(toolIndex));
-				continue;
-			}
-			tool = candidate;
-		} catch {
-			diagnostics.push(unreadableToolDiagnostic(toolIndex));
-			continue;
-		}
-		let name;
-		try {
-			name = tool.name;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is unreadable`]
-			});
-			continue;
-		}
-		if (typeof name !== "string" || !name) {
-			diagnostics.push({
-				toolIndex,
-				violations: [`tool[${toolIndex}].name is empty`]
-			});
-			continue;
-		}
-		let parameters;
-		try {
-			parameters = tool.parameters;
-		} catch {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: [`${name}.parameters is unreadable`]
-			});
-			continue;
-		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
-		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
-			diagnostics.push({
-				toolIndex,
-				toolName: name,
-				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
-			});
-			continue;
-		}
-		let descriptionValue;
-		try {
-			descriptionValue = tool.description;
-		} catch {}
-		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
-		projectedTools.push({
-			toolIndex,
-			name,
-			...description !== void 0 ? { description } : {},
-			parameters: schemaProjection.schema
-		});
-	}
-	return {
-		inputToolCount,
-		tools: projectedTools,
-		diagnostics
-	};
-}
-function requireProjectedFunction(name, projection, choiceLabel) {
-	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
-}
-/** Keeps Responses tool choices aligned with surviving function schemas. */
-function reconcileOpenAIResponsesToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "function") {
-		const functionName = choice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
-		return {
-			type: "function",
-			name: functionName
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const mode = choice.mode;
-	const tools = choice.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") {
-			normalizedAllowedTools.push(tool);
-			continue;
-		}
-		const functionName = tool.name;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			name: functionName
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		mode,
-		tools: normalizedAllowedTools
-	};
-}
-/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
-function reconcileOpenAICompletionsToolChoice(choice, projection) {
-	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
-	if (choice === "required") {
-		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
-		return choice;
-	}
-	if (choice === "none" || !isRecord(choice)) return choice;
-	const choiceType = choice.type;
-	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
-	if (choiceType === "function") {
-		const functionChoice = choice.function;
-		if (!isRecord(functionChoice)) return choice;
-		const functionName = functionChoice.name;
-		if (typeof functionName !== "string") return choice;
-		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
-		return {
-			type: "function",
-			function: { name: functionName }
-		};
-	}
-	if (choiceType !== "allowed_tools") return choice;
-	const allowedConfig = choice.allowed_tools;
-	if (!isRecord(allowedConfig)) return choice;
-	const mode = allowedConfig.mode;
-	const tools = allowedConfig.tools;
-	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
-	const normalizedAllowedTools = [];
-	for (const tool of tools) {
-		if (!isRecord(tool) || tool.type !== "function") continue;
-		const functionChoice = tool.function;
-		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
-		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
-			type: "function",
-			function: { name: functionName }
-		});
-	}
-	if (normalizedAllowedTools.length === 0) {
-		if (mode === "auto") return "none";
-		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
-	}
-	return {
-		type: "allowed_tools",
-		allowed_tools: {
-			mode,
-			tools: normalizedAllowedTools
-		}
-	};
-}
-//#endregion
-export { resolveModelRequestTimeoutMs as a, resolveProviderRequestCapabilities as c, buildGuardedModelFetch as i, resolveProviderRequestPolicyConfig as l, reconcileOpenAICompletionsToolChoice as n, resolveOpenAIStrictToolSetting as o, reconcileOpenAIResponsesToolChoice as r, resolveProviderEndpoint as s, projectOpenAITools as t, transformTransportMessages as u };

package/dist/provider-error-CAEvRjry.mjs

@@ -1,47 +0,0 @@
-import { o as truncateUtf16Safe } from "./tool-result-text-CTpIRbYd.mjs";
-//#region packages/ai/src/utils/provider-error.ts
-const MAX_ERROR_BODY_LENGTH = 4e3;
-function stringify(value) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	try {
-		return JSON.stringify(value, (_key, candidate) => {
-			if (typeof candidate !== "object" || candidate === null) return candidate;
-			if (seen.has(candidate)) return "[Circular]";
-			seen.add(candidate);
-			return candidate;
-		}) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-function readStatus(error) {
-	for (const value of [
-		error.status,
-		error.statusCode,
-		error.response?.status,
-		error.response?.statusCode
-	]) if (typeof value === "number" && Number.isFinite(value)) return value;
-}
-function readBody(error) {
-	for (const value of [
-		error.body,
-		error.error,
-		error.response?.body,
-		error.response?.data
-	]) {
-		if (value === void 0 || value === null) continue;
-		if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) continue;
-		const body = (typeof value === "string" ? value : stringify(value)).trim();
-		if (body.length > 0) return body.length <= MAX_ERROR_BODY_LENGTH ? body : `${truncateUtf16Safe(body, MAX_ERROR_BODY_LENGTH)}... [truncated]`;
-	}
-}
-function formatProviderError(error) {
-	if (!(error instanceof Error)) return stringify(error);
-	const httpError = error;
-	const status = readStatus(httpError);
-	const body = readBody(httpError);
-	if (status === void 0 || body === void 0 || error.message.includes(body)) return error.message;
-	return `${status}: ${body}`;
-}
-//#endregion
-export { formatProviderError as t };

package/dist/sanitize-unicode-DT5o51ur.mjs

@@ -1,26 +0,0 @@
-//#region packages/ai/src/utils/sanitize-unicode.ts
-/**
-* Removes unpaired Unicode surrogate characters from a string.
-*
-* Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
-* or vice versa) cause JSON serialization errors in many API providers.
-*
-* Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
-* surrogates and will NOT be affected by this function.
-*
-* @param text - The text to sanitize
-* @returns The sanitized text with unpaired surrogates removed
-*
-* @example
-* // Valid emoji (properly paired surrogates) are preserved
-* sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
-*
-* // Unpaired high surrogate is removed
-* const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
-* sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
-*/
-function sanitizeSurrogates(text) {
-	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
-}
-//#endregion
-export { sanitizeSurrogates as t };