@hsupu/copilot-api 0.7.18-beta.3 → 0.7.19

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) {
@@ -1203,7 +1216,10 @@ function generateId(randomLength = 7) {
 //#region src/lib/token/github-client.ts
 /** GitHub OAuth API client — device code flow and user info */
 const getGitHubUser = async () => {
-	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: githubHeaders(state) });
+	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, {
+		headers: githubHeaders(state),
+		signal: AbortSignal.timeout(15e3)
+	});
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get GitHub user", response);
 	return await response.json();
 };
@@ -1214,7 +1230,8 @@ const getDeviceCode = async () => {
 		body: JSON.stringify({
 			client_id: GITHUB_CLIENT_ID,
 			scope: "read:user"
-		})
+		}),
+		signal: AbortSignal.timeout(15e3)
 	});
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get device code", response);
 	return await response.json();
@@ -1231,7 +1248,8 @@ async function pollAccessToken(deviceCode) {
 				client_id: GITHUB_CLIENT_ID,
 				device_code: deviceCode.device_code,
 				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
-			})
+			}),
+			signal: AbortSignal.timeout(15e3)
 		});
 		if (!response.ok) {
 			await sleep(sleepDuration);
@@ -1405,7 +1423,9 @@ var DeviceAuthProvider = class extends GitHubTokenProvider {
 				refreshable: true
 			};
 		} catch (error) {
+			const cause = error instanceof TypeError && error.cause ? error.cause : void 0;
 			consola.error("Device authorization failed:", error);
+			if (cause) consola.error("Caused by:", cause);
 			return null;
 		}
 	}
@@ -1735,6 +1755,17 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/fetch-utils.ts
+/**
+* Create an AbortSignal for fetch timeout if configured.
+* Controls the time from request start to receiving response headers.
+* Returns undefined if fetchTimeout is 0 (disabled).
+*/
+function createFetchSignal() {
+	return state.fetchTimeout > 0 ? AbortSignal.timeout(state.fetchTimeout * 1e3) : void 0;
+}
+
 //#endregion
 //#region src/lib/models/client.ts
 /** Fetch models from Copilot API and cache in global state */
@@ -1743,7 +1774,10 @@ async function cacheModels() {
 	rebuildModelIndex();
 }
 const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, {
+		headers: copilotHeaders(state),
+		signal: createFetchSignal()
+	});
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
 	return await response.json();
 };
@@ -4247,7 +4281,7 @@ const setupClaudeCode = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.7.18-beta.3";
+var version = "0.7.19";
 
 //#endregion
 //#region src/lib/config/config.ts
@@ -4346,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);
@@ -4557,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,
@@ -5059,7 +5095,18 @@ function responsesInputToMessages(input) {
 				content: `[item_reference: ${item.id ?? "unknown"}]`
 			});
 			break;
-		default: break;
+		case "reasoning":
+			messages.push({
+				role: "assistant",
+				content: `[reasoning: ${item.id ?? "unknown"}]`
+			});
+			break;
+		default:
+			if (item.type && item.id) messages.push({
+				role: "system",
+				content: `[${item.type}: ${item.id}]`
+			});
+			break;
 	}
 	return messages;
 }
@@ -5083,6 +5130,10 @@ function responsesOutputToContent(output) {
 				arguments: item.arguments
 			}
 		});
+		if (item.type === "reasoning") {
+			const summaryText = item.summary.map((s) => s.text).filter(Boolean).join("\n");
+			if (summaryText) textParts.push(`[Reasoning: ${summaryText}]`);
+		}
 	}
 	if (textParts.length === 0 && toolCalls.length === 0) return null;
 	return {
@@ -5104,7 +5155,9 @@ function createResponsesStreamAccumulator() {
 		responseId: "",
 		toolCalls: [],
 		toolCallMap: /* @__PURE__ */ new Map(),
-		contentParts: []
+		contentParts: [],
+		reasoningTokens: 0,
+		cachedInputTokens: 0
 	};
 }
 /** Get the final accumulated content string */
@@ -5129,6 +5182,8 @@ function accumulateResponsesStreamEvent(event, acc) {
 			if (event.response.usage) {
 				acc.inputTokens = event.response.usage.input_tokens;
 				acc.outputTokens = event.response.usage.output_tokens;
+				acc.reasoningTokens = event.response.usage.output_tokens_details?.reasoning_tokens ?? 0;
+				acc.cachedInputTokens = event.response.usage.input_tokens_details?.cached_tokens ?? 0;
 			}
 			break;
 		case "response.failed":
@@ -5303,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 };
 			}
@@ -5379,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,
@@ -5414,7 +5471,9 @@ function buildResponsesResponseData(acc, fallbackModel) {
 		model: acc.model || fallbackModel,
 		usage: {
 			input_tokens: acc.inputTokens,
-			output_tokens: acc.outputTokens
+			output_tokens: acc.outputTokens,
+			...acc.reasoningTokens > 0 && { output_tokens_details: { reasoning_tokens: acc.reasoningTokens } },
+			...acc.cachedInputTokens > 0 && { cache_read_input_tokens: acc.cachedInputTokens }
 		},
 		stop_reason: acc.status || void 0,
 		content: finalContent || toolCalls.length > 0 ? {
@@ -5595,26 +5654,20 @@ async function processResponsesInstructions(instructions, model) {
 	return processSystemPromptText(instructions, model);
 }
 
-//#endregion
-//#region src/lib/fetch-utils.ts
-/**
-* Create an AbortSignal for fetch timeout if configured.
-* Controls the time from request start to receiving response headers.
-* Returns undefined if fetchTimeout is 0 (disabled).
-*/
-function createFetchSignal() {
-	return state.fetchTimeout > 0 ? AbortSignal.timeout(state.fetchTimeout * 1e3) : void 0;
-}
-
 //#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();
@@ -5740,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) => ({
@@ -5748,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}`);
@@ -5840,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({
@@ -6658,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();
@@ -6792,6 +6850,7 @@ function createOpenAIStreamAccumulator() {
 		inputTokens: 0,
 		outputTokens: 0,
 		cachedTokens: 0,
+		reasoningTokens: 0,
 		finishReason: "",
 		content: "",
 		toolCalls: [],
@@ -6805,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) {
@@ -7057,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 = [
@@ -7228,7 +7288,8 @@ const createEmbeddings = async (payload) => {
 	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
 		method: "POST",
 		headers: copilotHeaders(state),
-		body: JSON.stringify(normalizedPayload)
+		body: JSON.stringify(normalizedPayload),
+		signal: createFetchSignal()
 	});
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to create embeddings", response);
 	return await response.json();
@@ -7946,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") {
@@ -8647,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",
@@ -8706,12 +8764,12 @@ function buildHistoryToolStubs(historyToolNames) {
 * Returns a new array — never mutates the input.
 */
 function processToolPipeline(tools, modelId, messages) {
-	const existingNames = new Set(tools.map((t) => t.name));
+	const existingNamesLower = new Set(tools.map((t) => t.name.toLowerCase()));
 	const toolSearchEnabled = modelSupportsToolSearch(modelId);
 	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
 	});
@@ -8723,7 +8781,7 @@ function processToolPipeline(tools, modelId, messages) {
 			defer_loading: true
 		} : normalized);
 	}
-	for (const name of CLAUDE_CODE_OFFICIAL_TOOLS) if (!existingNames.has(name)) {
+	for (const name of CLAUDE_CODE_OFFICIAL_TOOLS) if (!existingNamesLower.has(name.toLowerCase())) {
 		const stub = {
 			name,
 			description: `Claude Code ${name} tool`,
@@ -8914,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);
@@ -8927,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)
@@ -9063,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;
@@ -9524,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 = [
@@ -9606,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;
@@ -9638,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
@@ -9688,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 */
@@ -9701,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
@@ -9808,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,
@@ -9832,7 +9966,8 @@ async function handleDirectResponses(opts) {
 				usage: {
 					input_tokens: responsesResponse.usage?.input_tokens ?? 0,
 					output_tokens: responsesResponse.usage?.output_tokens ?? 0,
-					...responsesResponse.usage?.input_tokens_details?.cached_tokens && { cache_read_input_tokens: responsesResponse.usage.input_tokens_details.cached_tokens }
+					...responsesResponse.usage?.input_tokens_details?.cached_tokens && { cache_read_input_tokens: responsesResponse.usage.input_tokens_details.cached_tokens },
+					...responsesResponse.usage?.output_tokens_details?.reasoning_tokens && { output_tokens_details: { reasoning_tokens: responsesResponse.usage.output_tokens_details.reasoning_tokens } }
 				},
 				stop_reason: responsesResponse.status,
 				content
@@ -9867,8 +10002,12 @@ async function handleDirectResponses(opts) {
 							streamEventsIn: eventsIn
 						});
 						try {
-							accumulateResponsesStreamEvent(JSON.parse(rawEvent.data), acc);
-							await stream.writeSSE({ data: rawEvent.data });
+							const event = JSON.parse(rawEvent.data);
+							accumulateResponsesStreamEvent(event, acc);
+							await stream.writeSSE({
+								event: rawEvent.event ?? event.type,
+								data: rawEvent.data
+							});
 						} catch {}
 					}
 				}
@@ -9878,10 +10017,13 @@ async function handleDirectResponses(opts) {
 				consola.error("[Responses] Stream error:", error);
 				reqCtx.fail(acc.model || payload.model, error);
 				const errorMessage = error instanceof Error ? error.message : String(error);
-				await stream.writeSSE({ data: JSON.stringify({ error: {
-					message: errorMessage,
-					type: error instanceof StreamIdleTimeoutError ? "timeout_error" : "server_error"
-				} }) });
+				await stream.writeSSE({
+					event: "error",
+					data: JSON.stringify({ error: {
+						message: errorMessage,
+						type: error instanceof StreamIdleTimeoutError ? "timeout_error" : "server_error"
+					} })
+				});
 			}
 		});
 	} catch (error) {
@@ -10032,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;
@@ -10085,6 +10236,10 @@ async function runServer(options) {
 		on("[timeouts]", "Timeouts", parts.join(", "));
 	}
 	on("[history_limit]", "History", state.historyLimit === 0 ? "unlimited" : `max=${state.historyLimit}`);
+	on("[shutdown]", "Shutdown", `graceful=${state.shutdownGracefulWait}s, abort=${state.shutdownAbortWait}s`);
+	if (state.systemPromptOverrides.length > 0) on("[system_prompt_overrides]", "System prompt overrides", `${state.systemPromptOverrides.length} rules`);
+	if (config.system_prompt_prepend) on("[system_prompt_prepend]", "System prompt prepend", `${config.system_prompt_prepend.length} chars`);
+	if (config.system_prompt_append) on("[system_prompt_append]", "System prompt append", `${config.system_prompt_append.length} chars`);
 	consola.info(`Configuration:\n${configLines.join("\n")}`);
 	if (options.rateLimit) initAdaptiveRateLimiter({
 		baseRetryIntervalSeconds: rlRetryInterval,
@@ -10102,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();