copilot-api-plus 1.4.10 → 1.6.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-DktL5osZ.js";
-import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-B8FDrdsQ.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-2psqVsSO.js";
+import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-DokbvagK.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";
@@ -1392,6 +1392,7 @@ accountRoutes.post("/", async (c) => {
 		const body = await c.req.json();
 		if (!body.githubToken || !body.label) return c.json({ error: "githubToken and label are required" }, 400);
 		const account = await accountManager.addAccount(body.githubToken, body.label, body.accountType);
+		accountManager.refreshGithubRateLimit(account);
 		if (body.proxy) {
 			try {
 				const proxyUrl = new URL(body.proxy);
@@ -1479,6 +1480,7 @@ accountRoutes.post("/:id/refresh", async (c) => {
 		if (!account) return c.json({ error: "Account not found" }, 404);
 		await accountManager.refreshAccountToken(account);
 		await accountManager.refreshAccountUsage(account);
+		await accountManager.refreshGithubRateLimit(account);
 		return c.json({ account: sanitiseAccount(account) });
 	} catch (error) {
 		consola.warn(`Error refreshing account: ${rootCause(error)}`);
@@ -1486,6 +1488,32 @@ accountRoutes.post("/:id/refresh", async (c) => {
 		return c.json({ error: "Failed to refresh account" }, 500);
 	}
 });
+accountRoutes.post("/:id/refresh-limits", async (c) => {
+	try {
+		const id = c.req.param("id");
+		const account = accountManager.getAccountById(id);
+		if (!account) return c.json({ error: "Account not found" }, 404);
+		await accountManager.refreshGithubRateLimit(account);
+		return c.json({ account: sanitiseAccount(account) });
+	} catch (error) {
+		consola.warn(`Error refreshing rate limits: ${rootCause(error)}`);
+		consola.debug("Error refreshing rate limits:", error);
+		return c.json({ error: "Failed to refresh rate limits" }, 500);
+	}
+});
+accountRoutes.post("/:id/clear-session-limit", (c) => {
+	try {
+		const id = c.req.param("id");
+		const account = accountManager.getAccountById(id);
+		if (!account) return c.json({ error: "Account not found" }, 404);
+		accountManager.clearCopilotSessionLimit(id);
+		return c.json({ account: sanitiseAccount(account) });
+	} catch (error) {
+		consola.warn(`Error clearing session limit: ${rootCause(error)}`);
+		consola.debug("Error clearing session limit:", error);
+		return c.json({ error: "Failed to clear session limit" }, 500);
+	}
+});
 accountRoutes.post("/auth/start", async (c) => {
 	try {
 		if (cachedDeviceCode && Date.now() < cachedDeviceCodeExpiresAt) {
@@ -1579,6 +1607,7 @@ accountRoutes.post("/auth/poll", async (c) => {
 			clearAuthFlowState();
 			const accountLabel = label || `Account ${accountManager.accountCount + 1}`;
 			const account = await accountManager.addAccount(json.access_token, accountLabel, account_type || "individual");
+			accountManager.refreshGithubRateLimit(account);
 			return c.json({
 				status: "complete",
 				account: sanitiseAccount(account)
@@ -1899,6 +1928,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 +2071,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 +2335,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 +2941,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 +2957,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 +2976,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 +2998,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
@@ -2757,6 +3225,29 @@ function isNonAccountError(errMsg) {
 * Returns the successful retry result, or null if the error was handled
 * without a successful retry.
 */
+/**
+* Handle a 429 from upstream: detect Copilot 5h Pro+ session-limit signature,
+* snapshot GitHub /rate_limit, and decide whether to mark the account or
+* propagate the error to the client (single-account guard).
+*/
+async function handle429(error, account, hasOtherAccount) {
+	let body;
+	try {
+		body = await error.response.clone().text();
+	} catch {
+		body = error.message || "";
+	}
+	const isCopilotSessionLimit = body.includes("user_global_rate_limited:pro_plus");
+	if (isCopilotSessionLimit) accountManager.markCopilotSessionLimit(account.id, "user_global_rate_limited:pro_plus");
+	accountManager.refreshGithubRateLimit(account);
+	if (!hasOtherAccount) {
+		consola.warn(`Account ${account.label}: 429 — only account, propagating to client without marking`);
+		error.__nonAccountError = true;
+		return null;
+	}
+	accountManager.markAccountStatus(account.id, "rate_limited", isCopilotSessionLimit ? "429 Copilot 5h session limit" : "429 Rate limited");
+	return null;
+}
 async function handleMultiAccountHttpError(error, account, retryContext) {
 	switch (error.response.status) {
 		case 401:
@@ -2770,14 +3261,7 @@ async function handleMultiAccountHttpError(error, account, retryContext) {
 			}
 			accountManager.markAccountStatus(account.id, "banned", "403 Forbidden");
 			return null;
-		case 429:
-			if (!retryContext.hasOtherAccount) {
-				consola.warn(`Account ${account.label}: 429 — only account, propagating to client without marking`);
-				error.__nonAccountError = true;
-				return null;
-			}
-			accountManager.markAccountStatus(account.id, "rate_limited", "429 Rate limited");
-			return null;
+		case 429: return handle429(error, account, retryContext.hasOtherAccount);
 		case 408:
 			consola.warn(`Account ${account.label}: 408 request timeout (network issue, not rotating)`);
 			error.__nonAccountError = true;
@@ -3502,12 +3986,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
 	}));
@@ -3790,7 +4274,7 @@ async function createWithMultiAccount(payload, options$1) {
 		} catch (error) {
 			lastError = error;
 			if (error instanceof HTTPError) {
-				const action = handleAnthropicHttpError(error, account, triedAccountIds);
+				const action = await handleAnthropicHttpError(error, account, triedAccountIds);
 				if (action === "refresh401") return handleMultiAccount401(ctx, account);
 				if (action === "throw") throw error;
 				continue;
@@ -3822,11 +4306,21 @@ async function createWithMultiAccount(payload, options$1) {
 * would disable the proxy entirely, so 429 / 403 are propagated unchanged
 * to the client when no other account is available.
 */
-function handleAnthropicHttpError(error, account, triedAccountIds) {
+async function handleAnthropicHttpError(error, account, triedAccountIds) {
 	const status = error.response.status;
 	if (status === 401) return "refresh401";
 	if (status === 429 || status === 403) {
 		const isRateLimit = status === 429;
+		if (isRateLimit) {
+			let body;
+			try {
+				body = await error.response.clone().text();
+			} catch {
+				body = error.message || "";
+			}
+			if (body.includes("user_global_rate_limited:pro_plus")) accountManager.markCopilotSessionLimit(account.id, "user_global_rate_limited:pro_plus");
+			accountManager.refreshGithubRateLimit(account);
+		}
 		if (hasAnotherAnthropicAccountToTry(triedAccountIds)) {
 			accountManager.markAccountStatus(account.id, isRateLimit ? "rate_limited" : "banned", isRateLimit ? "429 Rate limited" : "403 Forbidden");
 			consola.warn(`Account ${account.label}: ${status} on /v1/messages, trying next account`);
@@ -4556,7 +5050,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-Ct5NqLcM.js");
+		const { getGitHubUser } = await import("./get-user-CZ4szDap.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -4618,10 +5112,10 @@ async function runServer(options$1) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError: HTTPError$1 } = await import("./error-BaXXuCDb.js");
+		const { HTTPError: HTTPError$1 } = await import("./error-C7zHD_5f.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-DEcUuJp7.js");
+			const { clearGithubToken: clearGithubToken$1 } = await import("./token-CRJg2Pnb.js");
 			await clearGithubToken$1();
 			consola.info("Please restart to re-authenticate");
 		}