@jeffreycao/copilot-api 2.2.11 → 2.2.13

package/README.md

@@ -264,6 +264,42 @@ enabled = false
 >
 > For third-party models that do not support `tool_search`, we recommend disabling features.apps. Otherwise, each prompt may consume an additional 20,000 or more tokens.
 
+### If Codex Is Not Signed In to a GPT Account
+
+```toml
+[model_providers.copilot_api]
+name = "OpenAI"
+base_url = "http://localhost:4141"
+requires_openai_auth = false
+supports_websockets = false
+wire_api = "responses"
+request_max_retries = 3
+stream_max_retries = 3
+stream_idle_timeout_ms = 300000
+
+[model_providers.copilot_api.auth]
+command = "powershell.exe"
+args = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "[Console]::Out.Write($env:GITHUB_COPILOT_API_KEY)"
+]
+```
+
+macOS, replace the `auth` block with:
+
+```toml
+[model_providers.copilot_api.auth]
+command = "/bin/zsh"
+args = [
+    "-c",
+    "printf '%s' \"$GITHUB_COPILOT_API_KEY\""
+]
+```
+
+Without this configuration, Codex cannot fetch `/v1/models` while not signed in to a GPT account, so custom models are unavailable in the model picker.
+
 When a Codex client (`User-Agent` starts with `codex`) requests the top-level `GET /v1/models`, the gateway merges native Codex models with models available through the Messages adapter. The latter advertise `use_responses_lite: true`: `/v1/responses` uses **Responses → Messages** for Anthropic providers, while OpenAI-compatible providers and Chat-only Copilot models reuse the existing Messages route for **Responses → Messages → Chat Completions**, then translate streaming or JSON results back to Responses.
 
 The merged catalog is what Codex shows in its model picker, including the models exposed by your configured providers:

package/README.zh-CN.md

@@ -280,6 +280,42 @@ enabled = false
 >
 > 对于不支持 `tool_search` 的第三方模型，我们建议禁用 features.apps。否则，每个提示可能会额外消耗 20,000 多个 token。
 
+### Codex 未登录 GPT 账号时
+
+```toml
+[model_providers.copilot_api]
+name = "OpenAI"
+base_url = "http://localhost:4141"
+requires_openai_auth = false
+supports_websockets = false
+wire_api = "responses"
+request_max_retries = 3
+stream_max_retries = 3
+stream_idle_timeout_ms = 300000
+
+[model_providers.copilot_api.auth]
+command = "powershell.exe"
+args = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "[Console]::Out.Write($env:GITHUB_COPILOT_API_KEY)"
+]
+```
+
+macOS 将 `auth` 段替换为：
+
+```toml
+[model_providers.copilot_api.auth]
+command = "/bin/zsh"
+args = [
+    "-c",
+    "printf '%s' \"$GITHUB_COPILOT_API_KEY\""
+]
+```
+
+未按上述方式配置时，Codex 未登录 GPT 账号拉不到 `/v1/models`，无法选择自定义模型。
+
 Codex 客户端（`User-Agent` 以 `codex` 开头）请求顶层 `GET /v1/models` 时，网关会把原生 Codex 模型与可通过 Messages 适配的模型合并返回。后者会声明 `use_responses_lite: true`：调用 `/v1/responses` 后，Anthropic provider 走 **Responses → Messages**，OpenAI 兼容 provider 以及只支持 Chat 的 Copilot 模型则复用现有 Messages 路由继续走 **Responses → Messages → Chat Completions**，最终统一翻译回 Responses（包括流式事件）。
 
 合并后的模型列表会直接展示在 Codex 的模型选择界面中，包含各 provider 暴露的模型：

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-DmLlG7PU.js");
+	const { start } = await import("./start-z_xmbJbc.js");
 	await runMain(defineCommand({
 		meta: {
 			name: "copilot-api",

package/dist/{server-D_qrybxD.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)];
@@ -8697,17 +8743,11 @@ function registerMessagesTool(registration, registry) {
 	const originalKey = createOriginalToolKey(registration);
 	const existing = registry.byOriginal.get(originalKey);
 	if (existing) return existing;
-	const alias = createToolAlias(registration.namespace ? `${registration.namespace.replaceAll(".", "_")}__${registration.name}` : registration.name, originalKey, registry);
-	const descriptor = {
-		alias,
-		kind: registration.kind,
-		name: registration.name,
-		...registration.namespace ? { namespace: registration.namespace } : {}
-	};
-	registry.byAlias.set(alias, descriptor);
+	const descriptor = createMessagesToolDescriptor(registration, registry);
+	registry.byAlias.set(descriptor.alias, descriptor);
 	registry.byOriginal.set(originalKey, descriptor);
 	registry.tools.push({
-		name: alias,
+		name: descriptor.alias,
 		...registration.description ? { description: registration.description } : {},
 		input_schema: registration.kind === "custom" ? CUSTOM_TOOL_INPUT_SCHEMA : registration.parameters ?? {
 			type: "object",
@@ -8717,6 +8757,15 @@ function registerMessagesTool(registration, registry) {
 	});
 	return descriptor;
 }
+function createMessagesToolDescriptor(registration, registry) {
+	const originalKey = createOriginalToolKey(registration);
+	return {
+		alias: createToolAlias(registration.namespace ? `${registration.namespace.replaceAll(".", "_")}__${registration.name}` : registration.name, originalKey, registry),
+		kind: registration.kind,
+		name: registration.name,
+		...registration.namespace ? { namespace: registration.namespace } : {}
+	};
+}
 function translateInputToAnthropic(input, registry, instructions, originalInput, toolCallTips) {
 	const messages = [];
 	const system = [];
@@ -8847,11 +8896,12 @@ function translateInputReasoning(item, messages) {
 }
 function translateInputToolCall(item, kind, messages, registry) {
 	if (!isRecord(item)) throw new ResponsesMessagesTranslationError("Invalid Responses tool call item");
-	const descriptor = registerMessagesTool({
+	const toolIdentity = {
 		kind,
 		name: requireStringField(item, "name", `${kind}_tool_call`),
 		namespace: getOptionalStringField(item, "namespace") ?? void 0
-	}, registry);
+	};
+	const descriptor = registry.byOriginal.get(createOriginalToolKey(toolIdentity)) ?? createMessagesToolDescriptor(toolIdentity, registry);
 	const input = kind === "custom" ? { input: getStringField(item, "input") ?? "" } : parseFunctionArguments(getStringField(item, "arguments") ?? "{}", `${kind}_tool_call.arguments`);
 	appendAssistantBlock(messages, {
 		type: "tool_use",
@@ -10065,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,
@@ -10284,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,
@@ -10569,4 +10622,4 @@ server.route("/:provider/images", providerImageRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-D_qrybxD.js.map
+//# sourceMappingURL=server-Bmd_z-tv.js.map