@dianshuv/copilot-api 0.11.0 → 0.11.1

package/dist/main.mjs

@@ -1348,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.11.0";
+var version = "0.11.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -8052,10 +8052,11 @@ function translateErrorToAnthropicErrorEvent(error) {
 //#endregion
 //#region src/routes/messages/tool-call-recovery.ts
 const ENVELOPE = String.raw`(?:<(?:antml:)?function_calls>|call)`;
-const INVOKE_BODY = String.raw`<(?:antml:)?invoke\s+name="[^"]+">[\s\S]*?</(?:antml:)?invoke>`;
-const LEAKED_REGION_RE = new RegExp(String.raw`(?:^|\n)[ \t]*` + ENVELOPE + String.raw`[ \t\n]*(?:` + INVOKE_BODY + String.raw`\s*)+(?:</(?:antml:)?function_calls>)?`, "g");
-const INCOMPLETE_LEAK_TAIL_RE = new RegExp(String.raw`(?:^|\n)[ \t]*` + ENVELOPE + String.raw`[ \t\n]*<(?:antml:)?invoke\b[\s\S]*$`);
-const LEAK_OPEN_RE = new RegExp(String.raw`(?:^|\n)[ \t]*` + ENVELOPE + String.raw`[ \t\n]*<(?:antml:)?invoke\s+name="`);
+const INVOKE_BODY = String.raw`<(?:antml:)?invoke\s+name="[^"]+">(?:(?!<(?:antml:)?invoke\b)[\s\S])*?</(?:antml:)?invoke>`;
+const LEAKED_REGION_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*(?:` + INVOKE_BODY + String.raw`\s*)+(?:</(?:antml:)?function_calls>)?|` + INVOKE_BODY + String.raw`)`, "g");
+const STARTS_WITH_ENVELOPE_RE = new RegExp(String.raw`^[ \t\n]*` + ENVELOPE);
+const INVOKE_OPENER_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\b[^\n>]*>?`, "g");
+const LEAK_OPEN_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\s+name="`, "g");
 const INVOKE_RE = /<(?:antml:)?invoke\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?invoke>/g;
 const PARAMETER_RE = /<(?:antml:)?parameter\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?parameter>/g;
 function coerceParamValue(raw) {
@@ -8081,19 +8082,43 @@ function parseRegionInvokes(region, knownTools) {
 	}
 	return calls;
 }
+const FENCE_DELIM_RE = /(?:^|\n)[ \t]*```/g;
+function insideFence(text, pos) {
+	let openAt = -1;
+	for (const m of text.matchAll(FENCE_DELIM_RE)) if (openAt === -1) {
+		if (m.index >= pos) break;
+		openAt = m.index;
+	} else if (m.index > pos) return true;
+	else openAt = -1;
+	return false;
+}
+function regionIsLeak(region, offset, fullText, knownTools) {
+	if (insideFence(fullText, offset)) return false;
+	if (STARTS_WITH_ENVELOPE_RE.test(region)) return true;
+	if (!knownTools) return false;
+	return parseRegionInvokes(region, knownTools).length > 0;
+}
 /**
 * Split assistant text into ordered segments — dropping leaked envelope markup
 * (and undeclared-tool invokes) while preserving the natural-language on either
 * side and the pre/tool/post ordering. Returns a single text segment when there
 * is no leak. Shared by both response recovery paths so they cannot diverge.
+*
+* `from` restricts the EMITTED window to `text.slice(from)` while still
+* classifying against the FULL `text` — so a streaming capture that started just
+* after an opening ``` fence still sees that fence (and the now-arrived closing
+* one) when deciding whether the region is documentation.
 */
-function recoverSegments(text, knownTools) {
+function recoverSegments(text, knownTools, from = 0) {
 	const segments = [];
-	let cursor = 0;
+	let cursor = from;
 	let sawRegion = false;
 	for (const region of text.matchAll(LEAKED_REGION_RE)) {
+		const idx = region.index;
+		if (idx < from) continue;
+		if (!regionIsLeak(region[0], idx, text, knownTools)) continue;
 		sawRegion = true;
-		const pre = text.slice(cursor, region.index);
+		const pre = text.slice(cursor, idx);
 		if (pre.trim() !== "") segments.push({
 			kind: "text",
 			text: pre
@@ -8102,11 +8127,11 @@ function recoverSegments(text, knownTools) {
 			kind: "tool",
 			call
 		});
-		cursor = region.index + region[0].length;
+		cursor = idx + region[0].length;
 	}
 	if (!sawRegion) return [{
 		kind: "text",
-		text
+		text: text.slice(from)
 	}];
 	const post = text.slice(cursor);
 	if (post.trim() !== "") segments.push({
@@ -8115,19 +8140,20 @@ function recoverSegments(text, knownTools) {
 	});
 	return segments;
 }
-/** True when `text` contains at least one complete, envelope-wrapped leak. */
-function containsLeakedToolCall(text) {
+/** True when `text` contains at least one real leak (see `regionIsLeak`). */
+function containsLeakedToolCall(text, knownTools) {
 	if (!text.includes("invoke")) return false;
-	for (const _region of text.matchAll(LEAKED_REGION_RE)) return true;
+	for (const region of text.matchAll(LEAKED_REGION_RE)) if (regionIsLeak(region[0], region.index, text, knownTools)) return true;
 	return false;
 }
 /**
-* Remove complete leaked tool-call regions from assistant text, preserving the
-* surrounding natural-language on both sides.
+* Remove real leaked tool-call regions from assistant text, preserving the
+* surrounding natural-language on both sides. Regions that are not leaks (an
+* envelope-less <invoke> that names no declared tool) round-trip untouched.
 */
-function stripLeakedToolCalls(text) {
+function stripLeakedToolCalls(text, knownTools) {
 	if (!text.includes("invoke")) return text;
-	const stripped = text.replaceAll(LEAKED_REGION_RE, "");
+	const stripped = text.replaceAll(LEAKED_REGION_RE, (match, offset) => regionIsLeak(match, offset, text, knownTools) ? "" : match);
 	if (stripped === text) return text;
 	return stripped.replace(/[ \t\n]+$/, "");
 }
@@ -8141,14 +8167,27 @@ function toolNameSet(tools) {
 	return new Set((tools ?? []).filter((tool) => !isServerToolType(tool.type)).map((tool) => tool.name));
 }
 const EMPTIED_ASSISTANT_PLACEHOLDER = "[malformed tool call removed by proxy]";
-function historyHasLeak(text) {
+const INVOKE_NAME_RE = /<(?:antml:)?invoke\s+name="([^"]+)"/;
+function findIncompleteLeakTail(text, knownTools) {
+	let last;
+	for (const m of text.matchAll(INVOKE_OPENER_RE)) last = m;
+	if (!last || last.index === void 0) return -1;
+	if (text.includes("</invoke>", last.index + last[0].length)) return -1;
+	if (insideFence(text, last.index)) return -1;
+	if (STARTS_WITH_ENVELOPE_RE.test(last[0])) return last.index;
+	if (!knownTools) return -1;
+	const name = INVOKE_NAME_RE.exec(last[0]);
+	return name && knownTools.has(name[1]) ? last.index : -1;
+}
+function historyHasLeak(text, knownTools) {
 	if (!text.includes("invoke")) return false;
-	return containsLeakedToolCall(text) || INCOMPLETE_LEAK_TAIL_RE.test(text);
+	return containsLeakedToolCall(text, knownTools) || findIncompleteLeakTail(text, knownTools) !== -1;
 }
-function scrubHistoryText(text) {
-	const stripped = stripLeakedToolCalls(text);
-	const final = stripped.replace(INCOMPLETE_LEAK_TAIL_RE, "");
-	return final === stripped ? stripped : final.replace(/[ \t\n]+$/, "");
+function scrubHistoryText(text, knownTools) {
+	const stripped = stripLeakedToolCalls(text, knownTools);
+	const tailStart = findIncompleteLeakTail(stripped, knownTools);
+	if (tailStart === -1) return stripped;
+	return stripped.slice(0, tailStart).replace(/[ \t\n]+$/, "");
 }
 /**
 * Request-side de-poison. Strips leaked tool-call markup (complete and truncated)
@@ -8159,6 +8198,7 @@ function scrubHistoryText(text) {
 */
 function dePoisonAssistantMessages(payload) {
 	if (!payload.messages.some((m) => m.role === "assistant" && (typeof m.content === "string" ? m.content.includes("invoke") : m.content.some((b) => b.type === "text" && b.text.includes("invoke"))))) return payload;
+	const knownTools = toolNameSet(payload.tools);
 	let changed = false;
 	const messages = [];
 	for (const msg of payload.messages) {
@@ -8167,26 +8207,26 @@ function dePoisonAssistantMessages(payload) {
 			continue;
 		}
 		if (typeof msg.content === "string") {
-			if (!historyHasLeak(msg.content)) {
+			if (!historyHasLeak(msg.content, knownTools)) {
 				messages.push(msg);
 				continue;
 			}
 			changed = true;
-			const cleaned = scrubHistoryText(msg.content);
+			const cleaned = scrubHistoryText(msg.content, knownTools);
 			messages.push({
 				...msg,
 				content: cleaned.trim() === "" ? EMPTIED_ASSISTANT_PLACEHOLDER : cleaned
 			});
 			continue;
 		}
-		if (!msg.content.some((b) => b.type === "text" && historyHasLeak(b.text))) {
+		if (!msg.content.some((b) => b.type === "text" && historyHasLeak(b.text, knownTools))) {
 			messages.push(msg);
 			continue;
 		}
 		changed = true;
 		const content = msg.content.flatMap((b) => {
-			if (b.type !== "text" || !historyHasLeak(b.text)) return [b];
-			const cleaned = scrubHistoryText(b.text);
+			if (b.type !== "text" || !historyHasLeak(b.text, knownTools)) return [b];
+			const cleaned = scrubHistoryText(b.text, knownTools);
 			return cleaned.trim() === "" ? [] : [{
 				...b,
 				text: cleaned
@@ -8222,7 +8262,7 @@ function recoverLeakedToolCallsInResponse(response, knownTools) {
 	let recoveredCall = false;
 	const content = [];
 	for (const block of response.content) {
-		if (block.type !== "text" || !containsLeakedToolCall(block.text)) {
+		if (block.type !== "text" || !containsLeakedToolCall(block.text, knownTools)) {
 			content.push(block);
 			continue;
 		}
@@ -8328,12 +8368,16 @@ var LeakedToolCallStreamRecovery = class {
 			if (t.buffer.length - t.captureStart > MAX_CAPTURE) return this.abandonCapture(t);
 			return [];
 		}
-		if (!t.abandoned) {
-			const open = LEAK_OPEN_RE.exec(t.buffer);
-			if (open) return this.beginCapture(t, open.index);
+		if (!t.abandoned && t.buffer.includes("invoke")) {
+			for (const open of t.buffer.matchAll(LEAK_OPEN_RE)) if (this.shouldArmCapture(open[0], t.buffer, open.index)) return this.beginCapture(t, open.index);
 		}
 		return this.flushSafe(t);
 	}
+	shouldArmCapture(opener, buffer, openerIndex) {
+		if (insideFence(buffer, openerIndex)) return false;
+		if (STARTS_WITH_ENVELOPE_RE.test(opener)) return true;
+		return this.knownTools !== void 0 && this.knownTools.size > 0;
+	}
 	onBlockStop(event, rawData) {
 		const t = this.text;
 		if (!t || event.index !== t.upstreamIndex) return [this.reindexed(event, rawData)];
@@ -8479,7 +8523,7 @@ var LeakedToolCallStreamRecovery = class {
 		return events;
 	}
 	finishCapture(t) {
-		const segments = recoverSegments(t.buffer.slice(t.captureStart), this.knownTools);
+		const segments = recoverSegments(t.buffer, this.knownTools, t.captureStart);
 		const hasTool = segments.some((s) => s.kind === "tool");
 		const base = t.upstreamIndex + this.extraBlocks;
 		const events = [];

package/package.json

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