@vanillagreen/pi-claude-bridge 1.0.5 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-claude-bridge",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Pi provider bridge that runs Claude Code through the Claude Agent SDK, with opt-in forwarding for Pi prompt context.",
   "type": "module",
   "keywords": [
@@ -104,19 +104,19 @@
     "change-case": "^5.4.4"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@mariozechner/pi-ai": "^0.72.1",
-    "@mariozechner/pi-coding-agent": "^0.72.1",
+    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-coding-agent": "^0.74.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=node20 --outfile=bundle/index.js --external:@mariozechner/pi-ai --external:@mariozechner/pi-coding-agent",
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --outfile=bundle/index.js --external:@earendil-works/pi-ai --external:@earendil-works/pi-coding-agent",
     "prepack": "npm run build",
     "test:unit": "node --import tsx --test tests/unit-*.mjs",
     "test": "set -a && [ -f .env.test ] && . .env.test; set +a && npm run test:unit && tests/int-smoke.sh && tests/int-multi-turn.sh && tests/int-cache.sh && node --import tsx --test tests/int-*.mjs",

package/src/convert.ts

@@ -1,8 +1,8 @@
 // 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 "@mariozechner/pi-ai";
-import type { Message as SessionMessage } from "cc-session-io";
+import type { Message as PiMessage } from "@earendil-works/pi-ai";
+import type { ContentBlock, Message as SessionMessage } from "cc-session-io";
 import { pascalCase } from "change-case";
 
 export const PROVIDER_ID = "claude-bridge";
@@ -44,6 +44,42 @@ export function messageContentToText(
 	return hasText ? parts.join("\n") : "";
 }
 
+function imageBlockToAnthropic(block: { data?: string; mimeType?: string }): ContentBlock | undefined {
+	if (!block.data || !block.mimeType) return undefined;
+	return { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } } as ContentBlock;
+}
+
+function toolResultContentToAnthropic(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | ContentBlock[] {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const blocks: ContentBlock[] = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) {
+			blocks.push({ type: "text", text: block.text });
+		} else if (block.type === "image") {
+			const image = imageBlockToAnthropic(block);
+			if (image) blocks.push(image);
+		} else if (block.type) {
+			blocks.push({ type: "text", text: `[${block.type}]` });
+		}
+	}
+	if (blocks.length === 0) return "";
+	if (blocks.every((block) => block.type === "text")) return blocks.map((block) => (block as { text: string }).text).join("\n");
+	return blocks;
+}
+
+function assistantProvenancePrefix(msg: PiMessage): string | undefined {
+	if (msg.role !== "assistant") return undefined;
+	const provider = typeof (msg as any).provider === "string" ? (msg as any).provider : undefined;
+	const model = typeof (msg as any).model === "string" ? (msg as any).model : undefined;
+	const api = typeof (msg as any).api === "string" ? (msg as any).api : undefined;
+	if (!provider && !model && !api) return undefined;
+	if (provider === PROVIDER_ID || api === "anthropic") return undefined;
+	return `[Prior Pi assistant response from ${provider ?? api ?? "unknown-provider"}${model ? `/${model}` : ""}]\n`;
+}
+
 /** Convert pi message array to Anthropic API format. */
 export function convertPiMessages(
 	messages: PiMessage[],
@@ -61,16 +97,18 @@ export function convertPiMessages(
 				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 } });
+						parts.push(imageBlockToAnthropic(block));
 					}
 				}
-				anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+				anthropicMessages.push({ role: "user", content: parts.filter(Boolean).length ? parts.filter(Boolean) as ContentBlock[] : "[image]" });
 			} else {
 				anthropicMessages.push({ role: "user", content: "[empty]" });
 			}
 		} else if (msg.role === "assistant") {
 			const content = Array.isArray(msg.content) ? msg.content : [];
 			const blocks = [];
+			const provenance = assistantProvenancePrefix(msg);
+			if (provenance) blocks.push({ type: "text", text: provenance });
 			for (const block of content) {
 				if (block.type === "text" && block.text) {
 					blocks.push({ type: "text", text: block.text });
@@ -88,10 +126,10 @@ export function convertPiMessages(
 			if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
 			anthropicMessages.push({ role: "assistant", content: blocks });
 		} else if (msg.role === "toolResult") {
-			const text = typeof msg.content === "string" ? msg.content : messageContentToText(msg.content);
+			const content = toolResultContentToAnthropic(msg.content);
 			anthropicMessages.push({
 				role: "user",
-				content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: text || "", is_error: msg.isError }],
+				content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: content || "", is_error: msg.isError }],
 			});
 		}
 	}

package/src/index.ts

@@ -1,9 +1,10 @@
-import { calculateCost, getModels, type AssistantMessage, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions, type Tool } from "@mariozechner/pi-ai";
-import * as piAi from "@mariozechner/pi-ai";
-import { type ExtensionAPI, type ExtensionUIContext } from "@mariozechner/pi-coding-agent";
+import { calculateCost, getModels, type AssistantMessage, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions, type Tool } from "@earendil-works/pi-ai";
+import * as piAi from "@earendil-works/pi-ai";
+import { type ExtensionAPI, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { createSdkMcpServer, query, type EffortLevel, type SDKMessage, type SDKUserMessage, type SettingSource } from "@anthropic-ai/claude-agent-sdk";
 import type { Base64ImageSource, ContentBlockParam, MessageParam } from "@anthropic-ai/sdk/resources";
-import { createSession, deleteSession, repairToolPairing } from "cc-session-io";
+import { createSession, deleteSession, openSession, repairToolPairing } from "cc-session-io";
+import { createHash } from "crypto";
 import { accessSync, appendFileSync, constants as fsConstants, mkdirSync, realpathSync, statSync } from "fs";
 import { homedir } from "os";
 import { delimiter, dirname, join } from "path";
@@ -184,12 +185,107 @@ interface SessionState {
 }
 
 let sharedSession: SessionState | null = null;
+let extensionApi: ExtensionAPI | undefined;
+
+const BRIDGE_SESSION_CUSTOM_TYPE = "claude-bridge-session";
+
+interface PersistedBridgeSessionState extends SessionState {
+	fingerprint: string;
+	piSessionId?: string;
+	updatedAt: string;
+}
+
+function fingerprintMessages(messages: Context["messages"]): string {
+	const normalized = messages.map((message) => {
+		if (message.role === "assistant") {
+			return {
+				role: message.role,
+				provider: (message as AssistantMessage).provider,
+				model: (message as AssistantMessage).model,
+				content: (message as AssistantMessage).content,
+			};
+		}
+		return message;
+	});
+	return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+
+function readBuiltSessionContext(sessionManager: unknown): { messages: Context["messages"] } | undefined {
+	const built = typeof (sessionManager as any)?.buildSessionContext === "function" ? (sessionManager as any).buildSessionContext() : undefined;
+	return Array.isArray(built?.messages) ? built as { messages: Context["messages"] } : undefined;
+}
+
+function latestPersistedBridgeSession(sessionManager: unknown): PersistedBridgeSessionState | undefined {
+	const entries = typeof (sessionManager as any)?.getEntries === "function" ? (sessionManager as any).getEntries() : [];
+	if (!Array.isArray(entries)) return undefined;
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry?.type !== "custom" || entry.customType !== BRIDGE_SESSION_CUSTOM_TYPE) continue;
+		const data = entry.data as Partial<PersistedBridgeSessionState> | undefined;
+		if (!data || typeof data.sessionId !== "string" || typeof data.cursor !== "number" || typeof data.cwd !== "string" || typeof data.fingerprint !== "string") continue;
+		return data as PersistedBridgeSessionState;
+	}
+	return undefined;
+}
+
+function claudeSessionExists(sessionId: string, cwd: string): boolean {
+	try {
+		const session = openSession({ sessionId, projectPath: cwd, claudeDir: process.env.CLAUDE_CONFIG_DIR });
+		statSync(session.jsonlPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function restoreSharedSessionFromPi(ctx: { sessionManager?: unknown }): void {
+	const persisted = latestPersistedBridgeSession(ctx.sessionManager);
+	if (!persisted) return;
+	const built = readBuiltSessionContext(ctx.sessionManager);
+	if (!built) return;
+	const cursor = Math.max(0, Math.min(persisted.cursor, built.messages.length));
+	const fingerprint = fingerprintMessages(built.messages.slice(0, cursor));
+	if (fingerprint !== persisted.fingerprint) {
+		debug(`restoreSharedSession: fingerprint mismatch for ${persisted.sessionId.slice(0, 8)}`);
+		return;
+	}
+	if (!claudeSessionExists(persisted.sessionId, persisted.cwd)) {
+		debug(`restoreSharedSession: Claude session missing for ${persisted.sessionId.slice(0, 8)}`);
+		return;
+	}
+	sharedSession = { sessionId: persisted.sessionId, cursor, cwd: persisted.cwd };
+	debug(`restoreSharedSession: restored ${persisted.sessionId.slice(0, 8)}, cursor=${cursor}`);
+}
+
+function schedulePersistSharedSession(ctxLike?: { sessionManager?: unknown }): void {
+	if (!extensionApi || !sharedSession || !ctxLike?.sessionManager) return;
+	const snapshot = { ...sharedSession };
+	const timer = setTimeout(() => {
+		try {
+			const built = readBuiltSessionContext(ctxLike.sessionManager);
+			if (!built) return;
+			const cursor = Math.max(0, Math.min(snapshot.cursor, built.messages.length));
+			const data: PersistedBridgeSessionState = {
+				...snapshot,
+				cursor,
+				fingerprint: fingerprintMessages(built.messages.slice(0, cursor)),
+				piSessionId: typeof (ctxLike.sessionManager as any)?.getSessionId === "function" ? (ctxLike.sessionManager as any).getSessionId() : undefined,
+				updatedAt: new Date().toISOString(),
+			};
+			extensionApi?.appendEntry(BRIDGE_SESSION_CUSTOM_TYPE, data);
+			debug(`persistSharedSession: saved ${data.sessionId.slice(0, 8)}, cursor=${data.cursor}`);
+		} catch (error) {
+			debug("persistSharedSession failed:", error);
+		}
+	}, 0);
+	timer.unref?.();
+}
 
 // Convert pi messages to Anthropic API format for session import.
-// Lossy: non-Anthropic thinking blocks are dropped (no valid signature), and only
-// text/image/toolCall block types are handled. If all blocks in an assistant message
-// are filtered, the message is dropped — which can create invalid sequences (e.g.
-// two user messages in a row, or tool_result without preceding tool_use).
+// Lossy: non-Anthropic thinking blocks are dropped (no valid signature). User and
+// tool-result image blocks are preserved when possible. If assistant blocks are
+// otherwise incompatible, convertPiMessages emits a text placeholder so the record
+// sequence stays valid before repairToolPairing runs.
 function convertAndImportMessages(
 	session: ReturnType<typeof createSession>,
 	messages: Context["messages"],
@@ -1166,6 +1262,7 @@ function streamClaudeAgentSdk(model: Model<any>, context: Context, options?: Sim
 // --- Extension registration ---
 
 export default function (pi: ExtensionAPI) {
+	extensionApi = pi;
 	// Disable non-essential Claude Code traffic (update checks, MCP registry, telemetry)
 	process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
 
@@ -1195,8 +1292,13 @@ export default function (pi: ExtensionAPI) {
 		if (event.reason === "new" || event.reason === "resume" || event.reason === "fork") {
 			clearSession(`session_start:${event.reason}`);
 		}
+		if (event.reason === "startup" || event.reason === "resume" || event.reason === "fork") restoreSharedSessionFromPi(ctx);
 	});
 	pi.on("session_shutdown", () => clearSession("session_shutdown"));
+	pi.on("message_end", (event, ctx) => {
+		const message = (event as { message?: AssistantMessage }).message;
+		if (message?.role === "assistant" && message.provider === PROVIDER_ID) schedulePersistSharedSession(ctx);
+	});
 
 	// pi /compact and session-tree navigation (rewind / fork-at-point /
 	// branch switch) both mutate pi's messages array out from under the

package/src/query-state.ts

@@ -6,7 +6,7 @@
 //
 // Extracted from index.ts so tests can import without activating the extension.
 
-import type { AssistantMessage, AssistantMessageEventStream, Model } from "@mariozechner/pi-ai";
+import type { AssistantMessage, AssistantMessageEventStream, Model } from "@earendil-works/pi-ai";
 import type { McpResult } from "./extract-tool-results.js";
 
 export interface PendingToolCall {

package/src/typebox-to-zod.ts

@@ -13,15 +13,29 @@ import { z } from "zod";
 
 export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
 	let base: z.ZodTypeAny;
-	if (Array.isArray(prop.enum)) base = z.enum(prop.enum as [string, ...string[]]);
+	if (Array.isArray(prop.enum) && prop.enum.length > 0) base = z.enum(prop.enum as [string, ...string[]]);
 	else switch (prop.type) {
 		case "string": base = z.string(); break;
 		case "number": case "integer": base = z.number(); break;
 		case "boolean": base = z.boolean(); break;
-		case "array": base = prop.items
-			? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
-			: z.array(z.unknown()); break;
-		case "object": base = z.record(z.string(), z.unknown()); break;
+		case "array": {
+			base = prop.items
+				? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
+				: z.array(z.unknown());
+			const minItems = typeof prop.minItems === "number" ? prop.minItems : undefined;
+			if (minItems !== undefined) base = (base as z.ZodArray<z.ZodTypeAny>).min(minItems);
+			break;
+		}
+		case "object": {
+			if (prop.properties && typeof prop.properties === "object" && !Array.isArray(prop.properties)) {
+				base = z.object(jsonSchemaToZodShape(prop));
+				if (prop.additionalProperties === false) base = (base as z.ZodObject<Record<string, z.ZodTypeAny>>).strict();
+				else if (prop.additionalProperties === true) base = (base as z.ZodObject<Record<string, z.ZodTypeAny>>).passthrough();
+			} else {
+				base = z.record(z.string(), z.unknown());
+			}
+			break;
+		}
 		default: base = z.unknown();
 	}
 	if (typeof prop.description === "string") base = base.describe(prop.description);