@viniciosrab/pi-claude-bridge 0.9.0

package/src/config.ts

@@ -0,0 +1,101 @@
+// User-facing extension config. Loaded once at extension registration from
+// the global agent dir (getAgentDir(), e.g. ~/.pi/agent/claude-bridge.json)
+// and the project Pi config directory, project overriding global. Missing or
+// unparseable files are ignored (error to console.error, empty object
+// returned) so the extension always starts.
+
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+export interface Config {
+	/** Date (YYYY-MM-DD) the one-time startup notice was shown. Written by the extension, not the user. */
+	startupNoticeShown?: string;
+	askClaude?: {
+		enabled?: boolean;
+		name?: string;
+		label?: string;
+		description?: string;
+		defaultMode?: "full" | "read" | "none";
+		defaultIsolated?: boolean;
+		allowFullMode?: boolean;
+		appendSkills?: boolean;
+	};
+	/** Low-level Claude Agent SDK plumbing. Most users won't need these. */
+	provider?: {
+		strictMcpConfig?: boolean;
+		autoMemoryEnabled?: boolean;
+		// Set to false to stop the provider's Claude Code subprocess from loading
+		// user/project/local settings (hooks, plugins, env, apiKeyHelper).
+		loadClaudeSettings?: boolean;
+		pathToClaudeCodeExecutable?: string;
+		// Subscription plan tier. Setting to "max" enables Opus 4.6 at 1M context
+		plan?: "pro" | "max";
+		// Set to true to opt into metered 1M context usage ("extra usage" in
+		// Anthropic billing). Enables Sonnet 4.6 [1m] on every plan and Opus 4.6
+		// [1m] on Pro.
+		longContextExtraUsage?: boolean;
+		// Model ids (e.g. "claude-future-9") whose declared 1M context Claude Code
+		// does not actually serve; pins them to the bare id at 200K.
+		forceTwoHundredK?: string[];
+	};
+}
+
+export function tryParseJson(path: string): Partial<Config> {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch (e) {
+		console.error(`claude-bridge: failed to parse ${path}: ${e}`);
+		return {};
+	}
+}
+
+export function claudeCodeSettings(provider: Config["provider"] = {}): { autoMemoryEnabled: boolean } {
+	return { autoMemoryEnabled: provider.autoMemoryEnabled ?? false };
+}
+
+/** Provider-path `settingSources` override. Absent keeps the SDK default (all sources);
+ *  `loadClaudeSettings: false` passes an empty list so no settings files are loaded. */
+export function providerSettingSourcesOption(provider: Config["provider"] = {}): { settingSources?: [] } {
+	return provider.loadClaudeSettings === false ? { settingSources: [] } : {};
+}
+
+export function globalConfigPath(): string {
+	return join(getAgentDir(), "claude-bridge.json");
+}
+
+/** Record today's date in the global config so the startup notice shows once, preserving every
+ *  other field. Returns the config path for display either way.
+ *
+ *  Parses directly rather than through tryParseJson, which reports an unparseable file as `{}`:
+ *  spreading that would replace a user's whole config with just this marker the first time they
+ *  leave a trailing comma in it. Losing the notice is the cheaper failure, so the write is
+ *  skipped and the notice simply shows again next session. */
+export function markStartupNoticeShown(): string {
+	const path = globalConfigPath();
+	let existing: Partial<Config> = {};
+	if (existsSync(path)) {
+		try {
+			existing = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (e) {
+			console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+			return path;
+		}
+	}
+	// en-CA renders YYYY-MM-DD in local time; toISOString() would report UTC.
+	const next = { ...existing, startupNoticeShown: new Date().toLocaleDateString("en-CA") };
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return path;
+}
+
+export function loadConfig(cwd: string): Config {
+	const global = tryParseJson(globalConfigPath());
+	const project = tryParseJson(join(cwd, CONFIG_DIR_NAME, "claude-bridge.json"));
+	return {
+		startupNoticeShown: project.startupNoticeShown ?? global.startupNoticeShown,
+		askClaude: { ...global.askClaude, ...project.askClaude },
+		provider: { ...global.provider, ...project.provider },
+	};
+}

package/src/convert.ts

@@ -0,0 +1,222 @@
+// Pure pi→Anthropic message conversion helpers.
+// Extracted so they can be tested without pulling in the full extension runtime.
+
+import type { Message as PiMessage } from "@earendil-works/pi-ai";
+import type { Message as SessionMessage } from "cc-session-io";
+import { pascalCase } from "change-case";
+import { MCP_TOOL_PREFIX } from "./skills.js";
+
+export const PROVIDER_ID = "claude-bridge";
+
+// Pi tool names under Claude Code's builtin names. Only ever correct on the
+// AskClaude path, where CC runs its own tools — see mapPiToolNameToSdk.
+export const PI_TO_SDK_TOOL_NAME: Record<string, string> = {
+	read: "Read", write: "Write", edit: "Edit", bash: "Bash",
+};
+
+export function sanitizeToolId(id: string, cache: Map<string, string>): string {
+	const existing = cache.get(id);
+	if (existing) return existing;
+	const clean = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+	cache.set(id, clean);
+	return clean;
+}
+
+/** A pi tool name as the name a rebuilt transcript has to call it by.
+ *
+ *  Whether a map is passed is what distinguishes the two query shapes, because
+ *  they need opposite answers:
+ *
+ *  - **With a map — the provider path.** The query runs `tools: []`, so every
+ *    tool Claude can call is a pi tool served over MCP, and its name is
+ *    `mcp__custom-tools__<pi name>` by construction (resolveMcpTools). The map
+ *    is consulted first only because it carries the served tool's exact casing.
+ *    A name it lacks is a tool pi ran that we do not serve now — AskClaude,
+ *    excluded on purpose, or an extension since disabled — and naming that after
+ *    a Claude Code builtin would tell the model a builtin it cannot call is
+ *    available and was already used. That is the prompt condition behind the
+ *    phantom-call deadlock fixed in 122914dd, and the read direction refuses the
+ *    same names for the same reason (piToolNameFor in index.ts).
+ *  - **Without a map — the AskClaude path.** CC runs its own tools there, so
+ *    builtin names are real, matching mapToolName in the other direction.
+ */
+export function mapPiToolNameToSdk(name: string, customToolNameToSdk?: Map<string, string>): string {
+	if (!name) return "";
+	const normalized = name.toLowerCase();
+	// Pi history holds pi tool names. Our own SDK prefix can only reach here by
+	// feeding already-converted names back through the conversion, and prefixing
+	// twice invents a tool nobody serves.
+	if (normalized.startsWith(MCP_TOOL_PREFIX)) {
+		throw new Error(`mapPiToolNameToSdk: "${name}" is already an SDK tool name — pi history holds pi tool names`);
+	}
+	if (!customToolNameToSdk) return PI_TO_SDK_TOOL_NAME[normalized] ?? pascalCase(name);
+	return customToolNameToSdk.get(name) ?? customToolNameToSdk.get(normalized) ?? `${MCP_TOOL_PREFIX}${name}`;
+}
+
+export function messageContentToText(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	let hasText = false;
+	for (const block of content) {
+		if (block.type === "text" && block.text) { parts.push(block.text); hasText = true; }
+		else if (block.type !== "text" && block.type !== "image") { parts.push(`[${block.type}]`); }
+	}
+	return hasText ? parts.join("\n") : "";
+}
+
+// Tool results are flattened to text, which is how Claude Code stores most of
+// them. Images are the exception: they have no text form, so a result carrying
+// one keeps the block array shape instead (also what CC writes for screenshots).
+function toolResultContent(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | Array<Record<string, unknown>> {
+	if (typeof content === "string" || !Array.isArray(content)) return messageContentToText(content) || "";
+	const images = content.filter((b) => b.type === "image" && b.data && b.mimeType);
+	if (!images.length) return messageContentToText(content) || "";
+	const blocks: Array<Record<string, unknown>> = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+		else if (block.type === "image" && block.data && block.mimeType) {
+			blocks.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+		} else if (block.type !== "text" && block.type !== "image") {
+			// Same marker messageContentToText leaves for unrecognized blocks, so the
+			// text and image paths describe an extension's output the same way.
+			blocks.push({ type: "text", text: `[${block.type}]` });
+		}
+	}
+	return blocks;
+}
+
+/** What convertPiMessages discarded, for the debug line in index.ts. */
+export type DroppedContent = {
+	thinking: number;
+	abortedTurns: number;
+	providers: Set<string>;
+	other: Map<string, number>;
+};
+
+/** Convert pi message array to Anthropic API format. */
+export function convertPiMessages(
+	messages: PiMessage[],
+	customToolNameToSdk?: Map<string, string>,
+): { anthropicMessages: SessionMessage[]; sanitizedIds: Map<string, string>; dropped: DroppedContent } {
+	const anthropicMessages = [];
+	const sanitizedIds = new Map();
+	// What conversion discarded. Nothing downstream can tell: a stripped thinking
+	// block and a message that never carried one convert to the same thing, so
+	// without this the loss is invisible in the log and in a captured request.
+	const dropped: DroppedContent = { thinking: 0, abortedTurns: 0, providers: new Set(), other: new Map() };
+	// The user message collecting this assistant turn's tool results, if one has
+	// been emitted yet, and the index of the assistant message it belongs to. Both
+	// are cleared at every assistant message — see the toolResult branch.
+	let turnResults: { role: "user"; content: Array<Record<string, unknown>> } | null = null;
+	let turnAssistantIdx: number | null = null;
+
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				anthropicMessages.push({ role: "user", content: msg.content || "[empty]" });
+			} else if (Array.isArray(msg.content)) {
+				const parts = [];
+				for (const block of msg.content) {
+					if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
+					else if (block.type === "image" && block.data && block.mimeType) {
+						parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+					}
+				}
+				anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+			} else {
+				anthropicMessages.push({ role: "user", content: "[empty]" });
+			}
+		} else if (msg.role === "assistant") {
+			const content = Array.isArray(msg.content) ? msg.content : [];
+			const blocks = [];
+			for (const block of content) {
+				if (block.type === "text" && block.text) {
+					blocks.push({ type: "text", text: block.text });
+				} else if (block.type === "thinking") {
+					// Only replay thinking Claude Code itself produced. A signature minted
+					// by any other provider — including pi's own Anthropic provider — is
+					// not ours to hand back, and Anthropic rejects ones it can't verify.
+					const sig = block.thinkingSignature;
+					if (msg.provider === PROVIDER_ID && sig) {
+						blocks.push({ type: "thinking", thinking: block.thinking ?? "", signature: sig });
+					} else {
+						dropped.thinking++;
+						dropped.providers.add(msg.provider ?? "unknown");
+					}
+				} else if (block.type === "toolCall") {
+					const toolName = mapPiToolNameToSdk(block.name, customToolNameToSdk);
+					blocks.push({ type: "tool_use", id: sanitizeToolId(block.id, sanitizedIds), name: toolName, input: block.arguments ?? {} });
+				} else {
+					dropped.other.set(block.type, (dropped.other.get(block.type) ?? 0) + 1);
+				}
+			}
+			// A turn the user aborted before anything streamed carries no content at
+			// all. Standing a placeholder in its place invents a reply the assistant
+			// never made, and because it lands early in the prefix it costs the whole
+			// downstream prompt cache every time the session is rebuilt. Drop it:
+			// Session.importMessages imposes no alternation, and a turn with no blocks
+			// has no tool_use ids needing a synthetic result. Left before the turn
+			// bookkeeping so a stray result still attaches to the last assistant
+			// message actually emitted.
+			//
+			// Do NOT clear turnResults/turnAssistantIdx here. It looks like the tidy
+			// thing to do, but an abort between two parallel results — assistant[X,Y],
+			// R_X, aborted turn, R_Y — would then start a second results message for
+			// R_Y. repairToolPairing consumes both pending ids at the first one, stubs
+			// Y there and drops the real R_Y as unmatched, destroying the parallel
+			// result this merge exists to preserve. unit-import.mjs pins the shape.
+			if (!content.length) { dropped.abortedTurns++; continue; }
+			// Blocks were present but every one was filtered — content really was
+			// dropped here, so keep the slot and say so. Empty content is rejected by
+			// the API, and dropping the message would break tool pairing.
+			if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
+			turnResults = null;
+			turnAssistantIdx = anthropicMessages.length;
+			anthropicMessages.push({ role: "assistant", content: blocks });
+		} else if (msg.role === "toolResult") {
+			// Pi records one message per tool result, and repairToolPairing only
+			// pairs results that share the user message directly after their
+			// assistant message. Split across messages, the second and later results
+			// match no pending tool_use id: they are dropped and replaced with a
+			// synthetic "[no tool result recorded]", so every rebuild silently
+			// destroyed the output of parallel tool calls. Session.importMessages
+			// applies the repair itself, so this cannot be opted out of by skipping
+			// our own call. (Claude Code's live writer splits a turn across records
+			// — one per content block, one per result — so the single-message shape
+			// is repairToolPairing's requirement, not a copy of CC's own layout;
+			// tests/int-cc-contracts.mjs pins both facts.)
+			//
+			// Collecting into the turn's first result message rather than the
+			// immediately preceding one also handles a steer landing mid-execution,
+			// which pi records between the results (see extractAllToolResults).
+			// The results also have to sit *directly* after their assistant message:
+			// repairToolPairing consumes the turn's pending ids at the first user
+			// message that follows it, so a steer arriving before the first result —
+			// what any steer during a slow first tool looks like — would otherwise
+			// take the stubs and strand every real result behind it.
+			//
+			// Both hoists reorder the steer against wall-clock: Claude sees results
+			// that were still running when the steer arrived. Claude Code normalizes
+			// to the same order — it records a mid-turn steer as an `attachment`, and
+			// reorderAttachmentsForAPI (claude-code-rip src/utils/messages.ts:1481)
+			// bubbles attachments up to the nearest assistant or tool_result message
+			// and re-inserts them after it. The on-disk form differs, the order does not.
+			const block = { type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: toolResultContent(msg.content), is_error: msg.isError };
+			if (turnResults) {
+				turnResults.content.push(block);
+			} else {
+				turnResults = { role: "user", content: [block] };
+				// A result with no assistant message before it is malformed history;
+				// appending keeps it in order for repairToolPairing to discard.
+				anthropicMessages.splice(turnAssistantIdx === null ? anthropicMessages.length : turnAssistantIdx + 1, 0, turnResults);
+			}
+		}
+	}
+
+	return { anthropicMessages, sanitizedIds, dropped };
+}

package/src/extract-tool-results.ts

@@ -0,0 +1,47 @@
+// Tool-result extraction: walks the context tail to collect this turn's
+// tool results. Pi appends results to context and calls the provider again;
+// this scrapes them back out. Walks past user messages (steer/followUp) that
+// pi may inject between toolResults. Stops at the nearest assistant message
+// (turn boundary).
+// Extracted from index.ts so tests can import without activating the extension.
+
+export type McpContent = Array<
+	| { type: "text"; text: string }
+	| { type: "image"; data: string; mimeType: string }
+>;
+
+export interface McpResult {
+	content: McpContent;
+	isError?: boolean;
+	toolCallId?: string;
+	[key: string]: unknown;
+}
+
+export function toolResultToMcpContent(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): McpContent {
+	if (typeof content === "string") return [{ type: "text", text: content || "" }];
+	if (!Array.isArray(content)) return [{ type: "text", text: "" }];
+	const blocks: McpContent = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+		else if (block.type === "image" && block.data && block.mimeType) blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+	}
+	return blocks.length ? blocks : [{ type: "text", text: "" }];
+}
+
+// Returns { results, stopIdx } so callers can log the walk boundary.
+export function extractAllToolResults(
+	messages: Array<{ role: string; content?: unknown; toolCallId?: string; isError?: boolean; [key: string]: unknown }>,
+): { results: McpResult[]; stopIdx: number } {
+	const results: McpResult[] = [];
+	let stopIdx = -1;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "toolResult") {
+			results.unshift({ content: toolResultToMcpContent(msg.content as string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>), isError: msg.isError, toolCallId: msg.toolCallId });
+		} else if (msg.role === "assistant") { stopIdx = i; break; }
+		// user messages: skip (steer/followUp injected mid-tool-execution)
+	}
+	return { results, stopIdx };
+}