@vanillagreen/pi-claude-bridge 1.2.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillagreen/pi-claude-bridge",
-  "version": "1.2.0",
+  "version": "1.4.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": [
@@ -94,6 +94,41 @@
           "category": "Claude Code",
           "apply": "live"
         },
+        {
+          "key": "fastMode",
+          "label": "Fast mode",
+          "description": "Enable Claude Code fast mode for bridge requests when the selected model supports it. Off by default.",
+          "type": "boolean",
+          "default": false,
+          "category": "Claude Code",
+          "apply": "live"
+        },
+        {
+          "key": "forceEffort",
+          "label": "Force Claude effort",
+          "description": "Override Pi's thinking-level mapping for all claude-bridge requests. Use max to reach Claude Code max effort even though Pi has no max thinking level. none keeps Pi's selected level.",
+          "type": "enum",
+          "enumValues": [
+            "none",
+            "low",
+            "medium",
+            "high",
+            "xhigh",
+            "max"
+          ],
+          "default": "none",
+          "category": "Claude Code",
+          "apply": "live"
+        },
+        {
+          "key": "modelEffortOverrides",
+          "label": "Model effort overrides",
+          "description": "Optional JSON object mapping claude-bridge model ids to Claude Code effort levels, e.g. {\"claude-opus-4-8\":\"max\"}. Keys may also use claude-bridge/<id> or *.",
+          "type": "string",
+          "default": "{}",
+          "category": "Claude Code",
+          "apply": "live"
+        },
         {
           "key": "pathToClaudeCodeExecutable",
           "label": "Claude executable path",
@@ -107,8 +142,8 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.141",
-    "@anthropic-ai/sdk": "^0.73.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.158",
+    "@anthropic-ai/sdk": "0.93.0",
     "cc-session-io": "^0.3.1",
     "change-case": "^5.4.4"
   },

package/src/config.ts

@@ -9,12 +9,22 @@ import { dirname, join, resolve } from "path";
 
 export const PACKAGE_ID = "@vanillagreen/pi-claude-bridge";
 
+export type BridgeEffortLevel = "low" | "medium" | "high" | "xhigh" | "max";
+
+const VALID_EFFORT_LEVELS = new Set<BridgeEffortLevel>(["low", "medium", "high", "xhigh", "max"]);
+
 export interface Config {
 	enabled?: boolean;
 	/** Low-level Claude Agent SDK plumbing. Most users won't need these. */
 	provider?: {
 		appendSystemPrompt?: boolean;
 		allowExtraUsage?: boolean;
+		/** Enable Claude Code fast mode for bridge requests. */
+		fastMode?: boolean;
+		/** Force this Claude Code effort level for every bridge request. */
+		forceEffort?: BridgeEffortLevel;
+		/** Per-model Claude Code effort overrides keyed by model id (e.g. claude-opus-4-8). */
+		modelEffortOverrides?: Record<string, BridgeEffortLevel>;
 		settingSources?: SettingSource[];
 		strictMcpConfig?: boolean;
 		pathToClaudeCodeExecutable?: string;
@@ -106,6 +116,53 @@ function stringFrom(raw: SettingsRecord, key: string): string | undefined {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
+function hasOwn(raw: SettingsRecord, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(raw, key);
+}
+
+export function normalizeEffortLevel(value: unknown): BridgeEffortLevel | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "" || normalized === "none" || normalized === "auto" || normalized === "default") return undefined;
+	return VALID_EFFORT_LEVELS.has(normalized as BridgeEffortLevel) ? normalized as BridgeEffortLevel : undefined;
+}
+
+export function normalizeModelEffortOverrides(value: unknown): Record<string, BridgeEffortLevel> | undefined {
+	let source: unknown = value;
+	if (typeof source === "string") {
+		const trimmed = source.trim();
+		if (!trimmed || trimmed === "{}") return undefined;
+		try {
+			source = JSON.parse(trimmed);
+		} catch {
+			return undefined;
+		}
+	}
+	const record = asRecord(source);
+	if (!record) return undefined;
+
+	const out: Record<string, BridgeEffortLevel> = {};
+	for (const [modelId, rawEffort] of Object.entries(record)) {
+		const key = modelId.trim();
+		const effort = normalizeEffortLevel(rawEffort);
+		if (key && effort) out[key] = effort;
+	}
+	return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function normalizeProviderConfig(provider: Config["provider"] | undefined): Config["provider"] {
+	if (!provider) return {};
+	const raw = provider as SettingsRecord;
+	const out: Config["provider"] = { ...provider };
+	const forceEffort = normalizeEffortLevel(raw.forceEffort);
+	if (forceEffort) out.forceEffort = forceEffort;
+	else delete out.forceEffort;
+	const modelEffortOverrides = normalizeModelEffortOverrides(raw.modelEffortOverrides);
+	if (modelEffortOverrides) out.modelEffortOverrides = modelEffortOverrides;
+	else delete out.modelEffortOverrides;
+	return out;
+}
+
 function managerToConfig(raw: SettingsRecord): Partial<Config> {
 	const provider: Config["provider"] = {};
 	const promptContext: Config["promptContext"] = {};
@@ -114,6 +171,14 @@ function managerToConfig(raw: SettingsRecord): Partial<Config> {
 	if (appendSystemPrompt !== undefined) provider.appendSystemPrompt = appendSystemPrompt;
 	const allowExtraUsage = boolFrom(raw, "allowExtraUsage");
 	if (allowExtraUsage !== undefined) provider.allowExtraUsage = allowExtraUsage;
+	const fastMode = boolFrom(raw, "fastMode");
+	if (fastMode !== undefined) provider.fastMode = fastMode;
+	if (hasOwn(raw, "forceEffort")) {
+		provider.forceEffort = normalizeEffortLevel(raw.forceEffort);
+	}
+	if (hasOwn(raw, "modelEffortOverrides")) {
+		provider.modelEffortOverrides = normalizeModelEffortOverrides(raw.modelEffortOverrides);
+	}
 	const strictMcpConfig = boolFrom(raw, "strictMcpConfig");
 	if (strictMcpConfig !== undefined) provider.strictMcpConfig = strictMcpConfig;
 	const claudePath = stringFrom(raw, "pathToClaudeCodeExecutable");
@@ -139,9 +204,10 @@ export function loadConfig(cwd: string): Config {
 	const global = tryParseJson(join(piUserDir(), "claude-bridge.json"));
 	const project = tryParseJson(join(cwd, ".pi", "claude-bridge.json"));
 	const manager = managerToConfig(readManagerConfig(cwd));
+	const provider = normalizeProviderConfig({ ...global.provider, ...project.provider, ...manager.provider });
 	return {
 		enabled: manager.enabled ?? project.enabled ?? global.enabled ?? true,
-		provider: { ...global.provider, ...project.provider, ...manager.provider },
+		provider,
 		promptContext: { ...global.promptContext, ...project.promptContext, ...manager.promptContext },
 	};
 }

package/src/convert.ts

@@ -80,6 +80,34 @@ function assistantProvenancePrefix(msg: PiMessage): string | undefined {
 	return `[Prior Pi assistant response from ${provider ?? api ?? "unknown-provider"}${model ? `/${model}` : ""}]\n`;
 }
 
+function userMessageToAnthropic(msg: PiMessage): SessionMessage {
+	if (typeof msg.content === "string") return { role: "user", content: msg.content || "[empty]" };
+	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(imageBlockToAnthropic(block));
+		}
+		const kept = parts.filter(Boolean) as ContentBlock[];
+		return { role: "user", content: kept.length ? kept : "[image]" };
+	}
+	return { role: "user", content: "[empty]" };
+}
+
+function toolResultToAnthropicBlock(msg: PiMessage, sanitizedIds: Map<string, string>): ContentBlock {
+	const content = toolResultContentToAnthropic(msg.content as string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>);
+	return {
+		type: "tool_result",
+		tool_use_id: sanitizeToolId((msg as { toolCallId: string }).toolCallId, sanitizedIds),
+		content: content || "",
+		is_error: (msg as { isError?: boolean }).isError,
+	} as ContentBlock;
+}
+
+function hasToolUse(msg: PiMessage): boolean {
+	return msg.role === "assistant" && Array.isArray(msg.content) && msg.content.some((block) => block.type === "toolCall");
+}
+
 /** Convert pi message array to Anthropic API format. */
 export function convertPiMessages(
 	messages: PiMessage[],
@@ -88,22 +116,26 @@ export function convertPiMessages(
 	const anthropicMessages = [];
 	const sanitizedIds = new Map();
 
-	for (const msg of messages) {
+	const pushToolResultGroup = (toolMessages: PiMessage[]): void => {
+		if (toolMessages.length === 0) return;
+		anthropicMessages.push({
+			role: "user",
+			content: toolMessages.map((toolMsg) => {
+				const content = toolResultContentToAnthropic(toolMsg.content as string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>);
+				return {
+					type: "tool_result",
+					tool_use_id: sanitizeToolId((toolMsg as { toolCallId: string }).toolCallId, sanitizedIds),
+					content: content || "",
+					is_error: (toolMsg as { isError?: boolean }).isError,
+				};
+			}),
+		});
+	};
+
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
 		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(imageBlockToAnthropic(block));
-					}
-				}
-				anthropicMessages.push({ role: "user", content: parts.filter(Boolean).length ? parts.filter(Boolean) as ContentBlock[] : "[image]" });
-			} else {
-				anthropicMessages.push({ role: "user", content: "[empty]" });
-			}
+			anthropicMessages.push(userMessageToAnthropic(msg));
 		} else if (msg.role === "assistant") {
 			const content = Array.isArray(msg.content) ? msg.content : [];
 			const blocks = [];
@@ -125,12 +157,37 @@ export function convertPiMessages(
 			}
 			if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
 			anthropicMessages.push({ role: "assistant", content: blocks });
+
+			// Pi may inject steer/followUp user messages between parallel tool
+			// results, while runtime extraction treats every toolResult after the
+			// assistant (until the next assistant) as one turn. Claude history must
+			// put all tool_result blocks immediately after the tool_use assistant;
+			// replay interleaved user text only after that grouped result message.
+			if (hasToolUse(msg)) {
+				const toolMessages: PiMessage[] = [];
+				const interleavedUsers: PiMessage[] = [];
+				let j = i + 1;
+				for (; j < messages.length; j++) {
+					const next = messages[j];
+					if (next.role === "assistant") break;
+					if (next.role === "toolResult") toolMessages.push(next);
+					else if (next.role === "user") interleavedUsers.push(next);
+					else break;
+				}
+				if (toolMessages.length > 0) {
+					pushToolResultGroup(toolMessages);
+					for (const userMsg of interleavedUsers) anthropicMessages.push(userMessageToAnthropic(userMsg));
+					i = j - 1;
+				}
+			}
 		} else if (msg.role === "toolResult") {
-			const content = toolResultContentToAnthropic(msg.content);
-			anthropicMessages.push({
-				role: "user",
-				content: [{ type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: content || "", is_error: msg.isError }],
-			});
+			const blocks: ContentBlock[] = [];
+			for (; i < messages.length; i++) {
+				const toolMsg = messages[i];
+				if (toolMsg.role !== "toolResult") { i--; break; }
+				blocks.push(toolResultToAnthropicBlock(toolMsg, sanitizedIds));
+			}
+			anthropicMessages.push({ role: "user", content: blocks });
 		}
 	}