@jeffreycao/copilot-api 2.2.12 → 2.2.13

package/dist/main.js

@@ -30,7 +30,7 @@ if (isMcpFastPath(process.argv)) {
 	const { auth } = await import("./auth-C-RWNXGU.js");
 	const { debug } = await import("./debug-41w6Whae.js");
 	const { mcp } = await import("./mcp-fpSlKZxK.js");
-	const { start } = await import("./start-CJ6z_8Pn.js");
+	const { start } = await import("./start-z_xmbJbc.js");
 	await runMain(defineCommand({
 		meta: {
 			name: "copilot-api",

package/dist/{server-C3DnUZoh.js → server-Bmd_z-tv.js}

@@ -2933,8 +2933,8 @@ const setContextCacheControl = (part) => {
 	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
 //#endregion
-//#region src/routes/provider/utils.ts
-const RESPONSES_REASONING_EFFORTS = new Set([
+//#region src/lib/reasoning-effort.ts
+const REASONING_EFFORT_LEVELS = [
 	"none",
 	"minimal",
 	"low",
@@ -2942,13 +2942,45 @@ const RESPONSES_REASONING_EFFORTS = new Set([
 	"high",
 	"xhigh",
 	"max"
-]);
+];
+const KNOWN_REASONING_EFFORTS = new Set(REASONING_EFFORT_LEVELS);
 const REASONING_EFFORT_ALIASES = {
 	minimal: "low",
-	xhigh: "high",
-	max: "high",
-	ultra: "high"
+	ultra: "max"
+};
+const reasoningEffortRank = (effort) => REASONING_EFFORT_LEVELS.indexOf(effort);
+/**
+* Resolves the reasoning effort to send upstream for a requested effort.
+*
+* Policy:
+* - A supported effort passes through unchanged.
+* - Client-only levels are aliased first ("ultra" -> "max").
+* - An unsupported request clamps to the highest supported level not above
+*   the request, e.g. "max" against ["low", "medium", "high", "xhigh"]
+*   resolves to "xhigh".
+* - A request below every supported level resolves to the lowest supported
+*   level, e.g. "none" against ["low", "medium", "high"] resolves to "low".
+* - Without any known supported levels, valid wire efforts pass through and
+*   client-facing aliases are converted (for example, "ultra" -> "max").
+* - An unrecognized request is left unresolved so the upstream can validate
+*   it instead of receiving a silently substituted effort.
+*/
+const resolveSupportedReasoningEffort = (requestedEffort, supportedEfforts) => {
+	const supported = (supportedEfforts ?? []).filter((effort) => KNOWN_REASONING_EFFORTS.has(effort));
+	const requestedWireEffort = KNOWN_REASONING_EFFORTS.has(requestedEffort) ? requestedEffort : void 0;
+	if (supported.length === 0) return requestedWireEffort ?? REASONING_EFFORT_ALIASES[requestedEffort];
+	if (requestedWireEffort && supported.includes(requestedWireEffort)) return requestedWireEffort;
+	const aliasedEffort = REASONING_EFFORT_ALIASES[requestedEffort] ?? requestedWireEffort;
+	if (!aliasedEffort) return;
+	if (supported.includes(aliasedEffort)) return aliasedEffort;
+	const requestedRank = reasoningEffortRank(aliasedEffort);
+	let nearestBelow;
+	for (const effort of supported) if (reasoningEffortRank(effort) <= requestedRank && (nearestBelow === void 0 || reasoningEffortRank(effort) > reasoningEffortRank(nearestBelow))) nearestBelow = effort;
+	if (nearestBelow) return nearestBelow;
+	return supported.reduce((lowest, effort) => reasoningEffortRank(effort) < reasoningEffortRank(lowest) ? effort : lowest);
 };
+//#endregion
+//#region src/routes/provider/utils.ts
 const applyModelDefaults = (payload, modelConfig) => {
 	payload.temperature ??= modelConfig?.temperature;
 	payload.top_p ??= modelConfig?.topP;
@@ -2958,22 +2990,19 @@ const applyMissingExtraBody = (payload, options) => {
 	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
 };
 const normalizeProviderResponsesReasoningEffort = (payload, providerConfig) => {
-	const currentEffort = payload.reasoning?.effort;
-	if (typeof currentEffort !== "string") return;
+	if (!payload.reasoning || typeof payload.reasoning.effort !== "string") return;
 	const modelConfig = providerConfig.models?.[payload.model];
 	const builtinModelConfig = builtinProviderModelRegistry.getModelConfig(providerConfig.name, payload.model);
-	const configuredEfforts = normalizeResponsesReasoningEfforts(modelConfig?.reasoningEfforts);
-	const builtinEfforts = normalizeResponsesReasoningEfforts(builtinModelConfig?.reasoningEfforts);
-	const supportedEfforts = configuredEfforts.length > 0 ? configuredEfforts : builtinEfforts;
-	if (supportedEfforts.length === 0 || supportedEfforts.includes(currentEffort)) return;
-	const aliasedEffort = REASONING_EFFORT_ALIASES[currentEffort];
-	const fallbackEffort = aliasedEffort && supportedEfforts.includes(aliasedEffort) ? aliasedEffort : selectSupportedReasoningEffort(supportedEfforts, modelConfig?.defaultReasoningEffort, builtinModelConfig?.defaultReasoningEffort);
-	if (payload.reasoning && fallbackEffort) payload.reasoning.effort = fallbackEffort;
-};
-const normalizeResponsesReasoningEfforts = (efforts) => (efforts ?? []).filter((effort) => RESPONSES_REASONING_EFFORTS.has(effort));
-const selectSupportedReasoningEffort = (supportedEfforts, ...defaults) => {
-	for (const defaultEffort of defaults) if (defaultEffort && supportedEfforts.includes(defaultEffort)) return defaultEffort;
-	return supportedEfforts[0];
+	const configuredEfforts = modelConfig?.reasoningEfforts;
+	const supportedEfforts = configuredEfforts && configuredEfforts.length > 0 ? configuredEfforts : builtinModelConfig?.reasoningEfforts;
+	const resolvedEffort = resolveSupportedReasoningEffort(payload.reasoning.effort, supportedEfforts);
+	if (!resolvedEffort || resolvedEffort === payload.reasoning.effort) return;
+	const requestedEffort = payload.reasoning.effort;
+	payload.reasoning.effort = resolvedEffort;
+	return {
+		from: requestedEffort,
+		to: resolvedEffort
+	};
 };
 //#endregion
 //#region src/routes/provider/chat-completions/handler.ts
@@ -5910,6 +5939,17 @@ const getStreamErrorMessage = (event) => {
 	return event.error?.message ?? event.message ?? void 0;
 };
 const DEFAULT_RESPONSES_COMPACT_THRESHOLD_RATIO = .85;
+const normalizeResponsesReasoningEffort = (payload, supportedEfforts) => {
+	if (!payload.reasoning || typeof payload.reasoning.effort !== "string") return;
+	const resolvedEffort = resolveSupportedReasoningEffort(payload.reasoning.effort, supportedEfforts);
+	if (!resolvedEffort || resolvedEffort === payload.reasoning.effort) return;
+	const requestedEffort = payload.reasoning.effort;
+	payload.reasoning.effort = resolvedEffort;
+	return {
+		from: requestedEffort,
+		to: resolvedEffort
+	};
+};
 const responsesUtilsDependencies = {
 	getModelResponsesApiCompactThreshold: getModelResponsesApiCompactThreshold$1,
 	isContextManagementEnabledForMessages,
@@ -6651,7 +6691,8 @@ async function handleProviderMessagesForProvider(c, options) {
 const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 	const { modelConfig, payload, provider, providerConfig, usageEndpoint } = options;
 	const responsesPayload = prepareWebSearchResponsesPayload(payload);
-	normalizeProviderResponsesReasoningEffort(responsesPayload, providerConfig);
+	const normalizedReasoningEffort = normalizeProviderResponsesReasoningEffort(responsesPayload, providerConfig);
+	if (normalizedReasoningEffort) logger$10.debug(`Normalized reasoning effort from ${normalizedReasoningEffort.from} to ${normalizedReasoningEffort.to} based on the provider model configuration`);
 	debugJson(logger$10, "provider.messages.responses.web_search.request", {
 		payload: responsesPayload,
 		provider
@@ -6715,7 +6756,8 @@ const handleOpenAIResponsesProviderMessages = async (c, options) => {
 	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
 	const wantsStream = payload.stream === true;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(payload);
-	normalizeProviderResponsesReasoningEffort(responsesPayload, providerConfig);
+	const normalizedMessagesReasoningEffort = normalizeProviderResponsesReasoningEffort(responsesPayload, providerConfig);
+	if (normalizedMessagesReasoningEffort) logger$10.debug(`Normalized reasoning effort from ${normalizedMessagesReasoningEffort.from} to ${normalizedMessagesReasoningEffort.to} based on the provider model configuration`);
 	if (providerConfig.name === "codex" && !wantsStream) responsesPayload.stream = true;
 	if (applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens, { source: "messages" })) compactInputByLatestCompaction(responsesPayload);
 	debugJson(logger$10, "provider.messages.responses.request", {
@@ -7641,6 +7683,10 @@ const DEFAULT_REASONING_EFFORTS = [
 	"max",
 	"ultra"
 ];
+const addUltraReasoningEffort = (efforts) => {
+	if (efforts.includes("ultra")) return efforts;
+	return [...efforts, "ultra"];
+};
 const CODEX_ALIAS_PRIORITY_BASE = 1e3;
 const COPILOT_PRIORITY_BASE = 2e3;
 const OPENCODE_GO_PRIORITY_BASE = 3e3;
@@ -7947,7 +7993,7 @@ function createCatalogAlias(model, slug, providerName) {
 	};
 }
 function createSyntheticCodexModel(candidate, template, priority) {
-	const reasoningEfforts = candidate.reasoningEfforts.length > 0 ? candidate.reasoningEfforts : DEFAULT_REASONING_EFFORTS;
+	const reasoningEfforts = candidate.reasoningEfforts.length > 0 ? addUltraReasoningEffort(candidate.reasoningEfforts) : DEFAULT_REASONING_EFFORTS;
 	const defaultReasoningEffort = reasoningEfforts.includes(candidate.defaultReasoningEffort) ? candidate.defaultReasoningEffort : reasoningEfforts[0];
 	const supportsReasoning = reasoningEfforts.some((effort) => effort !== "none");
 	const inputModalities = [...new Set(candidate.inputModalities)];
@@ -10069,7 +10115,8 @@ async function handleProviderResponsesForProvider(c, options) {
 		type: "invalid_request_error"
 	} }, 400);
 	const effectiveType = resolveEffectiveProviderType(providerConfig, payload.model);
-	normalizeProviderResponsesReasoningEffort(payload, providerConfig);
+	const normalizedReasoningEffort = normalizeProviderResponsesReasoningEffort(payload, providerConfig);
+	if (normalizedReasoningEffort) logger$2.debug(`Normalized reasoning effort from ${normalizedReasoningEffort.from} to ${normalizedReasoningEffort.to} based on the provider model configuration`);
 	if (shouldFallbackToMessages$1(c, payload.model, effectiveType)) return await handleResponsesViaMessages(c, {
 		payload,
 		publicModel: options.publicModel ?? payload.model,
@@ -10288,6 +10335,8 @@ const handleResponses = async (c) => {
 	logger$1.debug("Extracted session ID:", fallbackSessionId);
 	const selectedModel = responsesHandlerDependencies.findEndpointModel(payload.model);
 	payload.model = selectedModel?.id ?? payload.model;
+	const normalizedReasoningEffort = normalizeResponsesReasoningEffort(payload, selectedModel?.capabilities?.supports?.reasoning_effort);
+	if (normalizedReasoningEffort) logger$1.debug(`Normalized reasoning effort from ${normalizedReasoningEffort.from} to ${normalizedReasoningEffort.to} based on the selected model capabilities`);
 	const responsesTransport = getResponsesTransportForModel(selectedModel);
 	if (shouldFallbackToMessages(c, payload.model, selectedModel, responsesTransport)) return await handleResponsesViaMessages(c, {
 		payload,
@@ -10573,4 +10622,4 @@ server.route("/:provider/images", providerImageRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-C3DnUZoh.js.map
+//# sourceMappingURL=server-Bmd_z-tv.js.map