@vanillagreen/pi-claude-bridge 1.2.0 → 1.4.0

package/src/models.ts

@@ -2,7 +2,7 @@
 // `resolveModelId` returns the first partial match, so `opus` resolves to the first-listed opus entry.
 // Extracted from index.ts so tests can import without activating the extension.
 
-export const MODEL_IDS_IN_ORDER = ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
+export const MODEL_IDS_IN_ORDER = ["claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
 
 // Project pi-ai's model entries down to the fields pi's registerProvider expects,
 // and keep MODEL_IDS_IN_ORDER ordering. IDs missing from pi-ai are silently dropped.

package/src/query-state.ts

@@ -14,6 +14,73 @@ export interface PendingToolCall {
 	resolve: (result: McpResult) => void;
 }
 
+export interface TurnToolCallRecord {
+	id: string;
+	toolName: string;
+	arguments: Record<string, unknown>;
+}
+
+export interface ClaimedToolCall {
+	toolCallId?: string;
+	match: "tool-args" | "tool-name" | "none";
+	ambiguous: boolean;
+	available: number;
+}
+
+export interface ToolResultProgress {
+	expectedIds: string[];
+	deliveredIds: string[];
+	resolvedIds: string[];
+	waitingIds: string[];
+	queuedIds: string[];
+	unmatchedResultIds: string[];
+	missingDeliveredIds: string[];
+	unresolvedIds: string[];
+	toolNames: Array<{ name: string; count: number }>;
+	expectedCount: number;
+	deliveredCount: number;
+	resolvedCount: number;
+	waitingCount: number;
+	queuedCount: number;
+	unmatchedResultCount: number;
+}
+
+function normalizeForCompare(value: unknown): unknown {
+	if (Array.isArray(value)) return value.map(normalizeForCompare);
+	if (value && typeof value === "object") {
+		const out: Record<string, unknown> = {};
+		for (const key of Object.keys(value as Record<string, unknown>).sort()) {
+			const child = (value as Record<string, unknown>)[key];
+			if (child !== undefined) out[key] = normalizeForCompare(child);
+		}
+		return out;
+	}
+	return value;
+}
+
+function argsKey(value: unknown): string {
+	return JSON.stringify(normalizeForCompare(value ?? {}));
+}
+
+function sameArgs(left: unknown, right: unknown): boolean {
+	return argsKey(left) === argsKey(right);
+}
+
+function hasRecordedArgs(args: Record<string, unknown> | undefined): boolean {
+	return Object.keys(args ?? {}).length > 0;
+}
+
+function unique(values: Iterable<string | undefined>): string[] {
+	const out: string[] = [];
+	const seen = new Set<string>();
+	for (const value of values) {
+		if (!value || seen.has(value)) continue;
+		seen.add(value);
+		out.push(value);
+	}
+	return out;
+}
+
 export class QueryContext {
 	// Query-scoped (fully isolated per query)
 	activeQuery: unknown | null = null;
@@ -22,8 +89,14 @@ export class QueryContext {
 	pendingToolCalls = new Map<string, PendingToolCall>();
 	pendingResults = new Map<string, McpResult>();
 	turnToolCallIds: string[] = [];
-	nextHandlerIdx = 0;
+	turnToolCalls: TurnToolCallRecord[] = [];
+	claimedToolCallIds = new Set<string>();
+	deliveredToolResultIds = new Set<string>();
+	resolvedToolResultIds = new Set<string>();
+	unmatchedToolResultIds = new Set<string>();
+	reportedToolResultMismatch = false;
 	deferredUserMessages: string[] = [];
+	handledTerminalError = false;
 
 	// Per-turn (reset together)
 	turnOutput: AssistantMessage | null = null;
@@ -47,8 +120,119 @@ export class QueryContext {
 		this.turnStarted = false;
 		this.turnSawStreamEvent = false;
 		this.turnSawToolCall = false;
-		// turnToolCallIds and nextHandlerIdx are NOT reset — they persist across
-		// tool-result delivery callbacks within the same assistant message.
+		this.handledTerminalError = false;
+		// Tool-call tracking is NOT reset here — it persists across the
+		// tool-result delivery callback for the same assistant message. New
+		// assistant messages call resetToolTracking() explicitly.
+	}
+
+	resetToolTracking(): void {
+		this.turnToolCallIds = [];
+		this.turnToolCalls = [];
+		this.claimedToolCallIds.clear();
+		this.deliveredToolResultIds.clear();
+		this.resolvedToolResultIds.clear();
+		this.unmatchedToolResultIds.clear();
+		this.reportedToolResultMismatch = false;
+	}
+
+	recordToolCall(id: string | undefined, toolName: string, args: Record<string, unknown> = {}): void {
+		if (!id) return;
+		if (!this.turnToolCallIds.includes(id)) this.turnToolCallIds.push(id);
+		const existing = this.turnToolCalls.find((call) => call.id === id);
+		if (existing) {
+			existing.toolName = toolName;
+			existing.arguments = args;
+			return;
+		}
+		this.turnToolCalls.push({ id, toolName, arguments: args });
+	}
+
+	updateToolCallArgs(id: string | undefined, args: Record<string, unknown>): void {
+		if (!id) return;
+		const existing = this.turnToolCalls.find((call) => call.id === id);
+		if (existing) existing.arguments = args;
+	}
+
+	hasRecordedToolCall(id: string | undefined): boolean {
+		return Boolean(id && (this.turnToolCallIds.includes(id) || this.turnToolCalls.some((call) => call.id === id)));
+	}
+
+	claimToolCall(toolName: string, args: Record<string, unknown> = {}): ClaimedToolCall {
+		const unclaimed = this.turnToolCalls.filter((call) => !this.claimedToolCallIds.has(call.id));
+		const byName = unclaimed.filter((call) => call.toolName === toolName);
+		const exact = byName.filter((call) => sameArgs(call.arguments, args));
+		let chosen: TurnToolCallRecord | undefined;
+		let match: ClaimedToolCall["match"] = "none";
+		let ambiguous = false;
+
+		if (exact.length > 0) {
+			chosen = exact[0];
+			match = "tool-args";
+			ambiguous = exact.length > 1;
+		} else if (byName.length === 1 && !hasRecordedArgs(byName[0].arguments)) {
+			// The SDK can invoke the MCP handler after content_block_start but
+			// before input_json_delta/content_block_stop finalizes arguments.
+			// Falling back to the sole same-name, argument-less call preserves that
+			// race without ever claiming a different tool type.
+			chosen = byName[0];
+			match = "tool-name";
+		}
+
+		if (!chosen) return { match: "none", ambiguous: false, available: unclaimed.length };
+		this.claimedToolCallIds.add(chosen.id);
+		return { toolCallId: chosen.id, match, ambiguous, available: unclaimed.length };
+	}
+
+	markToolResultDelivered(id: string | undefined): void {
+		if (id) this.deliveredToolResultIds.add(id);
+	}
+
+	markToolResultResolved(id: string | undefined): void {
+		if (id) this.resolvedToolResultIds.add(id);
+	}
+
+	markToolResultUnmatched(id: string | undefined): void {
+		if (id) this.unmatchedToolResultIds.add(id);
+	}
+
+	toolResultProgress(): ToolResultProgress {
+		const expectedIds = unique([
+			...this.turnToolCalls.map((call) => call.id),
+			...this.turnToolCallIds,
+		]);
+		const deliveredIds = unique(this.deliveredToolResultIds);
+		const resolvedIds = unique(this.resolvedToolResultIds);
+		const waitingIds = unique(this.pendingToolCalls.keys());
+		const queuedIds = unique(this.pendingResults.keys());
+		const unmatchedResultIds = unique(this.unmatchedToolResultIds);
+		const missingDeliveredIds = expectedIds.filter((id) => !this.deliveredToolResultIds.has(id));
+		const unresolvedIds = expectedIds.filter((id) => !this.resolvedToolResultIds.has(id));
+		const affectedIds = new Set([...missingDeliveredIds, ...unresolvedIds, ...waitingIds, ...queuedIds, ...unmatchedResultIds]);
+		const counts = new Map<string, number>();
+		for (const call of this.turnToolCalls) {
+			if (affectedIds.size > 0 && !affectedIds.has(call.id)) continue;
+			counts.set(call.toolName, (counts.get(call.toolName) ?? 0) + 1);
+		}
+		return {
+			expectedIds,
+			deliveredIds,
+			resolvedIds,
+			waitingIds,
+			queuedIds,
+			unmatchedResultIds,
+			missingDeliveredIds,
+			unresolvedIds,
+			toolNames: [...counts.entries()]
+				.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+				.map(([name, count]) => ({ name, count })),
+			expectedCount: expectedIds.length,
+			deliveredCount: deliveredIds.length,
+			resolvedCount: resolvedIds.length,
+			waitingCount: waitingIds.length,
+			queuedCount: queuedIds.length,
+			unmatchedResultCount: unmatchedResultIds.length,
+		};
 	}
 }
 

package/src/tool-pairing-audit.ts

@@ -0,0 +1,61 @@
+// Detect missing assistant tool_use ↔ user tool_result pairs before cc-session-io
+// repairs them with synthetic "[no tool result recorded]" blocks.
+// Kept pure so tests can exercise the exact audit without activating Pi.
+
+export interface MissingToolResult {
+	id: string;
+	toolName: string;
+	assistantIndex: number;
+	userIndex: number | null;
+}
+
+function contentBlocks(content: unknown): Array<Record<string, any>> {
+	return Array.isArray(content) ? content.filter((block): block is Record<string, any> => Boolean(block && typeof block === "object")) : [];
+}
+
+function toolUses(content: unknown): Array<{ id: string; name: string }> {
+	return contentBlocks(content)
+		.filter((block) => block.type === "tool_use" && typeof block.id === "string")
+		.map((block) => ({ id: block.id, name: typeof block.name === "string" && block.name ? block.name : "unknown" }));
+}
+
+function toolResultIds(content: unknown): Set<string> {
+	const ids = new Set<string>();
+	for (const block of contentBlocks(content)) {
+		if (block.type === "tool_result" && typeof block.tool_use_id === "string") ids.add(block.tool_use_id);
+	}
+	return ids;
+}
+
+/**
+ * Anthropic history requires an assistant message containing tool_use blocks to
+ * be followed by a user message containing matching tool_result blocks. Return
+ * every tool_use that would force repairToolPairing to synthesize a result.
+ */
+export function findUnpairedToolUses(messages: Array<{ role?: string; content?: unknown }>): MissingToolResult[] {
+	const missing: MissingToolResult[] = [];
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg?.role !== "assistant") continue;
+		const uses = toolUses(msg.content);
+		if (uses.length === 0) continue;
+
+		const next = messages[i + 1];
+		const nextUserIndex = next?.role === "user" ? i + 1 : null;
+		const resultIds = nextUserIndex == null ? new Set<string>() : toolResultIds(next.content);
+		for (const use of uses) {
+			if (!resultIds.has(use.id)) {
+				missing.push({ id: use.id, toolName: use.name, assistantIndex: i, userIndex: nextUserIndex });
+			}
+		}
+	}
+	return missing;
+}
+
+export function summarizeMissingToolNames(missing: MissingToolResult[]): Array<{ name: string; count: number }> {
+	const counts = new Map<string, number>();
+	for (const item of missing) counts.set(item.toolName, (counts.get(item.toolName) ?? 0) + 1);
+	return [...counts.entries()]
+		.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+		.map(([name, count]) => ({ name, count }));
+}