@vanillagreen/pi-claude-bridge 4.0.1 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-claude-bridge",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "Pi provider bridge that runs Claude Code through the Claude Agent SDK, with opt-in forwarding for Pi prompt context.",
   "type": "module",
   "keywords": [
@@ -145,13 +145,14 @@
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",
     "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/node": "^24.3.0",
     "esbuild": "^0.28.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3"
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node22 --outfile=bundle/index.js --external:@earendil-works/pi-ai --external:@earendil-works/pi-coding-agent && esbuild src/connector-inventory.ts --bundle --platform=node --format=esm --target=node22 --outfile=bundle/connector-inventory.js",
+    "build": "esbuild src/index.ts --bundle --preserve-symlinks --platform=node --format=esm --target=node22 --outfile=bundle/index.js --external:@earendil-works/pi-ai --external:@earendil-works/pi-coding-agent && esbuild src/connector-inventory.ts --bundle --preserve-symlinks --platform=node --format=esm --target=node22 --outfile=bundle/connector-inventory.js",
     "prepack": "npm run build",
     "test:unit": "node --import tsx --test tests/unit-*.mjs",
     "test:ci": "npm run build && npm run test:unit",

package/src/assistant-stream.ts

@@ -159,6 +159,7 @@ export function reapStaleQueuedResults(c: QueryContext): void {
 	diagDump("stale_queued_tool_results_parked", { count: stale.length, stale });
 	appendIntegrityEntry("stale_queued_tool_results_parked", { count: stale.length, stale });
 	safeNotify(
+		`queued-results-parked=${JSON.stringify({ count: stale.length, tools: names })}\n` +
 		`Claude bridge: parked ${stale.length} early tool result(s) whose handler has not arrived (${names.slice(0, 6).join(", ")}${names.length > 6 ? ", …" : ""}). ` +
 		`A late handler can still consume them.`,
 		"warning",
@@ -345,7 +346,7 @@ export function processStreamEvent(
 		}
 		if (event.content_block?.type === "tool_use" && !isPiDispatchable(event.content_block.name, customToolNameToPi)) {
 			c.suppressedStreamIndexes.add(event.index);
-			if (isForeignMcpTool(event.content_block.name)) c.markOutputCommitted();
+			if (isForeignMcpTool(event.content_block.name)) c.noteForeignMcpToolCall(event.content_block.id, event.content_block.name);
 			debug(`processStreamEvent: non-dispatchable tool ${event.content_block.name} [${event.content_block.id}] — not mirrored as a Pi tool call`);
 			return;
 		}
@@ -513,7 +514,7 @@ function appendMissingToolUsesFromAssistant(
 			continue;
 		}
 		if (!isPiDispatchable(block.name, customToolNameToPi)) {
-			if (isForeignMcpTool(block.name)) c.markOutputCommitted();
+			if (isForeignMcpTool(block.name)) c.noteForeignMcpToolCall(block.id, block.name);
 			debug(`assistant message: non-dispatchable tool ${block.name} [${block.id}] — not mirrored as a Pi tool call`);
 			continue;
 		}
@@ -670,7 +671,7 @@ export function processAssistantMessage(message: SDKMessage, model: Model<any>,
 				continue;
 			}
 			if (!isPiDispatchable(block.name, customToolNameToPi)) {
-				if (isForeignMcpTool(block.name)) c.markOutputCommitted();
+				if (isForeignMcpTool(block.name)) c.noteForeignMcpToolCall(block.id, block.name);
 				debug(`processAssistantMessage fallback: non-dispatchable tool ${block.name} [${block.id}] — not mirrored as a Pi tool call`);
 				continue;
 			}

package/src/billing-identity.ts

@@ -0,0 +1,116 @@
+// The Anthropic login the bridge's child query actually authenticated as,
+// published for other extensions to read.
+//
+// WHY a published surface rather than letting a reader resolve
+// CLAUDE_CONFIG_DIR for itself: that directory names the login only when the
+// child used one. The bridge also accepts an API key and the Bedrock, Vertex,
+// Foundry, Anthropic-AWS and Mantle backends (auth-presence.ts), and it passes
+// those environment values straight to the child (query-options.ts). A
+// companion account router may additionally hand each request its own profile
+// and rotate it while the process environment never changes
+// (account-router.ts). Only the SDK's own accountInfo() names the identity a
+// request ran under, so the rule for reading it lives here once instead of in
+// every consumer.
+//
+// SECURITY: this module holds one email per live request lane in memory and
+// never logs it.
+
+import type { AccountInfo } from "@anthropic-ai/claude-agent-sdk";
+import { currentRequestLaneId } from "./request-lane.js";
+
+export const CLAUDE_BILLING_IDENTITY_SYMBOL = Symbol.for("kendex.pi.claude-bridge.billing-identity.v1");
+
+/** Anthropic's own login backend. Every other `apiProvider` value is an
+ *  external credential whose payer this bridge cannot name. */
+const FIRST_PARTY = "firstParty";
+
+export interface ClaudeBillingIdentityV1 {
+	version: 1;
+	/** The Anthropic login email of the latest child attempt in `sessionId`, or
+	 *  undefined when that attempt authenticated with an API key or a
+	 *  third-party backend, has not reported yet, or its probe failed. A
+	 *  consumer passes the visible Pi session id, displays the result, and
+	 *  derives nothing further. */
+	currentLoginEmail(sessionId: string | undefined): string | undefined;
+}
+
+interface BillingIdentityStore extends ClaudeBillingIdentityV1 {
+	beginAttempt(sessionId: string | undefined): (info: AccountInfo) => void;
+	deleteLane(sessionId: string | undefined): void;
+	clear(): void;
+}
+
+interface BillingIdentityLane {
+	attempt: symbol;
+	loginEmail?: string;
+}
+
+const BILLING_IDENTITY_LANES_SYMBOL = Symbol.for("kendex.pi.claude-bridge.billing-identity-lanes.v1");
+
+function sharedBillingIdentityLanes(): Map<string | undefined, BillingIdentityLane> {
+	const host = globalThis as Record<symbol, unknown>;
+	let lanes = host[BILLING_IDENTITY_LANES_SYMBOL] as Map<string | undefined, BillingIdentityLane> | undefined;
+	if (!lanes) {
+		lanes = new Map();
+		host[BILLING_IDENTITY_LANES_SYMBOL] = lanes;
+	}
+	return lanes;
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+/** The login email an `accountInfo()` result confirms, or undefined when it
+ *  confirms none. An API key is rejected even under the first-party backend:
+ *  the key's owner is not the signed-in login, and `apiKeySource` is how the
+ *  SDK reports that a key was used. */
+export function loginEmailFrom(info: AccountInfo): string | undefined {
+	if (info.apiProvider !== FIRST_PARTY) return undefined;
+	if (nonEmpty(info.apiKeySource)) return undefined;
+	return nonEmpty(info.email);
+}
+
+export function makeBillingIdentityStore(
+	lanes: Map<string | undefined, BillingIdentityLane> = new Map(),
+): BillingIdentityStore {
+	return {
+		version: 1,
+		currentLoginEmail: (sessionId) => lanes.get(sessionId)?.loginEmail,
+		beginAttempt: (sessionId) => {
+			const attempt = Symbol("billing-identity-attempt");
+			lanes.set(sessionId, { attempt });
+			return (info) => {
+				const current = lanes.get(sessionId);
+				if (current?.attempt !== attempt) return;
+				lanes.set(sessionId, { attempt, loginEmail: loginEmailFrom(info) });
+			};
+		},
+		deleteLane: (sessionId) => lanes.delete(sessionId),
+		clear: () => lanes.clear(),
+	};
+}
+
+export const BRIDGE_BILLING_IDENTITY = makeBillingIdentityStore(sharedBillingIdentityLanes());
+
+/** Start the billing probe for the current request lane. Starting clears that
+ *  lane, so a rejected probe cannot leave the previous attempt's identity.
+ *  The returned recorder ignores an older probe that settles after a newer
+ *  attempt in the same lane. */
+export function beginBillingIdentityAttempt(): (info: AccountInfo) => void {
+	return BRIDGE_BILLING_IDENTITY.beginAttempt(currentRequestLaneId());
+}
+
+/** Remove one completed Pi session without changing concurrent sessions. */
+export function deleteBillingIdentityLane(sessionId: string | undefined): void {
+	BRIDGE_BILLING_IDENTITY.deleteLane(sessionId);
+}
+
+/** Read the published store, or undefined when no bridge is loaded. Never
+ *  installs one: a consumer that created its own would answer for a bridge
+ *  that is not running. */
+export function resolveClaudeBillingIdentity(): ClaudeBillingIdentityV1 | undefined {
+	const host = globalThis as unknown as Record<PropertyKey, unknown>;
+	const candidate = host[CLAUDE_BILLING_IDENTITY_SYMBOL] as ClaudeBillingIdentityV1 | undefined;
+	return candidate?.version === 1 && typeof candidate.currentLoginEmail === "function" ? candidate : undefined;
+}

package/src/bridge-state.ts

@@ -1,5 +1,5 @@
 import { type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
-import { debug, diagDump, diagGuidance } from "./debug.js";
+import { DEBUG, debug, diagDump, diagGuidance, diagLogPath } from "./debug.js";
 import { type QueryContext } from "./query-state.js";
 import { currentRequestLaneId } from "./request-lane.js";
 import { summarizeMissingToolNames, type MissingToolResult } from "./tool-pairing-audit.js";
@@ -35,14 +35,16 @@ export interface SessionState {
 	// navigation) or after an abort left the JSONL in an indeterminate state.
 	// REBUILD wipes and rewrites the file to match pi's current history.
 	needsRebuild?: boolean;
-	// Set ONLY after an abort. The killed CC subprocess may still be flushing
-	// a late "[Request interrupted by user]" record to the session JSONL.
+	// Set whenever a CC subprocess was killed and may still be flushing to its
+	// session JSONL: after an abort, whose late "[Request interrupted by user]"
+	// record is the classic case, and at a history replacement (compact, tree
+	// navigation) that stops an ACTIVE query to restart it on pi's new context.
 	// Reusing the same sessionId/path would race that orphan write into our
 	// fresh file and break CC's parent-uuid chain on the next resume. When
 	// this flag is set, REBUILD takes a fresh UUID and skips deleteSession
-	// so the orphan writes land on a dead inode. Compact/tree do NOT set
-	// this — there's no concurrent CC writer during those events, so
-	// in-place rebuild (preserve UUID, deleteSession + createSession) is safe.
+	// so the orphan writes land on a dead inode. A compact or tree event with
+	// no active query kills nothing, so it leaves this unset and rebuilds in
+	// place (preserve UUID, deleteSession + createSession).
 	forceRotate?: boolean;
 }
 
@@ -284,6 +286,7 @@ export function reportToolResultMismatch(
 			unmatchedResultIds: progress.unmatchedResultIds,
 		});
 		safeNotify(
+			`tool-result-mismatch=${JSON.stringify({ delivered: progress.deliveredCount, expected: progress.expectedCount, resolved: progress.resolvedCount, diagnostic: DEBUG ? diagLogPath() : "CLAUDE_BRIDGE_DEBUG=1" })}\n` +
 			`Claude bridge: tool result delivery interrupted during ${reason}; ` +
 			`delivered ${progress.deliveredCount}/${progress.expectedCount}, resolved ${progress.resolvedCount}/${progress.expectedCount}, ` +
 			`waiting=${progress.waitingCount}, queued=${progress.queuedCount}, unmatched=${progress.unmatchedResultCount}` +

package/src/connector-audit.ts

@@ -160,10 +160,12 @@ export function recordConnectorCallResult(
 	isError: boolean,
 	byteSize: number | undefined,
 ): boolean {
-	const pending = queryCtx.connectorCallAudit.get(toolUseId);
+	const pending = queryCtx.childSideCalls.get(toolUseId);
 	if (pending?.recorded) return false;
 	const childSessionId = pending?.childSessionId ?? queryCtx.childSessionId;
-	queryCtx.connectorCallAudit.set(toolUseId, { ...pending, name, childSessionId, recorded: true });
+	// Reached only for a child-executed connector result, so an entry this call
+	// never saw noted is a connector's.
+	queryCtx.childSideCalls.set(toolUseId, { ...pending, kind: pending?.kind ?? "connector", name, childSessionId, recorded: true });
 	return appendConnectorCallAudit({
 		name,
 		toolUseId,
@@ -183,9 +185,11 @@ export function recordConnectorCallResult(
  */
 export function flushConnectorCallAudit(queryCtx: QueryContext, reason: ToolCallDrainCause): number {
 	let appended = 0;
-	for (const [toolUseId, state] of queryCtx.connectorCallAudit) {
-		if (state.recorded) continue;
-		queryCtx.connectorCallAudit.set(toolUseId, { ...state, recorded: true });
+	for (const [toolUseId, state] of queryCtx.childSideCalls) {
+		// Foreign MCP calls share the map but not the trail: its entries are
+		// `claude-bridge-connector-call` records naming a claude.ai connector.
+		if (state.recorded || state.kind !== "connector") continue;
+		queryCtx.childSideCalls.set(toolUseId, { ...state, recorded: true });
 		const childSessionId = state.childSessionId ?? queryCtx.childSessionId;
 		if (appendConnectorCallAudit({
 			name: state.name,

package/src/connector-inventory.ts

@@ -244,8 +244,8 @@ export async function listAccountConnectors(deps: ListConnectorsDeps): Promise<C
 	// fetch/proxy layer is free to put the request headers — and therefore the
 	// bearer token — into the message it throws, and that message would otherwise
 	// land in a reason string that callers log.
-	const fail = (reason: string): ConnectorInventory =>
-		({ ok: false, complete: false, reason: redactSecret(reason, credentials.accessToken) });
+	const fail = (key: string, value: string | number, reason: string): ConnectorInventory =>
+		({ ok: false, complete: false, reason: redactSecret(`${key}=${JSON.stringify(value)}\n${reason}`, credentials.accessToken) });
 
 	let response: Response;
 	try {
@@ -260,32 +260,32 @@ export async function listAccountConnectors(deps: ListConnectorsDeps): Promise<C
 			signal,
 		});
 	} catch (error) {
-		return fail(`connector list request failed: ${errorText(error)}`);
+		return fail("connector-request", "transport", `connector list request failed: ${errorText(error)}`);
 	}
 
 	let bodyText: string;
 	try {
 		bodyText = await response.text();
 	} catch (error) {
-		return fail(`connector list response unreadable: ${errorText(error)}`);
+		return fail("connector-response", "unreadable", `connector list response unreadable: ${errorText(error)}`);
 	}
 
 	if (!response.ok) {
-		return fail(`connector list returned HTTP ${response.status}${apiErrorSuffix(bodyText)}`);
+		return fail("connector-http", response.status, `connector list returned HTTP ${response.status}${apiErrorSuffix(bodyText)}`);
 	}
 
 	let parsed: Json;
 	try {
 		parsed = JSON.parse(bodyText) as Json;
 	} catch {
-		return fail("connector list returned a non-JSON body");
+		return fail("connector-json", "invalid", "connector list returned a non-JSON body");
 	}
 
 	// A missing/!Array `results` is a protocol change, not an empty account. Treat
 	// it as failure — reporting "no connectors" here would recreate exactly the
 	// silent-wrong-answer failure this module exists to remove.
 	if (!Array.isArray(parsed?.results)) {
-		return fail("connector list response had no results array");
+		return fail("connector-results", "not-array", "connector list response had no results array");
 	}
 
 	const connectors: ConnectorEntry[] = [];
@@ -296,7 +296,7 @@ export async function listAccountConnectors(deps: ListConnectorsDeps): Promise<C
 		// so silently keeping it would understate the inventory in a way the
 		// caller could not detect. Fail instead.
 		if (!name) {
-			return fail("connector list contained an entry with no name");
+			return fail("connector-name", connectors.length, "connector list contained an entry with no name");
 		}
 		connectors.push({
 			name,

package/src/connectors.ts

@@ -517,6 +517,7 @@ function connectorWriteDenyOutput(toolName: string) {
 			hookEventName: "PreToolUse" as const,
 			permissionDecision: "deny" as const,
 			permissionDecisionReason:
+				`connector-write-denied=${JSON.stringify(toolName)}\n` +
 				`Connector write tool "${toolName}" is blocked in read-only connector mode. ` +
 				`Connector writes must go through the host application's gated approval flow.`,
 		},

package/src/consume-query.ts

@@ -3,7 +3,7 @@
 // generator and pushes events into the query's captured Pi stream.
 
 import { type Model } from "@earendil-works/pi-ai";
-import { type query } from "@anthropic-ai/claude-agent-sdk";
+import { type AccountInfo, type query } from "@anthropic-ai/claude-agent-sdk";
 import {
 	classifyClaudeFailure,
 	rateLimitResetFromInfo,
@@ -88,6 +88,7 @@ export async function consumeQuery(
 	model: Model<any>,
 	bridgeConfig: Config,
 	wasAborted: () => boolean,
+	recordBillingIdentity: (info: AccountInfo) => void,
 	account?: ClaudeAccountRoute,
 	router?: ClaudeAccountRouterV1,
 	// Mirror of the held failure for the caller's .catch: the SDK iterator can
@@ -100,6 +101,7 @@ export async function consumeQuery(
 	let capturedSessionId: string | undefined;
 	let failure: ClaudeAttemptFailure | undefined;
 	let accountProbe: Promise<void> | undefined;
+	let accountInfoProbe: Promise<AccountInfo> | undefined;
 	const holdFailure = (next: ClaudeAttemptFailure | undefined): void => {
 		failure = next;
 		if (attemptFailureBox) attemptFailureBox.failure = next;
@@ -216,9 +218,22 @@ export async function consumeQuery(
 					// from the teardown flush, which runs outside this function's scope.
 					queryCtx.childSessionId = capturedSessionId;
 					noteFastModeDisabledReason(message, bridgeConfig);
+					// Which login this child authenticated as is published for other
+					// extensions, for every child rather than only a routed one:
+					// an unrouted child is the common case and its identity is
+					// just as unknowable from outside the SDK. Nothing waits for
+					// it, so it stays off the turn's critical path. The call sits
+					// in an async IIFE so a synchronous throw arrives as a
+					// rejection the debug line below names.
+					if (!accountInfoProbe) {
+						accountInfoProbe = (async () => sdkQuery.accountInfo())();
+						void accountInfoProbe
+							.then((info) => recordBillingIdentity(info))
+							.catch((error) => debug("consumeQuery: billing identity probe rejected:", error));
+					}
 					if (account && router && !accountProbe) {
 						accountProbe = Promise.allSettled([
-							sdkQuery.accountInfo().then((info) => router.recordIdentity(account.profileId, {
+							accountInfoProbe.then((info) => router.recordIdentity(account.profileId, {
 								email: info.email,
 								organization: info.organization,
 								subscriptionType: info.subscriptionType,