@dianshuv/copilot-api 0.6.1 → 0.6.3

package/README.md

@@ -66,7 +66,8 @@ copilot-api start
 | `--no-auto-truncate` | Disable auto-truncate when exceeding token limits | false |
 | `--compress-tool-results` | Compress old tool results before truncating | false |
 | `--redirect-anthropic` | Force Anthropic through OpenAI translation | false |
-| `--no-rewrite-anthropic-tools` | Don't rewrite server-side tools | false |
+| `--strip-server-tools` | Strip server-side tools from Anthropic requests | false |
+| `--context-editing` | Context editing mode: off, clear-thinking, clear-tooluse, clear-both | off |
 | `--timezone-offset` | Timezone offset in hours from UTC for log timestamps (e.g., +8, -5, 0) | +8 |
 | `--posthog-key` | PostHog API key for token usage analytics (opt-in) | none |
 

package/dist/main.mjs

@@ -4,14 +4,14 @@ import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path, { dirname, join } from "node:path";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
 import { PostHog } from "posthog-node";
-import { getProxyForUrl } from "proxy-from-env";
-import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { execSync } from "node:child_process";
 import process$1 from "node:process";
 import pc from "picocolors";
@@ -32,12 +32,90 @@ async function ensurePaths() {
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
 }
 async function ensureFile(filePath) {
+	const isWindows = process.platform === "win32";
 	try {
 		await fs.access(filePath, fs.constants.W_OK);
-		if (((await fs.stat(filePath)).mode & 511) !== 384) await fs.chmod(filePath, 384);
+		if (!isWindows) {
+			if (((await fs.stat(filePath)).mode & 511) !== 384) await fs.chmod(filePath, 384);
+		}
 	} catch {
 		await fs.writeFile(filePath, "");
-		await fs.chmod(filePath, 384);
+		if (!isWindows) await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/lib/proxy.ts
+/**
+* Custom dispatcher that routes requests through proxies based on environment variables.
+* Extends Agent to properly inherit the Dispatcher interface.
+*/
+var ProxyDispatcher = class extends Agent {
+	proxies = /* @__PURE__ */ new Map();
+	dispatch(options, handler) {
+		try {
+			const origin = this.getOriginUrl(options.origin);
+			const proxyUrl = this.getProxyUrl(origin);
+			if (!proxyUrl) {
+				consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+				return super.dispatch(options, handler);
+			}
+			const agent = this.getOrCreateProxyAgent(proxyUrl);
+			consola.debug(`HTTP proxy route: ${origin.hostname} via ${this.formatProxyLabel(proxyUrl)}`);
+			return agent.dispatch(options, handler);
+		} catch {
+			return super.dispatch(options, handler);
+		}
+	}
+	getOriginUrl(origin) {
+		return typeof origin === "string" ? new URL(origin) : origin;
+	}
+	getProxyUrl(origin) {
+		const raw = getProxyForUrl(origin.toString());
+		return raw && raw.length > 0 ? raw : void 0;
+	}
+	getOrCreateProxyAgent(proxyUrl) {
+		let agent = this.proxies.get(proxyUrl);
+		if (!agent) {
+			agent = new ProxyAgent(proxyUrl);
+			this.proxies.set(proxyUrl, agent);
+		}
+		return agent;
+	}
+	formatProxyLabel(proxyUrl) {
+		try {
+			const u = new URL(proxyUrl);
+			return `${u.protocol}//${u.host}`;
+		} catch {
+			return proxyUrl;
+		}
+	}
+	async close() {
+		await super.close();
+		await Promise.all([...this.proxies.values()].map((p) => p.close()));
+		this.proxies.clear();
+	}
+	destroy(errOrCallback, callback) {
+		for (const agent of this.proxies.values()) if (typeof errOrCallback === "function") agent.destroy(errOrCallback);
+		else if (callback) agent.destroy(errOrCallback ?? null, callback);
+		else agent.destroy(errOrCallback ?? null).catch(() => {});
+		this.proxies.clear();
+		if (typeof errOrCallback === "function") {
+			super.destroy(errOrCallback);
+			return;
+		} else if (callback) {
+			super.destroy(errOrCallback ?? null, callback);
+			return;
+		} else return super.destroy(errOrCallback ?? null);
+	}
+};
+function initProxyFromEnv() {
+	if (typeof Bun !== "undefined") return;
+	try {
+		setGlobalDispatcher(new ProxyDispatcher());
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
 	}
 }
 
@@ -51,7 +129,10 @@ const state = {
 	autoTruncate: true,
 	compressToolResults: false,
 	redirectAnthropic: false,
-	rewriteAnthropicTools: true,
+	stripServerTools: false,
+	contextEditingMode: "off",
+	normalizeResponsesCallIds: true,
+	historyMinEntries: 50,
 	staleRequestMaxAge: 600,
 	timezoneOffset: 8,
 	shutdownGracefulWait: 60,
@@ -482,6 +563,7 @@ async function runAuth(options) {
 		consola.info("Verbose logging enabled");
 	}
 	state.showToken = options.showToken;
+	initProxyFromEnv();
 	await ensurePaths();
 	await setupGitHubToken({ force: true });
 	consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
@@ -528,6 +610,7 @@ const checkUsage = defineCommand({
 		description: "Show current GitHub Copilot usage/quota information"
 	},
 	async run() {
+		initProxyFromEnv();
 		await ensurePaths();
 		await setupGitHubToken();
 		try {
@@ -585,6 +668,7 @@ async function checkTokenExists() {
 }
 async function getAccountInfo() {
 	try {
+		initProxyFromEnv();
 		await ensurePaths();
 		await setupGitHubToken();
 		if (!state.githubToken) return null;
@@ -673,6 +757,7 @@ const debugModels = defineCommand({
 	},
 	async run({ args }) {
 		state.accountType = args["account-type"];
+		initProxyFromEnv();
 		await ensurePaths();
 		if (args["github-token"]) {
 			state.githubToken = args["github-token"];
@@ -1036,7 +1121,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.6.1";
+var version = "0.6.3";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -1908,6 +1993,26 @@ function getTokenStats() {
 		timeline
 	};
 }
+function getHistoryEntryCount() {
+	return historyState.entries.length;
+}
+function getHistoryMaxEntries() {
+	return historyState.maxEntries;
+}
+function setHistoryMaxEntries(max) {
+	historyState.maxEntries = max;
+}
+/**
+* Evict the oldest `count` entries from the history store.
+* Returns the actual number of entries evicted.
+*/
+function evictOldestEntries(count) {
+	if (count <= 0) return 0;
+	const actual = Math.min(count, historyState.entries.length);
+	const removed = historyState.entries.splice(0, actual);
+	for (const entry of removed) if (!historyState.entries.some((e) => e.sessionId === entry.sessionId)) historyState.sessions.delete(entry.sessionId);
+	return actual;
+}
 function exportHistory(format = "json") {
 	if (format === "json") return JSON.stringify({
 		sessions: Array.from(historyState.sessions.values()),
@@ -1948,6 +2053,91 @@ function exportHistory(format = "json") {
 	return [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");
 }
 
+//#endregion
+//#region src/lib/history-memory-pressure.ts
+/**
+* Memory pressure monitor — proactively evicts old history entries
+* when heap usage approaches the V8 heap limit, preventing OOM crashes.
+*
+* Graduated response:
+*   75–80%  Warning: log only, no eviction
+*   80–90%  High: evict entries, reduce maxEntries by 25%
+*   90%+    Critical: aggressive eviction, reduce maxEntries by 50%
+*/
+const CHECK_INTERVAL_MS = 3e4;
+const WARN_THRESHOLD = .75;
+const EVICT_THRESHOLD = .8;
+const CRITICAL_THRESHOLD = .9;
+const WARN_LOG_COOLDOWN_MS = 3e5;
+let resolvedHeapLimit = null;
+let timer = null;
+let lastWarningTime = 0;
+let totalEvictedCount = 0;
+async function resolveHeapLimit() {
+	if (resolvedHeapLimit !== null) return resolvedHeapLimit;
+	let limit;
+	try {
+		limit = (await import("node:v8")).getHeapStatistics().heap_size_limit;
+	} catch {
+		limit = 512 * 1024 * 1024;
+	}
+	resolvedHeapLimit = limit;
+	return limit;
+}
+function formatMB(bytes) {
+	return `${Math.round(bytes / 1024 / 1024)}MB`;
+}
+function formatPct(ratio) {
+	return `${Math.round(ratio * 100)}%`;
+}
+async function checkMemoryPressure() {
+	const heapLimit = await resolveHeapLimit();
+	const { heapUsed } = process.memoryUsage();
+	const ratio = heapUsed / heapLimit;
+	if (ratio < WARN_THRESHOLD) return;
+	const currentEntries = getHistoryEntryCount();
+	if (currentEntries <= state.historyMinEntries) {
+		if (ratio >= EVICT_THRESHOLD && Date.now() - lastWarningTime > WARN_LOG_COOLDOWN_MS) {
+			lastWarningTime = Date.now();
+			consola.warn(`[memory] Heap ${formatMB(heapUsed)}/${formatMB(heapLimit)} (${formatPct(ratio)}) — only ${currentEntries} history entries remain. Consider increasing --max-old-space-size`);
+		}
+		return;
+	}
+	if (ratio < EVICT_THRESHOLD) {
+		if (Date.now() - lastWarningTime > WARN_LOG_COOLDOWN_MS) {
+			lastWarningTime = Date.now();
+			consola.warn(`[memory] Heap ${formatMB(heapUsed)}/${formatMB(heapLimit)} (${formatPct(ratio)}) — approaching limit, ${currentEntries} history entries in memory`);
+		}
+		return;
+	}
+	lastWarningTime = Date.now();
+	const currentMax = getHistoryMaxEntries();
+	const newMaxEntries = ratio >= CRITICAL_THRESHOLD ? Math.max(state.historyMinEntries, Math.floor(currentMax * .5)) : Math.max(state.historyMinEntries, Math.floor(currentMax * .75));
+	const evictCount = Math.max(0, currentEntries - newMaxEntries);
+	if (evictCount <= 0) return;
+	const evicted = evictOldestEntries(evictCount);
+	totalEvictedCount += evicted;
+	if (newMaxEntries < currentMax) setHistoryMaxEntries(newMaxEntries);
+	const afterHeapUsed = process.memoryUsage().heapUsed;
+	consola.warn(`[memory] Evicted ${evicted} history entries due to memory pressure (heap: ${formatMB(heapUsed)} → ${formatMB(afterHeapUsed)}/${formatMB(heapLimit)}, entries: ${currentEntries} → ${currentEntries - evicted}, max: ${newMaxEntries})`);
+	globalThis.gc?.();
+}
+function startMemoryPressureMonitor() {
+	if (timer) return;
+	timer = setInterval(() => {
+		checkMemoryPressure().catch((error) => {
+			consola.error("[memory] Error in memory pressure check:", error);
+		});
+	}, CHECK_INTERVAL_MS);
+	if ("unref" in timer) timer.unref();
+}
+function stopMemoryPressureMonitor() {
+	if (timer) {
+		clearInterval(timer);
+		timer = null;
+	}
+}
+
 //#endregion
 //#region src/lib/posthog.ts
 let client = null;
@@ -1997,81 +2187,6 @@ async function shutdownPostHog() {
 	}
 }
 
-//#endregion
-//#region src/lib/proxy.ts
-/**
-* Custom dispatcher that routes requests through proxies based on environment variables.
-* Extends Agent to properly inherit the Dispatcher interface.
-*/
-var ProxyDispatcher = class extends Agent {
-	proxies = /* @__PURE__ */ new Map();
-	dispatch(options, handler) {
-		try {
-			const origin = this.getOriginUrl(options.origin);
-			const proxyUrl = this.getProxyUrl(origin);
-			if (!proxyUrl) {
-				consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
-				return super.dispatch(options, handler);
-			}
-			const agent = this.getOrCreateProxyAgent(proxyUrl);
-			consola.debug(`HTTP proxy route: ${origin.hostname} via ${this.formatProxyLabel(proxyUrl)}`);
-			return agent.dispatch(options, handler);
-		} catch {
-			return super.dispatch(options, handler);
-		}
-	}
-	getOriginUrl(origin) {
-		return typeof origin === "string" ? new URL(origin) : origin;
-	}
-	getProxyUrl(origin) {
-		const raw = getProxyForUrl(origin.toString());
-		return raw && raw.length > 0 ? raw : void 0;
-	}
-	getOrCreateProxyAgent(proxyUrl) {
-		let agent = this.proxies.get(proxyUrl);
-		if (!agent) {
-			agent = new ProxyAgent(proxyUrl);
-			this.proxies.set(proxyUrl, agent);
-		}
-		return agent;
-	}
-	formatProxyLabel(proxyUrl) {
-		try {
-			const u = new URL(proxyUrl);
-			return `${u.protocol}//${u.host}`;
-		} catch {
-			return proxyUrl;
-		}
-	}
-	async close() {
-		await super.close();
-		await Promise.all([...this.proxies.values()].map((p) => p.close()));
-		this.proxies.clear();
-	}
-	destroy(errOrCallback, callback) {
-		for (const agent of this.proxies.values()) if (typeof errOrCallback === "function") agent.destroy(errOrCallback);
-		else if (callback) agent.destroy(errOrCallback ?? null, callback);
-		else agent.destroy(errOrCallback ?? null).catch(() => {});
-		this.proxies.clear();
-		if (typeof errOrCallback === "function") {
-			super.destroy(errOrCallback);
-			return;
-		} else if (callback) {
-			super.destroy(errOrCallback ?? null, callback);
-			return;
-		} else return super.destroy(errOrCallback ?? null);
-	}
-};
-function initProxyFromEnv() {
-	if (typeof Bun !== "undefined") return;
-	try {
-		setGlobalDispatcher(new ProxyDispatcher());
-		consola.debug("HTTP proxy configured from environment (per-URL)");
-	} catch (err) {
-		consola.debug("Proxy setup skipped:", err);
-	}
-}
-
 //#endregion
 //#region src/lib/shell.ts
 function getShell() {
@@ -2184,6 +2299,7 @@ async function gracefulShutdown(signal, deps) {
 	try {
 		deps?.contextManager?.stopReaper();
 	} catch {}
+	stopMemoryPressureMonitor();
 	stopRefresh();
 	const wsClients = getWsCount();
 	if (wsClients > 0) {
@@ -4483,6 +4599,30 @@ function handleNonStreamResponse(c, response, model, ctx, payload) {
 	return c.json(geminiResponse);
 }
 
+//#endregion
+//#region src/routes/gemini/model-alias.ts
+/**
+* Maps Gemini model names that aren't available on GitHub Copilot
+* to equivalent models that are.
+*
+* The Gemini CLI's routing classifier requests gemini-2.5-flash-lite
+* and gemini-2.5-flash, which Copilot doesn't serve. We map them to
+* the closest available flash model.
+*
+* Aliases are only applied when the requested model is absent from
+* the Copilot model list, so if Copilot adds support for these models
+* natively, requests will go through unchanged.
+*/
+const GEMINI_MODEL_ALIASES = {
+	"gemini-2.5-flash-lite": "gemini-3-flash-preview",
+	"gemini-2.5-flash": "gemini-3-flash-preview"
+};
+function resolveGeminiModelAlias(model) {
+	if (!(model in GEMINI_MODEL_ALIASES)) return model;
+	if (state.models?.data.some((m) => m.id === model)) return model;
+	return GEMINI_MODEL_ALIASES[model];
+}
+
 //#endregion
 //#region src/routes/gemini/route.ts
 const geminiRoutes = new Hono();
@@ -4490,7 +4630,7 @@ geminiRoutes.post("/:modelAction", async (c) => {
 	const modelAction = c.req.param("modelAction");
 	const colonIndex = modelAction.lastIndexOf(":");
 	if (colonIndex === -1) return geminiError(c, 400, "INVALID_ARGUMENT", "Missing action in URL");
-	const model = modelAction.slice(0, Math.max(0, colonIndex));
+	const model = resolveGeminiModelAlias(modelAction.slice(0, Math.max(0, colonIndex)));
 	const action = modelAction.slice(Math.max(0, colonIndex + 1));
 	switch (action) {
 		case "generateContent": return handleGeminiGenerate(c, model, false);
@@ -6526,6 +6666,156 @@ async function checkNeedsCompactionAnthropic(payload, model, config = {}) {
 	};
 }
 
+//#endregion
+//#region src/lib/anthropic/features.ts
+function normalizeForMatching(modelId) {
+	return modelId.toLowerCase().replaceAll(/[-_.]/g, "").replace(/\d{8}$/, "");
+}
+function modelSupportsContextEditing(modelId) {
+	const n = normalizeForMatching(modelId);
+	return n.includes("claude") && (n.includes("haiku45") || n.includes("sonnet4") || n.includes("sonnet45") || n.includes("sonnet46") || n.includes("opus4") || n.includes("opus41") || n.includes("opus45") || n.includes("opus46"));
+}
+function modelSupportsToolSearch(modelId) {
+	const n = normalizeForMatching(modelId);
+	return n.includes("claude") && (n.includes("opus45") || n.includes("opus46") || n.includes("sonnet45") || n.includes("sonnet46"));
+}
+function isContextEditingEnabled(modelId) {
+	return modelSupportsContextEditing(modelId) && state.contextEditingMode !== "off";
+}
+function modelHasAdaptiveThinking(resolvedModel) {
+	return resolvedModel?.capabilities?.supports?.adaptive_thinking === true;
+}
+function buildAnthropicBetaHeaders(modelId, resolvedModel) {
+	const headers = {};
+	const betaFeatures = [];
+	if (!modelHasAdaptiveThinking(resolvedModel)) betaFeatures.push("interleaved-thinking-2025-05-14");
+	if (isContextEditingEnabled(modelId)) betaFeatures.push("context-management-2025-06-27");
+	if (modelSupportsToolSearch(modelId)) betaFeatures.push("advanced-tool-use-2025-11-20");
+	if (betaFeatures.length > 0) headers["anthropic-beta"] = betaFeatures.join(",");
+	return headers;
+}
+const THINKING_KEEP_TURNS = 2;
+const TOOL_USE_TRIGGER_TYPE = "input_tokens";
+const TOOL_USE_TRIGGER_VALUE = 8e4;
+const TOOL_USE_KEEP_COUNT = 10;
+function buildContextManagement(mode, hasThinking) {
+	if (mode === "off") return void 0;
+	const edits = [];
+	if ((mode === "clear-thinking" || mode === "clear-both") && hasThinking) edits.push({
+		type: "clear_thinking_20251015",
+		keep: {
+			type: "thinking_turns",
+			value: Math.max(1, THINKING_KEEP_TURNS)
+		}
+	});
+	if (mode === "clear-tooluse" || mode === "clear-both") edits.push({
+		type: "clear_tool_uses_20250919",
+		trigger: {
+			type: TOOL_USE_TRIGGER_TYPE,
+			value: TOOL_USE_TRIGGER_VALUE
+		},
+		keep: {
+			type: "tool_uses",
+			value: TOOL_USE_KEEP_COUNT
+		}
+	});
+	return edits.length > 0 ? { edits } : void 0;
+}
+
+//#endregion
+//#region src/lib/anthropic/server-tool-filter.ts
+const SERVER_TOOL_TYPE_PREFIXES = [
+	"web_search_",
+	"web_fetch_",
+	"code_execution_",
+	"text_editor_",
+	"computer_",
+	"bash_"
+];
+/** 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");
+}
+/** Check if a content block is a server-side tool block */
+function isServerToolBlock(block) {
+	if (block.type === "server_tool_use") return true;
+	return isServerToolResultType(block.type);
+}
+/** Check if a tool's type field matches a known server tool prefix */
+function isServerToolType(type) {
+	if (!type) return false;
+	return SERVER_TOOL_TYPE_PREFIXES.some((prefix) => type.startsWith(prefix));
+}
+/** Log a single server tool block */
+function logServerToolBlock(block) {
+	if (block.type === "server_tool_use") {
+		consola.debug(`[ServerTool] server_tool_use: ${block.name}`);
+		return;
+	}
+	if (!isServerToolResultType(block.type)) return;
+	consola.debug(`[ServerTool] ${block.type}`);
+}
+/** Log all server tool blocks from a non-streaming response */
+function logServerToolBlocks(content) {
+	for (const block of content) logServerToolBlock(block);
+}
+/**
+* Creates a filter for server tool blocks in SSE streams.
+* Handles index remapping so block indices remain dense/sequential after filtering.
+* Always active — matching vscode-copilot-chat behavior.
+*/
+function createServerToolBlockFilter() {
+	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 (isServerToolBlock(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 server tool blocks from a non-streaming response */
+function filterServerToolBlocksFromResponse(response) {
+	const filtered = response.content.filter((block) => !isServerToolBlock(block));
+	if (filtered.length === response.content.length) return response;
+	return {
+		...response,
+		content: filtered
+	};
+}
+
 //#endregion
 //#region src/services/copilot/create-anthropic-messages.ts
 /**
@@ -6550,14 +6840,15 @@ const COPILOT_SUPPORTED_FIELDS = new Set([
 	"tools",
 	"tool_choice",
 	"thinking",
-	"service_tier"
+	"service_tier",
+	"context_management"
 ]);
 /**
 * Filter payload to only include fields supported by Copilot's Anthropic API.
 * This prevents errors like "Extra inputs are not permitted" for unsupported
 * fields like `output_config`.
 *
-* Also converts server-side tools (web_search, etc.) to custom tools.
+* Optionally strips server-side tools when state.stripServerTools is enabled.
 */
 function filterPayloadForCopilot(payload) {
 	const filtered = {};
@@ -6565,7 +6856,7 @@ function filterPayloadForCopilot(payload) {
 	for (const [key, value] of Object.entries(payload)) if (COPILOT_SUPPORTED_FIELDS.has(key)) filtered[key] = value;
 	else unsupportedFields.push(key);
 	if (unsupportedFields.length > 0) consola.debug(`[DirectAnthropic] Filtered unsupported fields: ${unsupportedFields.join(", ")}`);
-	if (filtered.tools) filtered.tools = convertServerToolsToCustom(filtered.tools);
+	if (filtered.tools) filtered.tools = stripServerToolsFromPayload(filtered.tools);
 	return filtered;
 }
 /**
@@ -6596,6 +6887,7 @@ async function createAnthropicMessages(payload, options) {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	let filteredPayload = filterPayloadForCopilot(payload);
 	filteredPayload = adjustMaxTokensForThinking(filteredPayload);
+	const resolvedModel = state.models?.data.find((m) => m.id === filteredPayload.model);
 	const enableVision = filteredPayload.messages.some((msg) => {
 		if (typeof msg.content === "string") return false;
 		return msg.content.some((block) => block.type === "image");
@@ -6609,6 +6901,16 @@ async function createAnthropicMessages(payload, options) {
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user"),
 		"anthropic-version": "2023-06-01"
 	};
+	const betaHeaders = buildAnthropicBetaHeaders(filteredPayload.model, resolvedModel);
+	Object.assign(headers, betaHeaders);
+	if (isContextEditingEnabled(filteredPayload.model)) {
+		const hasThinking = filteredPayload.thinking?.type === "enabled";
+		const cm = buildContextManagement(state.contextEditingMode, hasThinking);
+		if (cm) {
+			filteredPayload.context_management = cm;
+			consola.debug("[DirectAnthropic] Added context_management:", JSON.stringify(cm));
+		}
+	}
 	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
 	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
 		method: "POST",
@@ -6632,96 +6934,21 @@ async function createAnthropicMessages(payload, options) {
 	if (payload.stream) return events(response);
 	return await response.json();
 }
-const SERVER_TOOL_CONFIGS = {
-	web_search: {
-		description: "Search the web for current information. Returns web search results that can help answer questions about recent events, current data, or information that may have changed since your knowledge cutoff.",
-		input_schema: {
-			type: "object",
-			properties: { query: {
-				type: "string",
-				description: "The search query"
-			} },
-			required: ["query"]
-		}
-	},
-	web_fetch: {
-		description: "Fetch content from a URL. NOTE: This is a client-side tool - the client must fetch the URL and return the content.",
-		input_schema: {
-			type: "object",
-			properties: { url: {
-				type: "string",
-				description: "The URL to fetch"
-			} },
-			required: ["url"]
-		}
-	},
-	code_execution: {
-		description: "Execute code in a sandbox. NOTE: This is a client-side tool - the client must execute the code.",
-		input_schema: {
-			type: "object",
-			properties: {
-				code: {
-					type: "string",
-					description: "The code to execute"
-				},
-				language: {
-					type: "string",
-					description: "The programming language"
-				}
-			},
-			required: ["code"]
-		}
-	},
-	computer: {
-		description: "Control computer desktop. NOTE: This is a client-side tool - the client must handle computer control.",
-		input_schema: {
-			type: "object",
-			properties: { action: {
-				type: "string",
-				description: "The action to perform"
-			} },
-			required: ["action"]
-		}
-	}
-};
-/**
-* Check if a tool is a server-side tool that needs conversion.
-*/
-function getServerToolPrefix(tool) {
-	if (tool.type) {
-		for (const prefix of Object.keys(SERVER_TOOL_CONFIGS)) if (tool.type.startsWith(prefix)) return prefix;
-	}
-	return null;
-}
 /**
-* Convert server-side tools to custom tools, or pass them through unchanged.
-* This allows them to be passed to the API and handled by the client.
-*
-* Note: Server-side tools are only converted if state.rewriteAnthropicTools is enabled.
+* Strip server-side tools from the tools array when configured.
+* When state.stripServerTools is enabled, server tools are removed from the request.
+* When disabled (default), server tools are passed through unchanged.
 */
-function convertServerToolsToCustom(tools) {
-	if (!tools) return;
+function stripServerToolsFromPayload(tools) {
+	if (!tools) return void 0;
+	if (!state.stripServerTools) return tools;
 	const result = [];
 	for (const tool of tools) {
-		const serverToolPrefix = getServerToolPrefix(tool);
-		if (serverToolPrefix) {
-			const config = SERVER_TOOL_CONFIGS[serverToolPrefix];
-			if (!state.rewriteAnthropicTools) {
-				consola.debug(`[DirectAnthropic] Passing ${serverToolPrefix} through unchanged (use --rewrite-anthropic-tools to convert)`);
-				result.push(tool);
-				continue;
-			}
-			if (config.remove) {
-				consola.warn(`[DirectAnthropic] Removing unsupported server tool: ${tool.name}. Reason: ${config.removalReason}`);
-				continue;
-			}
-			consola.debug(`[DirectAnthropic] Converting server tool to custom: ${tool.name} (type: ${tool.type})`);
-			result.push({
-				name: tool.name,
-				description: config.description,
-				input_schema: config.input_schema
-			});
-		} else result.push(tool);
+		if (isServerToolType(tool.type)) {
+			consola.warn(`[DirectAnthropic] Stripping server tool: ${tool.name} (type: ${tool.type})`);
+			continue;
+		}
+		result.push(tool);
 	}
 	return result.length > 0 ? result : void 0;
 }
@@ -6816,9 +7043,6 @@ function createAnthropicStreamAccumulator() {
 		currentToolCall: null
 	};
 }
-function isServerToolResultType(type) {
-	return type !== "tool_result" && type.endsWith("_tool_result");
-}
 function processAnthropicEvent(event, acc) {
 	switch (event.type) {
 		case "content_block_delta":
@@ -7467,6 +7691,8 @@ function handleDirectAnthropicNonStreamingResponse(c, response, ctx, truncateRes
 	});
 	let finalResponse = response;
 	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToAnthropicResponse$1(response, createTruncationMarker$1(truncateResult));
+	logServerToolBlocks(finalResponse.content);
+	finalResponse = filterServerToolBlocksFromResponse(finalResponse);
 	return c.json(finalResponse);
 }
 /**
@@ -7498,6 +7724,7 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 	const { stream, response, anthropicPayload, ctx } = opts;
 	const acc = createAnthropicStreamAccumulator();
 	const checkRepetition = createStreamRepetitionChecker(`anthropic:${anthropicPayload.model}`);
+	const serverToolFilter = createServerToolBlockFilter();
 	try {
 		for await (const rawEvent of response) {
 			consola.debug("Direct Anthropic raw stream event:", JSON.stringify(rawEvent));
@@ -7511,10 +7738,13 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 				continue;
 			}
 			processAnthropicEvent(event, acc);
+			if (event.type === "content_block_start") logServerToolBlock(event.content_block);
 			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
+			const forwardData = serverToolFilter.rewriteEvent(event, rawEvent.data);
+			if (forwardData === null) continue;
 			await stream.writeSSE({
 				event: rawEvent.event || event.type,
-				data: rawEvent.data
+				data: forwardData
 			});
 		}
 		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
@@ -8032,6 +8262,38 @@ const handleItemId = (parsed, tracker) => {
 
 //#endregion
 //#region src/routes/responses/utils.ts
+const CALL_PREFIX = "call_";
+const FC_PREFIX = "fc_";
+/**
+* Normalize function call IDs in Responses API input.
+* Converts Chat Completions format `call_xxx` IDs to Responses format `fc_xxx` IDs
+* on function_call and function_call_output items.
+*/
+function normalizeCallIds(payload) {
+	if (typeof payload.input === "string") return payload;
+	let count = 0;
+	const input = payload.input.map((item) => {
+		if ("call_id" in item && typeof item.call_id === "string") {
+			const callId = item.call_id;
+			if (callId.startsWith(CALL_PREFIX)) {
+				count++;
+				return {
+					...item,
+					call_id: FC_PREFIX + callId.slice(5)
+				};
+			}
+		}
+		return item;
+	});
+	if (count > 0) {
+		consola.debug(`[Responses] Normalized ${count} call IDs (call_ → fc_)`);
+		return {
+			...payload,
+			input
+		};
+	}
+	return payload;
+}
 const getResponsesRequestOptions = (payload) => {
 	return {
 		vision: hasVisionInput(payload),
@@ -8182,7 +8444,8 @@ const TERMINAL_EVENTS = new Set([
 	"error"
 ]);
 const handleResponses = async (c) => {
-	const payload = await c.req.json();
+	let payload = await c.req.json();
+	if (state.normalizeResponsesCallIds) payload = normalizeCallIds(payload);
 	consola.debug("Responses request payload:", JSON.stringify(payload));
 	const trackingId = c.get("trackingId");
 	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
@@ -8461,7 +8724,8 @@ async function runServer(options) {
 	state.autoTruncate = options.autoTruncate;
 	state.compressToolResults = options.compressToolResults;
 	state.redirectAnthropic = options.redirectAnthropic;
-	state.rewriteAnthropicTools = options.rewriteAnthropicTools;
+	state.stripServerTools = options.stripServerTools;
+	state.contextEditingMode = options.contextEditing;
 	state.timezoneOffset = options.timezoneOffset;
 	if (options.rateLimit) initAdaptiveRateLimiter({
 		baseRetryIntervalSeconds: options.retryInterval,
@@ -8473,11 +8737,13 @@ async function runServer(options) {
 	if (!options.autoTruncate) consola.info("Auto-truncate disabled");
 	if (options.compressToolResults) consola.info("Tool result compression enabled");
 	if (options.redirectAnthropic) consola.info("Anthropic API redirect enabled (using OpenAI translation)");
-	if (!options.rewriteAnthropicTools) consola.info("Anthropic server-side tools rewrite disabled (passing through unchanged)");
+	if (options.stripServerTools) consola.info("Server-side tools will be stripped from requests");
+	if (options.contextEditing !== "off") consola.info(`Context editing mode: ${options.contextEditing}`);
 	initHistory(options.history, options.historyLimit);
 	if (options.history) {
 		const limitText = options.historyLimit === 0 ? "unlimited" : `max ${options.historyLimit}`;
 		consola.info(`History recording enabled (${limitText} entries)`);
+		startMemoryPressureMonitor();
 	}
 	if (options.posthogKey) {
 		initPostHog(options.posthogKey);
@@ -8648,10 +8914,15 @@ const start = defineCommand({
 			default: false,
 			description: "Redirect Anthropic models through OpenAI translation (instead of direct API)"
 		},
-		"no-rewrite-anthropic-tools": {
+		"strip-server-tools": {
 			type: "boolean",
 			default: false,
-			description: "Don't rewrite Anthropic server-side tools (web_search, etc.) to custom tool format"
+			description: "Strip Anthropic server-side tools (web_search, etc.) from requests"
+		},
+		"context-editing": {
+			type: "string",
+			default: "off",
+			description: "Context editing mode: off, clear-thinking, clear-tooluse, clear-both"
 		},
 		"timezone-offset": {
 			type: "string",
@@ -8684,7 +8955,8 @@ const start = defineCommand({
 			autoTruncate: !args["no-auto-truncate"],
 			compressToolResults: args["compress-tool-results"],
 			redirectAnthropic: args["redirect-anthropic"],
-			rewriteAnthropicTools: !args["no-rewrite-anthropic-tools"],
+			stripServerTools: args["strip-server-tools"],
+			contextEditing: args["context-editing"],
 			timezoneOffset: parseTimezoneOffset(args["timezone-offset"]),
 			posthogKey: args["posthog-key"]
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",