@hsupu/copilot-api 0.7.18 → 0.7.19

package/config.example.yaml

@@ -56,7 +56,7 @@ model_overrides:
 stream_idle_timeout: 300       # Max seconds between SSE events (0 = no timeout).
                                # Applies to all streaming paths (Anthropic, Chat Completions, Responses).
 
-fetch_timeout: 60               # Seconds: request start → HTTP response headers (0 = no timeout).
+fetch_timeout: 300             # Seconds: request start → HTTP response headers (0 = no timeout).
                                # Applies to all upstream API clients.
 
 stale_request_max_age: 600     # Max seconds an active request can live before the stale reaper

package/dist/main.mjs

@@ -63,24 +63,25 @@ const DEFAULT_MODEL_OVERRIDES = {
 };
 const state = {
 	accountType: "individual",
-	modelIndex: /* @__PURE__ */ new Map(),
-	modelIds: /* @__PURE__ */ new Set(),
-	showGitHubToken: false,
-	verbose: false,
 	autoTruncate: true,
 	compressToolResultsBeforeTruncate: true,
 	convertServerToolsToCustom: true,
-	modelOverrides: { ...DEFAULT_MODEL_OVERRIDES },
 	dedupToolCalls: false,
-	rewriteSystemReminders: false,
-	truncateReadToolResult: false,
-	systemPromptOverrides: [],
+	fetchTimeout: 300,
+	filterToolSearchBlocks: false,
 	historyLimit: 200,
-	fetchTimeout: 60,
-	streamIdleTimeout: 300,
-	shutdownGracefulWait: 60,
+	modelIds: /* @__PURE__ */ new Set(),
+	modelIndex: /* @__PURE__ */ new Map(),
+	modelOverrides: { ...DEFAULT_MODEL_OVERRIDES },
+	rewriteSystemReminders: false,
+	showGitHubToken: false,
 	shutdownAbortWait: 120,
-	staleRequestMaxAge: 600
+	shutdownGracefulWait: 60,
+	staleRequestMaxAge: 600,
+	streamIdleTimeout: 300,
+	systemPromptOverrides: [],
+	truncateReadToolResult: false,
+	verbose: false
 };
 
 //#endregion
@@ -105,7 +106,7 @@ const GITHUB_API_VERSION = "2022-11-28";
 */
 const INTERACTION_ID = randomUUID();
 const copilotBaseUrl = (state) => state.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state.accountType}.githubcopilot.com`;
-const copilotHeaders = (state, vision = false) => {
+const copilotHeaders = (state, opts) => {
 	const headers = {
 		Authorization: `Bearer ${state.copilotToken}`,
 		"content-type": standardHeaders()["content-type"],
@@ -113,13 +114,17 @@ const copilotHeaders = (state, vision = false) => {
 		"editor-version": `vscode/${state.vsCodeVersion}`,
 		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 		"user-agent": USER_AGENT,
-		"openai-intent": "conversation-panel",
+		"openai-intent": opts?.intent ?? "conversation-panel",
 		"x-github-api-version": COPILOT_API_VERSION,
 		"x-request-id": randomUUID(),
 		"X-Interaction-Id": INTERACTION_ID,
 		"x-vscode-user-agent-library-version": "electron-fetch"
 	};
-	if (vision) headers["copilot-vision-request"] = "true";
+	if (opts?.vision) headers["copilot-vision-request"] = "true";
+	if (opts?.modelRequestHeaders) {
+		const coreKeysLower = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+		for (const [key, value] of Object.entries(opts.modelRequestHeaders)) if (!coreKeysLower.has(key.toLowerCase())) headers[key] = value;
+	}
 	return headers;
 };
 const GITHUB_API_BASE_URL = "https://api.github.com";
@@ -744,7 +749,10 @@ function forwardError(c, error) {
 			consola.warn(`HTTP 429: Rate limit exceeded`);
 			return c.json(formattedError, 429);
 		}
-		consola.error(`HTTP ${error.status}:`, errorJson);
+		if (typeof errorJson === "string") {
+			const preview = errorJson.trimStart().startsWith("<") ? `[HTML ${errorJson.length} bytes]` : truncateForLog(errorJson, 200);
+			consola.error(`HTTP ${error.status}: ${preview}`);
+		} else consola.error(`HTTP ${error.status}:`, errorJson);
 		return c.json({ error: {
 			message: error.responseText,
 			type: "error"
@@ -984,6 +992,11 @@ function formatErrorWithCause(error) {
 	if (error.cause instanceof Error && error.cause.message && error.cause.message !== error.message) msg += ` (cause: ${stripBunVerboseHint(error.cause.message)})`;
 	return msg;
 }
+/** Truncate a string for log display, adding ellipsis if truncated */
+function truncateForLog(text, maxLen) {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, maxLen)}… (${text.length} bytes total)`;
+}
 /** Extract error message with fallback. For HTTPError, extracts the actual API error response. */
 function getErrorMessage(error, fallback = "Unknown error") {
 	if (error instanceof Error) {
@@ -4268,7 +4281,7 @@ const setupClaudeCode = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.7.18";
+var version = "0.7.19";
 
 //#endregion
 //#region src/lib/config/config.ts
@@ -4367,6 +4380,7 @@ async function applyConfigToState() {
 		if (a.convert_server_tools_to_custom !== void 0) state.convertServerToolsToCustom = a.convert_server_tools_to_custom;
 		if (a.dedup_tool_calls !== void 0) state.dedupToolCalls = a.dedup_tool_calls === true ? "input" : a.dedup_tool_calls;
 		if (a.truncate_read_tool_result !== void 0) state.truncateReadToolResult = a.truncate_read_tool_result;
+		if (a.filter_tool_search_blocks !== void 0) state.filterToolSearchBlocks = a.filter_tool_search_blocks;
 		if (a.rewrite_system_reminders !== void 0) {
 			if (typeof a.rewrite_system_reminders === "boolean") state.rewriteSystemReminders = a.rewrite_system_reminders;
 			else if (Array.isArray(a.rewrite_system_reminders)) state.rewriteSystemReminders = compileRewriteRules(a.rewrite_system_reminders);
@@ -4578,7 +4592,8 @@ function toHistoryResponse(entryData) {
 			input_tokens: r.usage.input_tokens,
 			output_tokens: r.usage.output_tokens,
 			cache_read_input_tokens: r.usage.cache_read_input_tokens,
-			cache_creation_input_tokens: r.usage.cache_creation_input_tokens
+			cache_creation_input_tokens: r.usage.cache_creation_input_tokens,
+			output_tokens_details: r.usage.output_tokens_details
 		},
 		stop_reason: r.stop_reason,
 		error: r.error,
@@ -5343,30 +5358,31 @@ function mapAnthropicContentBlocks(acc) {
 			const { _generic: _, ...rest } = block;
 			return rest;
 		}
-		switch (block.type) {
+		if ("_brand" in block) return {
+			type: block.type,
+			tool_use_id: block.tool_use_id,
+			content: block.content
+		};
+		const narrowed = block;
+		switch (narrowed.type) {
 			case "text": return {
 				type: "text",
-				text: block.text
+				text: narrowed.text
 			};
 			case "thinking": return {
 				type: "thinking",
-				thinking: block.thinking
+				thinking: narrowed.thinking
 			};
 			case "redacted_thinking": return { type: "redacted_thinking" };
 			case "tool_use":
 			case "server_tool_use": return {
-				type: block.type,
-				id: block.id,
-				name: block.name,
-				input: safeParseJson(block.input)
-			};
-			case "web_search_tool_result": return {
-				type: "web_search_tool_result",
-				tool_use_id: block.tool_use_id,
-				content: block.content
+				type: narrowed.type,
+				id: narrowed.id,
+				name: narrowed.name,
+				input: safeParseJson(narrowed.input)
 			};
 			default: {
-				const unknown = block;
+				const unknown = narrowed;
 				consola.warn(`[recording] Unhandled content block type in stream result: ${unknown.type}`);
 				return { type: unknown.type };
 			}
@@ -5419,6 +5435,7 @@ function buildOpenAIResponseData(acc, fallbackModel) {
 		usage: {
 			input_tokens: acc.inputTokens,
 			output_tokens: acc.outputTokens,
+			...acc.reasoningTokens > 0 && { output_tokens_details: { reasoning_tokens: acc.reasoningTokens } },
 			...acc.cachedTokens > 0 && { cache_read_input_tokens: acc.cachedTokens }
 		},
 		stop_reason: acc.finishReason || void 0,
@@ -5640,12 +5657,17 @@ async function processResponsesInstructions(instructions, model) {
 //#endregion
 //#region src/lib/openai/responses-client.ts
 /** Call Copilot /responses endpoint */
-const createResponses = async (payload) => {
+const createResponses = async (payload, opts) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const enableVision = hasVisionContent(payload.input);
 	const isAgentCall = Array.isArray(payload.input) && payload.input.some((item) => item.role === "assistant" || item.type === "function_call" || item.type === "function_call_output");
+	const modelSupportsVision = opts?.resolvedModel?.capabilities?.supports?.vision !== false;
 	const headers = {
-		...copilotHeaders(state, enableVision),
+		...copilotHeaders(state, {
+			vision: enableVision && modelSupportsVision,
+			modelRequestHeaders: opts?.resolvedModel?.request_headers,
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+		}),
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
 	const fetchSignal = createFetchSignal();
@@ -5771,7 +5793,7 @@ function createTokenRefreshStrategy() {
 * centralizes that configuration to avoid duplication.
 */
 /** Create the FormatAdapter for Responses API pipeline execution */
-function createResponsesAdapter() {
+function createResponsesAdapter(selectedModel) {
 	return {
 		format: "openai-responses",
 		sanitize: (p) => ({
@@ -5779,7 +5801,7 @@ function createResponsesAdapter() {
 			removedCount: 0,
 			systemReminderRemovals: 0
 		}),
-		execute: (p) => executeWithAdaptiveRateLimit(() => createResponses(p)),
+		execute: (p) => executeWithAdaptiveRateLimit(() => createResponses(p, { resolvedModel: selectedModel })),
 		logPayloadSize: (p) => {
 			const count = typeof p.input === "string" ? 1 : p.input.length;
 			consola.debug(`Responses payload: ${count} input item(s), model: ${p.model}`);
@@ -5871,7 +5893,7 @@ async function handleResponseCreate(ws, payload) {
 		model: resolvedModel,
 		clientModel: requestedModel
 	});
-	const adapter = createResponsesAdapter();
+	const adapter = createResponsesAdapter(selectedModel);
 	const strategies = createResponsesStrategies();
 	try {
 		const iterator = (await executeRequestPipeline({
@@ -6689,12 +6711,17 @@ function createTruncationResponseMarkerOpenAI(result) {
 
 //#endregion
 //#region src/lib/openai/client.ts
-const createChatCompletions = async (payload) => {
+const createChatCompletions = async (payload, opts) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
 	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	const modelSupportsVision = opts?.resolvedModel?.capabilities?.supports?.vision !== false;
 	const headers = {
-		...copilotHeaders(state, enableVision),
+		...copilotHeaders(state, {
+			vision: enableVision && modelSupportsVision,
+			modelRequestHeaders: opts?.resolvedModel?.request_headers,
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+		}),
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
 	const fetchSignal = createFetchSignal();
@@ -6823,6 +6850,7 @@ function createOpenAIStreamAccumulator() {
 		inputTokens: 0,
 		outputTokens: 0,
 		cachedTokens: 0,
+		reasoningTokens: 0,
 		finishReason: "",
 		content: "",
 		toolCalls: [],
@@ -6836,6 +6864,7 @@ function accumulateOpenAIStreamEvent(parsed, acc) {
 		acc.inputTokens = parsed.usage.prompt_tokens;
 		acc.outputTokens = parsed.usage.completion_tokens;
 		if (parsed.usage.prompt_tokens_details?.cached_tokens !== void 0) acc.cachedTokens = parsed.usage.prompt_tokens_details.cached_tokens;
+		if (parsed.usage.completion_tokens_details?.reasoning_tokens !== void 0) acc.reasoningTokens = parsed.usage.completion_tokens_details.reasoning_tokens;
 	}
 	const choice = parsed.choices[0];
 	if (choice) {
@@ -7088,7 +7117,7 @@ async function executeRequest(opts) {
 	const adapter = {
 		format: "openai-chat-completions",
 		sanitize: (p) => sanitizeOpenAIMessages(p),
-		execute: (p) => executeWithAdaptiveRateLimit(() => createChatCompletions(p)),
+		execute: (p) => executeWithAdaptiveRateLimit(() => createChatCompletions(p, { resolvedModel: selectedModel })),
 		logPayloadSize: (p) => logPayloadSizeInfo(p, selectedModel)
 	};
 	const strategies = [
@@ -7978,9 +8007,6 @@ function contentToText(content, options) {
 		case "server_tool_use":
 			parts.push(`[server_tool_use: ${block.name}]`, JSON.stringify(block.input));
 			break;
-		case "web_search_tool_result":
-			parts.push(`[web_search_tool_result]`);
-			break;
 		default: {
 			const genericBlock = block;
 			if ("tool_use_id" in genericBlock && genericBlock.type !== "image") {
@@ -8679,7 +8705,7 @@ const NON_DEFERRED_TOOL_NAMES = new Set([
 	"switch_agent",
 	...CLAUDE_CODE_OFFICIAL_TOOLS
 ]);
-const TOOL_SEARCH_TOOL_NAME = "tool_search_tool_regex";
+const TOOL_SEARCH_TOOL_NAME$1 = "tool_search_tool_regex";
 const TOOL_SEARCH_TOOL_TYPE = "tool_search_tool_regex_20251119";
 const EMPTY_INPUT_SCHEMA = {
 	type: "object",
@@ -8743,7 +8769,7 @@ function processToolPipeline(tools, modelId, messages) {
 	const historyToolNames = toolSearchEnabled ? collectHistoryToolNames(messages) : void 0;
 	const result = [];
 	if (toolSearchEnabled) result.push({
-		name: TOOL_SEARCH_TOOL_NAME,
+		name: TOOL_SEARCH_TOOL_NAME$1,
 		type: TOOL_SEARCH_TOOL_TYPE,
 		defer_loading: false
 	});
@@ -8946,7 +8972,7 @@ function adjustThinkingBudget(wire) {
 * Create messages using Anthropic-style API directly.
 * Calls Copilot's native Anthropic endpoint for Anthropic-vendor models.
 */
-async function createAnthropicMessages(payload) {
+async function createAnthropicMessages(payload, opts) {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const wire = buildWirePayload(payload);
 	adjustThinkingBudget(wire);
@@ -8959,8 +8985,13 @@ async function createAnthropicMessages(payload) {
 		return msg.content.some((block) => block.type === "image");
 	});
 	const isAgentCall = messages.some((msg) => msg.role === "assistant");
+	const modelSupportsVision = opts?.resolvedModel?.capabilities?.supports?.vision !== false;
 	const headers = {
-		...copilotHeaders(state, enableVision),
+		...copilotHeaders(state, {
+			vision: enableVision && modelSupportsVision,
+			modelRequestHeaders: opts?.resolvedModel?.request_headers,
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+		}),
 		"X-Initiator": isAgentCall ? "agent" : "user",
 		"anthropic-version": "2023-06-01",
 		...buildAnthropicBetaHeaders(model)
@@ -9095,25 +9126,29 @@ function handleContentBlockStart(index, block, acc) {
 				input: ""
 			};
 			break;
-		case "web_search_tool_result":
-			newBlock = {
-				type: "web_search_tool_result",
-				tool_use_id: block.tool_use_id,
-				content: block.content
-			};
-			break;
-		default: {
-			const unknownBlock = block;
-			consola.warn(`[stream-accumulator] Unknown content block type: ${String(unknownBlock.type)}`);
+		default:
+			if (isServerToolResultType(block.type) && "tool_use_id" in block) {
+				newBlock = {
+					_brand: "server_tool_result",
+					type: block.type,
+					tool_use_id: block.tool_use_id,
+					content: block.content
+				};
+				break;
+			}
+			consola.warn(`[stream-accumulator] Unknown content block type: ${block.type}`);
 			newBlock = {
-				...unknownBlock,
+				...block,
 				_generic: true
 			};
 			break;
-		}
 	}
 	acc.contentBlocks[index] = newBlock;
 }
+/** Check if a block type is a server-side tool result (ends with _tool_result, but not plain tool_result) */
+function isServerToolResultType(type) {
+	return type !== "tool_result" && type.endsWith("_tool_result");
+}
 function handleContentBlockDelta(index, delta, acc, copilotAnnotations) {
 	const block = acc.contentBlocks[index];
 	if (!block) return;
@@ -9556,7 +9591,7 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, reqCtx) {
 	const adapter = {
 		format: "anthropic-messages",
 		sanitize: (p) => sanitizeAnthropicMessages(preprocessTools(p)),
-		execute: (p) => executeWithAdaptiveRateLimit(() => createAnthropicMessages(p)),
+		execute: (p) => executeWithAdaptiveRateLimit(() => createAnthropicMessages(p, { resolvedModel: selectedModel })),
 		logPayloadSize: (p) => logPayloadSizeInfoAnthropic(p, selectedModel)
 	};
 	const strategies = [
@@ -9638,6 +9673,7 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 	let eventsIn = 0;
 	let currentBlockType = "";
 	let firstEventLogged = false;
+	const toolSearchFilter = state.filterToolSearchBlocks ? createToolSearchBlockFilter() : null;
 	try {
 		for await (const { raw: rawEvent, parsed } of processAnthropicStream(response, acc, clientAbortSignal)) {
 			const dataLen = rawEvent.data?.length ?? 0;
@@ -9670,8 +9706,10 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 				const delta = parsed.delta;
 				if (delta.type === "text_delta" && delta.text) checkRepetition(delta.text);
 			}
+			const forwardData = toolSearchFilter ? toolSearchFilter.rewriteEvent(parsed, rawEvent.data ?? "") : rawEvent.data ?? "";
+			if (forwardData === null) continue;
 			await stream.writeSSE({
-				data: rawEvent.data ?? "",
+				data: forwardData,
 				event: rawEvent.event,
 				id: rawEvent.id !== void 0 ? String(rawEvent.id) : void 0,
 				retry: rawEvent.retry
@@ -9720,6 +9758,7 @@ function handleDirectAnthropicNonStreamingResponse(c, response, reqCtx, truncate
 	});
 	let finalResponse = response;
 	if (state.verbose && truncateResult?.wasTruncated) finalResponse = prependMarkerToResponse(response, createTruncationMarker$1(truncateResult));
+	if (state.filterToolSearchBlocks) finalResponse = filterToolSearchBlocksFromResponse(finalResponse);
 	return c.json(finalResponse);
 }
 /** Convert SanitizationStats to the format expected by rewrites */
@@ -9733,6 +9772,69 @@ function toSanitizationInfo(stats) {
 		systemReminderRemovals: stats.systemReminderRemovals
 	};
 }
+const TOOL_SEARCH_TOOL_NAME = "tool_search_tool_regex";
+const TOOL_SEARCH_RESULT_TYPE = "tool_search_tool_result";
+/** Check if a content block is an internal tool_search block */
+function isToolSearchBlock(block) {
+	if (block.type === "server_tool_use" && block.name === TOOL_SEARCH_TOOL_NAME) return true;
+	if (block.type === TOOL_SEARCH_RESULT_TYPE) return true;
+	return false;
+}
+/**
+* Filters tool_search blocks from the SSE stream before forwarding to the client.
+* Handles index remapping so block indices remain dense/sequential after filtering.
+*/
+function createToolSearchBlockFilter() {
+	const filteredIndices = /* @__PURE__ */ new Set();
+	const clientIndexMap = /* @__PURE__ */ new Map();
+	let nextClientIndex = 0;
+	function getClientIndex(apiIndex) {
+		let idx = clientIndexMap.get(apiIndex);
+		if (idx === void 0) {
+			idx = nextClientIndex++;
+			clientIndexMap.set(apiIndex, idx);
+		}
+		return idx;
+	}
+	return { rewriteEvent(parsed, rawData) {
+		if (!parsed) return rawData;
+		if (parsed.type === "content_block_start") {
+			const block = parsed.content_block;
+			if (isToolSearchBlock(block)) {
+				filteredIndices.add(parsed.index);
+				return null;
+			}
+			if (filteredIndices.size === 0) {
+				getClientIndex(parsed.index);
+				return rawData;
+			}
+			const clientIndex = getClientIndex(parsed.index);
+			if (clientIndex === parsed.index) return rawData;
+			const obj = JSON.parse(rawData);
+			obj.index = clientIndex;
+			return JSON.stringify(obj);
+		}
+		if (parsed.type === "content_block_delta" || parsed.type === "content_block_stop") {
+			if (filteredIndices.has(parsed.index)) return null;
+			if (filteredIndices.size === 0) return rawData;
+			const clientIndex = getClientIndex(parsed.index);
+			if (clientIndex === parsed.index) return rawData;
+			const obj = JSON.parse(rawData);
+			obj.index = clientIndex;
+			return JSON.stringify(obj);
+		}
+		return rawData;
+	} };
+}
+/** Filter tool_search blocks from a non-streaming response */
+function filterToolSearchBlocksFromResponse(response) {
+	const filtered = response.content.filter((block) => !isToolSearchBlock(block));
+	if (filtered.length === response.content.length) return response;
+	return {
+		...response,
+		content: filtered
+	};
+}
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -9840,9 +9942,9 @@ async function handleResponses(c) {
 /** Pass through to Copilot /responses endpoint directly */
 async function handleDirectResponses(opts) {
 	const { c, payload, reqCtx } = opts;
-	const adapter = createResponsesAdapter();
-	const strategies = createResponsesStrategies();
 	const selectedModel = state.modelIndex.get(payload.model);
+	const adapter = createResponsesAdapter(selectedModel);
+	const strategies = createResponsesStrategies();
 	try {
 		const pipelineResult = await executeRequestPipeline({
 			adapter,
@@ -10072,7 +10174,16 @@ function parseIntOrDefault(value, defaultValue) {
 	const parsed = Number.parseInt(value, 10);
 	return Number.isFinite(parsed) ? parsed : defaultValue;
 }
+const VALID_ACCOUNT_TYPES = [
+	"individual",
+	"business",
+	"enterprise"
+];
 async function runServer(options) {
+	if (!VALID_ACCOUNT_TYPES.includes(options.accountType)) {
+		consola.error(`Invalid account type: "${options.accountType}". Must be one of: ${VALID_ACCOUNT_TYPES.join(", ")}`);
+		process.exit(1);
+	}
 	if (options.verbose) {
 		consola.level = 5;
 		state.verbose = true;
@@ -10146,7 +10257,9 @@ async function runServer(options) {
 	try {
 		await cacheModels();
 	} catch (error) {
-		consola.warn("Failed to fetch models from Copilot API:", error instanceof Error ? error.message : error);
+		consola.error("Failed to fetch models from Copilot API:", error instanceof Error ? error.message : error);
+		consola.error(`Verify that --account-type "${state.accountType}" is correct. Available types: ${VALID_ACCOUNT_TYPES.join(", ")}`);
+		process.exit(1);
 	}
 	consola.info(`Available models:\n${state.models?.data.map((m) => formatModelInfo(m)).join("\n")}`);
 	await loadPersistedLimits();