@jeffreycao/copilot-api 2.2.12 → 2.2.14

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-HHr2HlXT.js");
 	await runMain(defineCommand({
 		meta: {
 			name: "copilot-api",

package/dist/{server-C3DnUZoh.js → server-B3NoF9oG.js}

@@ -374,6 +374,21 @@ async function resolveProviderConfig(providerName) {
 	}
 	return getProviderConfig(normalizedProviderName);
 }
+/**
+* Returns the parsed "provider/model" alias only when that provider is
+* actually configured, otherwise null so the caller falls through to its
+* default flow. GitHub Copilot enterprise models can ship with namespaced ids
+* such as "org/family/model": without this check the first segment is
+* misrouted to a non-existent provider and surfaced as a 400/404.
+*/
+async function ensureConfiguredProviderModelAlias(alias, resolveConfig = resolveProviderConfig) {
+	if (!alias) return null;
+	return await resolveConfig(alias.provider) ? alias : null;
+}
+/** parseProviderModelAlias + ensureConfiguredProviderModelAlias. */
+async function resolveConfiguredProviderModelAlias(model, resolveConfig = resolveProviderConfig) {
+	return ensureConfiguredProviderModelAlias(parseProviderModelAlias(model), resolveConfig);
+}
 //#endregion
 //#region src/lib/event-bus.ts
 var EventBus = class {
@@ -2845,10 +2860,12 @@ async function handleAlphaSearchRequest(c, resolvedProviderConfig) {
 		}
 	}
 	const fallbackRequestedModel = messagesBackedModel ? payload.model : requestedModel;
-	if (providerModelAlias) return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, {
-		provider: providerModelAlias.provider,
-		request: payload
-	});
+	if (providerModelAlias) {
+		if (await ensureConfiguredProviderModelAlias(providerModelAlias, alphaSearchRouteDependencies.resolveProviderConfig)) return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, {
+			provider: providerModelAlias.provider,
+			request: payload
+		});
+	}
 	return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, { request: {
 		...payload,
 		model: fallbackRequestedModel
@@ -2933,8 +2950,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 +2959,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 +3007,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
@@ -3098,7 +3144,7 @@ async function handleCompletion$1(c) {
 	const requestedModel = payload.model;
 	payload.model = resolveMappedModel(payload.model);
 	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
-	const providerModelAlias = parseProviderModelAlias(payload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(payload.model);
 	if (providerModelAlias) {
 		payload.model = providerModelAlias.model;
 		return await handleProviderChatCompletionsForProvider(c, {
@@ -4390,7 +4436,7 @@ async function handleCountTokens(c) {
 	const anthropicPayload = await c.req.json();
 	anthropicPayload.model = resolveMappedModel(anthropicPayload.model);
 	normalizeSystemMessages(anthropicPayload);
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(anthropicPayload.model);
 	if (providerModelAlias) {
 		anthropicPayload.model = providerModelAlias.model;
 		return await handleProviderCountTokensForProvider(c, {
@@ -5910,6 +5956,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,
@@ -6104,6 +6161,7 @@ const containsVisionContent = (value) => {
 //#region src/routes/messages/web-search/fulfill.ts
 const webSearchFlowDependencies = {
 	createResponses,
+	resolveProviderConfig,
 	createUsageRecorder: (payload, sessionId, webSearchModel) => createCopilotTokenUsageRecorder({
 		endpoint: "responses",
 		fallbackSessionId: sessionId,
@@ -6125,14 +6183,17 @@ const stripWebSearchServerTool = (payload) => {
 	if (!Array.isArray(payload.tools)) return;
 	payload.tools = payload.tools.filter((tool) => !isWebSearchServerTool(tool));
 };
-const resolveWebSearchRoute = (payload, options) => {
+const resolveWebSearchRoute = async (payload, options) => {
 	const { webSearchModel, responsesWebSearchEnabled } = options;
 	if (!webSearchModel || !isWebSearchOnlyRequest(payload)) return { kind: "strip" };
 	const alias = parseProviderModelAlias(webSearchModel);
-	if (alias) return {
-		kind: "provider",
-		alias
-	};
+	if (alias) {
+		const configuredAlias = await ensureConfiguredProviderModelAlias(alias, options.resolveProviderConfig ?? resolveProviderConfig);
+		return configuredAlias ? {
+			kind: "provider",
+			alias: configuredAlias
+		} : { kind: "strip" };
+	}
 	if (responsesWebSearchEnabled) return {
 		kind: "responses",
 		model: webSearchModel
@@ -6234,9 +6295,10 @@ const createUsageRecorder = (payload, sessionId, webSearchModel) => webSearchFlo
 const tryHandleWebSearch = async (c, payload, options) => {
 	if (!hasWebSearchServerTool(payload)) return null;
 	normalizeSystemMessages(payload);
-	const route = resolveWebSearchRoute(payload, {
+	const route = await resolveWebSearchRoute(payload, {
 		webSearchModel: getMessageApiWebSearchModel(),
-		responsesWebSearchEnabled: isResponsesApiWebSearchEnabled()
+		responsesWebSearchEnabled: isResponsesApiWebSearchEnabled(),
+		resolveProviderConfig: webSearchFlowDependencies.resolveProviderConfig
 	});
 	if (route.kind === "provider") {
 		payload.model = route.alias.model;
@@ -6651,7 +6713,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 +6778,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", {
@@ -7518,7 +7582,7 @@ async function handleCompletionPayload(c, anthropicPayload, dispatchOptions = {}
 		consola.debug(`Claude auto model override: ${anthropicPayload.model} -> ${claudeAutoModel}`);
 		anthropicPayload.model = claudeAutoModel;
 	}
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(anthropicPayload.model, providerMessagesHandlerDependencies.resolveProviderConfig);
 	if (providerModelAlias) {
 		anthropicPayload.model = providerModelAlias.model;
 		return await handleProviderMessagesForProvider(c, {
@@ -7641,6 +7705,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 +8015,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)];
@@ -9102,12 +9170,14 @@ function appendUserBlock(messages, block) {
 	};
 	messages.push(message);
 }
-function parseFunctionArguments(value, path) {
+function parseFunctionArguments(value, _path) {
 	try {
 		const parsed = JSON.parse(value);
 		if (isRecord(parsed)) return parsed;
-	} catch {}
-	throw new ResponsesMessagesTranslationError(`${path} must be a JSON object string`);
+	} catch {
+		return {};
+	}
+	return {};
 }
 function parseDataUrl(value) {
 	const match = /^data:([^;,]+);base64,(.*)$/su.exec(value);
@@ -10069,7 +10139,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,
@@ -10268,7 +10339,7 @@ const handleResponses = async (c) => {
 	const requestedModel = payload.model;
 	payload.model = responsesHandlerDependencies.resolveMappedModel(payload.model);
 	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
-	const providerModelAlias = parseProviderModelAlias(payload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(payload.model, providerResponsesHandlerDependencies.resolveProviderConfig);
 	if (providerModelAlias) {
 		payload.model = providerModelAlias.model;
 		return await handleProviderResponsesForProvider(c, {
@@ -10288,6 +10359,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 +10646,4 @@ server.route("/:provider/images", providerImageRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-C3DnUZoh.js.map
+//# sourceMappingURL=server-B3NoF9oG.js.map