copilot-api-plus 1.4.9 → 1.5.0

package/dist/main.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountManager, cacheModels, cacheVSCodeVersion, copilotBaseUrl, copilotHeaders, ensurePaths, findModel, forwardError, getAccountDispatcher, getCopilotUsage, initProxyFromEnv, isAccountProxied, isNullish, isProxyActive, notifyStreamEnd, notifyStreamStart, resetAccountConnections, resetConnections, rootCause, sleep, standardHeaders, state } from "./account-manager-D4DftPxS.js";
-import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-DYGcLmSO.js";
+import { GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountManager, cacheModels, cacheVSCodeVersion, copilotBaseUrl, copilotHeaders, ensurePaths, findModel, forwardError, getAccountDispatcher, getCopilotUsage, initProxyFromEnv, isAccountProxied, isNullish, isProxyActive, notifyStreamEnd, notifyStreamStart, resetAccountConnections, resetConnections, rootCause, sleep, standardHeaders, state } from "./account-manager-DktL5osZ.js";
+import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-B8FDrdsQ.js";
 import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -1899,6 +1899,7 @@ function injectIntoAnthropicPayload(payload) {
 function injectIntoOpenAIPayload(payload) {
 	if (!ENABLED) return payload;
 	const msgs = payload.messages;
+	if (!Array.isArray(msgs)) return payload;
 	for (const m of msgs) {
 		if (m.role !== "system" && m.role !== "developer") continue;
 		if (typeof m.content === "string" && alreadyInjected(m.content)) return payload;
@@ -2041,6 +2042,7 @@ function stripSystemReminders(payload) {
 * nothing changed.
 */
 function stripOpenAIReminders(payload) {
+	if (!Array.isArray(payload.messages)) return payload;
 	let changed = false;
 	const newMessages = payload.messages.map((m) => {
 		if (m.content === null) return m;
@@ -2304,6 +2306,396 @@ function overrideMessageStartEventModel(rawData, requestedModel) {
 	}
 }
 
+//#endregion
+//#region src/services/copilot/responses-translator.ts
+function partsToInputContent(parts, role) {
+	return parts.map((part) => {
+		if (part.type === "text") return role === "assistant" ? {
+			type: "output_text",
+			text: part.text
+		} : {
+			type: "input_text",
+			text: part.text
+		};
+		return {
+			type: "input_image",
+			image_url: part.image_url.url,
+			detail: part.image_url.detail
+		};
+	});
+}
+function stringToInputContent(text, role) {
+	return role === "assistant" ? [{
+		type: "output_text",
+		text
+	}] : [{
+		type: "input_text",
+		text
+	}];
+}
+function messageContent(message) {
+	if (message.content === null) return [];
+	if (typeof message.content === "string") return stringToInputContent(message.content, message.role);
+	return partsToInputContent(message.content, message.role);
+}
+function translateAssistantWithToolCalls(message) {
+	const items = [];
+	const content = messageContent(message);
+	if (content.length > 0) items.push({
+		type: "message",
+		role: "assistant",
+		content
+	});
+	for (const call of message.tool_calls ?? []) items.push({
+		type: "function_call",
+		call_id: call.id,
+		name: call.function.name,
+		arguments: call.function.arguments
+	});
+	return items;
+}
+function translateMessage(message) {
+	if (message.role === "tool") {
+		const text = typeof message.content === "string" ? message.content : messageContent(message).map((c) => c.type === "input_text" || c.type === "output_text" ? c.text : "").join("");
+		return [{
+			type: "function_call_output",
+			call_id: message.tool_call_id ?? "",
+			output: text
+		}];
+	}
+	if (message.role === "assistant" && message.tool_calls?.length) return translateAssistantWithToolCalls(message);
+	return [{
+		type: "message",
+		role: message.role,
+		content: messageContent(message)
+	}];
+}
+function translateTool(tool) {
+	return {
+		type: "function",
+		name: tool.function.name,
+		description: tool.function.description,
+		parameters: tool.function.parameters
+	};
+}
+function translateToolChoice(choice) {
+	if (!choice) return void 0;
+	if (typeof choice === "string") return choice;
+	return {
+		type: "function",
+		name: choice.function.name
+	};
+}
+function translateReasoning(effort) {
+	if (!effort) return void 0;
+	if (effort === "max") return { effort: "high" };
+	return { effort };
+}
+function chatToResponsesPayload(payload) {
+	let instructions;
+	const remainingMessages = [];
+	let sawNonSystem = false;
+	for (const msg of payload.messages) {
+		if (msg.role === "system" && !sawNonSystem) {
+			const text = typeof msg.content === "string" ? msg.content : messageContent(msg).map((c) => c.type === "input_text" || c.type === "output_text" ? c.text : "").join("\n");
+			instructions = instructions ? `${instructions}\n\n${text}` : text;
+			continue;
+		}
+		sawNonSystem = true;
+		remainingMessages.push(msg);
+	}
+	const input = remainingMessages.flatMap((m) => translateMessage(m));
+	const maxOutput = payload.max_completion_tokens ?? payload.max_tokens ?? void 0;
+	return {
+		model: payload.model,
+		input,
+		instructions,
+		tools: payload.tools?.map((t) => translateTool(t)),
+		tool_choice: translateToolChoice(payload.tool_choice),
+		reasoning: translateReasoning(payload.reasoning_effort),
+		max_output_tokens: maxOutput ?? void 0,
+		temperature: payload.temperature ?? void 0,
+		top_p: payload.top_p ?? void 0,
+		parallel_tool_calls: void 0,
+		stream: payload.stream ?? void 0
+	};
+}
+function mapUsage(usage) {
+	if (!usage) return void 0;
+	return {
+		prompt_tokens: usage.input_tokens ?? 0,
+		completion_tokens: usage.output_tokens ?? 0,
+		total_tokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0),
+		...usage.input_tokens_details?.cached_tokens !== void 0 && { prompt_tokens_details: { cached_tokens: usage.input_tokens_details.cached_tokens } }
+	};
+}
+function extractAssistantText(output) {
+	let text = "";
+	for (const item of output) {
+		if (item.type !== "message") continue;
+		for (const part of item.content) text += part.text;
+	}
+	return text;
+}
+function extractToolCalls(output) {
+	const calls = [];
+	for (const item of output) if (item.type === "function_call") calls.push({
+		id: item.call_id,
+		type: "function",
+		function: {
+			name: item.name,
+			arguments: item.arguments
+		}
+	});
+	return calls;
+}
+function responsesToChatResponse(resp, requestedModel) {
+	const text = extractAssistantText(resp.output);
+	const toolCalls = extractToolCalls(resp.output);
+	const finishReason = toolCalls.length > 0 ? "tool_calls" : "stop";
+	return {
+		id: resp.id,
+		object: "chat.completion",
+		created: resp.created_at ?? Math.floor(Date.now() / 1e3),
+		model: requestedModel,
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: text || null,
+				...toolCalls.length > 0 && { tool_calls: toolCalls }
+			},
+			logprobs: null,
+			finish_reason: finishReason
+		}],
+		usage: mapUsage(resp.usage)
+	};
+}
+function makeChunk(s, choice) {
+	return { data: JSON.stringify({
+		id: s.responseId,
+		object: "chat.completion.chunk",
+		created: s.created,
+		model: s.requestedModel,
+		choices: [choice]
+	}) };
+}
+function ensureRoleChunk(s) {
+	if (s.roleEmitted) return null;
+	s.roleEmitted = true;
+	return makeChunk(s, {
+		index: 0,
+		delta: {
+			role: "assistant",
+			content: ""
+		},
+		finish_reason: null,
+		logprobs: null
+	});
+}
+function getToolIndex(s, key) {
+	let idx = s.toolIndexById.get(key);
+	if (idx === void 0) {
+		idx = s.nextToolIndex++;
+		s.toolIndexById.set(key, idx);
+	}
+	return idx;
+}
+function* handleTextDelta(s, delta) {
+	const roleChunk = ensureRoleChunk(s);
+	if (roleChunk) yield roleChunk;
+	yield makeChunk(s, {
+		index: 0,
+		delta: { content: delta },
+		finish_reason: null,
+		logprobs: null
+	});
+}
+function* handleFunctionCallAdded(s, item) {
+	s.hasToolCalls = true;
+	const key = item.call_id || item.id || "";
+	const idx = getToolIndex(s, key);
+	const roleChunk = ensureRoleChunk(s);
+	if (roleChunk) yield roleChunk;
+	yield makeChunk(s, {
+		index: 0,
+		delta: { tool_calls: [{
+			index: idx,
+			id: item.call_id,
+			type: "function",
+			function: {
+				name: item.name,
+				arguments: ""
+			}
+		}] },
+		finish_reason: null,
+		logprobs: null
+	});
+}
+function* handleArgumentsDelta(s, itemId, delta) {
+	const idx = getToolIndex(s, itemId);
+	yield makeChunk(s, {
+		index: 0,
+		delta: { tool_calls: [{
+			index: idx,
+			function: { arguments: delta }
+		}] },
+		finish_reason: null,
+		logprobs: null
+	});
+}
+function buildUsageChunk(s, usage) {
+	if (!usage) return null;
+	const chunk = {
+		id: s.responseId,
+		object: "chat.completion.chunk",
+		created: s.created,
+		model: s.requestedModel,
+		choices: [],
+		usage: {
+			prompt_tokens: usage.prompt_tokens,
+			completion_tokens: usage.completion_tokens,
+			total_tokens: usage.total_tokens,
+			...usage.prompt_tokens_details && { prompt_tokens_details: usage.prompt_tokens_details }
+		}
+	};
+	return { data: JSON.stringify(chunk) };
+}
+function* handleCompleted(s, response) {
+	const finishReason = s.hasToolCalls ? "tool_calls" : "stop";
+	yield makeChunk(s, {
+		index: 0,
+		delta: {},
+		finish_reason: finishReason,
+		logprobs: null
+	});
+	const usageChunk = buildUsageChunk(s, mapUsage(response.usage));
+	if (usageChunk) yield usageChunk;
+	yield { data: "[DONE]" };
+}
+function parseEvent(data) {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+function handleTerminalEvent(event) {
+	const message = event.message ?? event.response?.error?.message ?? "Responses API error";
+	throw new Error(message);
+}
+/**
+* Dispatch a single Responses-API event to the right handler.
+* Returns generator of chunks and a boolean (true = stream complete).
+*/
+function* dispatchEvent(s, event) {
+	switch (event.type) {
+		case "response.output_text.delta":
+			if (event.delta) yield* handleTextDelta(s, event.delta);
+			return false;
+		case "response.output_item.added":
+			if (event.item?.type === "function_call") yield* handleFunctionCallAdded(s, event.item);
+			return false;
+		case "response.function_call_arguments.delta":
+			if (event.delta !== void 0) yield* handleArgumentsDelta(s, event.item_id ?? "", event.delta);
+			return false;
+		case "response.completed":
+			if (event.response) {
+				yield* handleCompleted(s, event.response);
+				return true;
+			}
+			return false;
+		case "response.failed":
+		case "response.error": handleTerminalEvent(event);
+		default: return false;
+	}
+}
+/**
+* Translate a Responses-API SSE stream into Chat Completions SSE messages.
+*
+* Yields `{ data: <stringified chat-completion-chunk> }` objects so the
+* route handler can feed them straight into `stream.writeSSE()` — same
+* shape as the existing `events()` output for `/chat/completions`.
+*/
+async function* responsesStreamToChatChunks(source, requestedModel) {
+	const s = {
+		responseId: `chatcmpl-${randomUUID().replaceAll("-", "")}`,
+		created: Math.floor(Date.now() / 1e3),
+		requestedModel,
+		roleEmitted: false,
+		hasToolCalls: false,
+		toolIndexById: /* @__PURE__ */ new Map(),
+		nextToolIndex: 0
+	};
+	for await (const sse of source) {
+		if (!sse.data || sse.data === "[DONE]") continue;
+		const event = parseEvent(sse.data);
+		if (!event) continue;
+		if (yield* dispatchEvent(s, event)) return;
+	}
+}
+
+//#endregion
+//#region src/services/copilot/create-responses.ts
+/**
+* Call Copilot's `/v1/responses` with a Chat Completions payload and
+* return either a Chat-style response or an SSE generator that yields
+* already-translated Chat Completion chunks (one per `data:` line).
+*
+* Currently only supports single-account mode. Multi-account routing
+* for Responses-only models can be added in a follow-up if needed.
+*/
+async function createResponsesAsChat(payload) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const responsesPayload = chatToResponsesPayload(payload);
+	const url = `${copilotBaseUrl(state)}/v1/responses`;
+	const enableVision = responsesPayload.input.some((item) => item.type === "message" && item.content.some((c) => c.type === "input_image"));
+	const isAgentCall = payload.messages.some((m) => ["assistant", "tool"].includes(m.role));
+	const buildHeaders = () => ({
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": isAgentCall ? "agent" : "user"
+	});
+	const bodyString = JSON.stringify(responsesPayload);
+	consola.debug("Sending request to Copilot (/v1/responses):", {
+		model: responsesPayload.model,
+		endpoint: url,
+		stream: responsesPayload.stream
+	});
+	let response = await fetchWithRetry(url, () => ({
+		method: "POST",
+		headers: buildHeaders(),
+		body: bodyString
+	}));
+	if (response.status === 401) {
+		consola.warn("Copilot token expired, refreshing and retrying...");
+		try {
+			await refreshCopilotToken();
+			response = await fetchWithTimeout$1(url, {
+				method: "POST",
+				headers: buildHeaders(),
+				body: bodyString
+			});
+		} catch {}
+	}
+	if (!response.ok) {
+		const errorBody = await response.text();
+		consola.error("Failed /v1/responses request", {
+			status: response.status,
+			statusText: response.statusText,
+			body: errorBody
+		});
+		throw new HTTPError(`Failed to call /v1/responses: ${response.status} ${errorBody}`, response);
+	}
+	if (payload.stream) {
+		const sse = events(response);
+		const translated = responsesStreamToChatChunks(sse, payload.model);
+		translated.__accountInfo = { apiBaseUrl: copilotBaseUrl(state) };
+		return translated;
+	}
+	const responsesResult = await response.json();
+	return responsesToChatResponse(responsesResult, payload.model);
+}
+
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 /**
@@ -2520,6 +2912,15 @@ function logThinkingInjection(original, injected, resolvedModel) {
 	else if (injected.reasoning_effort && injected.reasoning_effort !== original.reasoning_effort) consola.debug(`Thinking: injected reasoning_effort=${injected.reasoning_effort} for "${resolvedModel}"`);
 	else if (reasoningUnsupportedModels.has(resolvedModel)) consola.debug(`Thinking: skipped — "${resolvedModel}" does not support reasoning`);
 }
+/**
+* Models known to require `/v1/responses` (and reject `/chat/completions`
+* with `unsupported_api_for_model`). Learned at runtime — once a model
+* hits the 400, all future requests for it skip the chat-completions
+* attempt and go straight to the Responses API.
+*
+* Cleared on process restart so Copilot routing changes self-heal.
+*/
+const responsesApiOnlyModels = /* @__PURE__ */ new Set();
 const createChatCompletions = async (payload) => {
 	const resolvedModel = modelRouter.resolveModel(payload.model);
 	const routedPayload = resolvedModel !== payload.model ? {
@@ -2527,6 +2928,10 @@ const createChatCompletions = async (payload) => {
 		model: resolvedModel
 	} : payload;
 	if (resolvedModel !== payload.model) consola.debug(`Model routed: ${payload.model} → ${resolvedModel}`);
+	if (responsesApiOnlyModels.has(resolvedModel)) {
+		consola.debug(`Model "${resolvedModel}" cached as Responses-only — using /v1/responses`);
+		return createResponsesAsChat(routedPayload);
+	}
 	const thinkingPayload = injectThinking(routedPayload, resolvedModel);
 	const wasInjected = thinkingPayload.reasoning_effort !== routedPayload.reasoning_effort || thinkingPayload.thinking_budget !== routedPayload.thinking_budget;
 	logThinkingInjection(routedPayload, thinkingPayload, resolvedModel);
@@ -2542,6 +2947,11 @@ const createChatCompletions = async (payload) => {
 		releaseSlot();
 		return result;
 	} catch (error) {
+		const responsesRetry = handle400UnsupportedApiError(error, {
+			resolvedModel,
+			routedPayload
+		}, releaseSlot);
+		if (responsesRetry !== void 0) return responsesRetry;
 		const maxTokensRetry = handle400MaxTokensError(error, {
 			resolvedModel,
 			routedPayload: thinkingPayload
@@ -2559,6 +2969,35 @@ const createChatCompletions = async (payload) => {
 	}
 };
 /**
+* Handle Copilot's `unsupported_api_for_model` 400 — the model only
+* accepts /v1/responses, not /chat/completions (e.g. gpt-5.5). Mark the
+* model so future requests skip the failing attempt, then retry via the
+* Responses API translator.
+*/
+function handle400UnsupportedApiError(error, ctx, releaseSlot) {
+	if (!(error instanceof HTTPError) || error.response.status !== 400) return void 0;
+	const errMsg = error.message;
+	if (!errMsg.includes("unsupported_api_for_model") && !errMsg.includes("not accessible via the /chat/completions endpoint")) return void 0;
+	responsesApiOnlyModels.add(ctx.resolvedModel);
+	consola.debug(`Model "${ctx.resolvedModel}" requires /v1/responses — switching for future requests`);
+	return (async () => {
+		try {
+			const result = await createResponsesAsChat(ctx.routedPayload);
+			if (Symbol.asyncIterator in result) {
+				const accountInfo = result.__accountInfo;
+				const wrapped$1 = wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+				wrapped$1.__accountInfo = accountInfo;
+				return wrapped$1;
+			}
+			releaseSlot();
+			return result;
+		} catch (retryError) {
+			releaseSlot();
+			throw retryError;
+		}
+	})();
+}
+/**
 * Handle 400 errors caused by `max_tokens` being rejected — o-series and
 * GPT-5.x require `max_completion_tokens` instead.  Learns at runtime:
 * adds the model to `maxCompletionTokensModels` and retries once with the
@@ -3502,12 +3941,12 @@ function getAnthropicThinkingBlocks(reasoningContent) {
 		thinking: reasoningContent
 	}];
 }
-function getAnthropicTextBlocks(messageContent) {
-	if (typeof messageContent === "string") return [{
+function getAnthropicTextBlocks(messageContent$1) {
+	if (typeof messageContent$1 === "string") return [{
 		type: "text",
-		text: messageContent
+		text: messageContent$1
 	}];
-	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
+	if (Array.isArray(messageContent$1)) return messageContent$1.filter((part) => part.type === "text").map((part) => ({
 		type: "text",
 		text: part.text
 	}));
@@ -4556,7 +4995,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-p_Kr8XWd.js");
+		const { getGitHubUser } = await import("./get-user-Ct5NqLcM.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -4618,10 +5057,10 @@ async function runServer(options$1) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError: HTTPError$1 } = await import("./error-rdTm4jb1.js");
+		const { HTTPError: HTTPError$1 } = await import("./error-BaXXuCDb.js");
 		if (error instanceof HTTPError$1 && error.response.status === 401) {
 			consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-			const { clearGithubToken: clearGithubToken$1 } = await import("./token-CsABqA-G.js");
+			const { clearGithubToken: clearGithubToken$1 } = await import("./token-DEcUuJp7.js");
 			await clearGithubToken$1();
 			consola.info("Please restart to re-authenticate");
 		}