@oh-my-pi/pi-coding-agent 11.2.3 → 11.4.0

package/src/sdk.ts

@@ -387,7 +387,7 @@ function customToolToDefinition(tool: CustomTool): ToolDefinition {
 		label: tool.label,
 		description: tool.description,
 		parameters: tool.parameters,
-		execute: (toolCallId, params, onUpdate, ctx, signal) =>
+		execute: (toolCallId, params, signal, onUpdate, ctx) =>
 			tool.execute(toolCallId, params, onUpdate, createCustomToolContext(ctx), signal),
 		onSession: tool.onSession ? (event, ctx) => tool.onSession?.(event, createCustomToolContext(ctx)) : undefined,
 		renderCall: tool.renderCall,
@@ -506,6 +506,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const existingSession = sessionManager.buildSessionContext();
 	time("loadSession");
 	const hasExistingSession = existingSession.messages.length > 0;
+	const hasThinkingEntry = sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
 
 	const hasExplicitModel = options.model !== undefined;
 	let model = options.model;
@@ -563,7 +564,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// If session has data, restore thinking level from it
 	if (thinkingLevel === undefined && hasExistingSession) {
-		thinkingLevel = existingSession.thinkingLevel as ThinkingLevel;
+		thinkingLevel = hasThinkingEntry
+			? (existingSession.thinkingLevel as ThinkingLevel)
+			: ((settingsInstance.get("defaultThinkingLevel") ?? "off") as ThinkingLevel);
 	}
 
 	// Fall back to settings default
@@ -698,7 +701,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			onConnecting: serverNames => {
 				if (options.hasUI && serverNames.length > 0) {
 					process.stderr.write(
-						chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}...
+						chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…
 `),
 					);
 				}
@@ -1016,14 +1019,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingBudgets: settingsInstance.getGroup("thinkingBudgets"),
 		kimiApiFormat: settingsInstance.get("providers.kimiApiFormat") ?? "anthropic",
 		getToolContext: tc => toolContextStore.getContext(tc),
-		getApiKey: async () => {
-			const currentModel = agent.state.model;
-			if (!currentModel) {
-				throw new Error("No model selected");
-			}
-			const key = await modelRegistry.getApiKey(currentModel, sessionId);
+		getApiKey: async provider => {
+			// Use the provider argument from the in-flight request;
+			// agent.state.model may already be switched mid-turn.
+			const key = await modelRegistry.getApiKeyForProvider(provider, sessionId);
 			if (!key) {
-				throw new Error(`No API key found for provider "${currentModel.provider}"`);
+				throw new Error(`No API key found for provider "${provider}"`);
 			}
 			return key;
 		},
@@ -1036,6 +1037,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Restore messages if session has existing data
 	if (hasExistingSession) {
 		agent.replaceMessages(existingSession.messages);
+		if (!hasThinkingEntry) {
+			sessionManager.appendThinkingLevelChange(thinkingLevel);
+		}
 	} else {
 		// Save initial model and thinking level for new sessions so they can be restored on resume
 		if (model) {
@@ -1072,7 +1076,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			const result = await warmupLspServers(cwd, {
 				onConnecting: serverNames => {
 					if (options.hasUI && serverNames.length > 0) {
-						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}...\n`));
+						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}…\n`));
 					}
 				},
 			});

package/src/session/agent-session.ts

@@ -29,7 +29,6 @@ import type {
 } from "@oh-my-pi/pi-ai";
 import { isContextOverflow, modelsAreEqual, supportsXhigh } from "@oh-my-pi/pi-ai";
 import { abortableSleep, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
 import type { Rule } from "../capability/rule";
 import { getAgentDbPath } from "../config";
 import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "../config/model-registry";
@@ -237,6 +236,8 @@ const noOpUIContext: ExtensionUIContext = {
 	setFooter: () => {},
 	setHeader: () => {},
 	setEditorComponent: () => {},
+	getToolsExpanded: () => false,
+	setToolsExpanded: () => {},
 };
 
 async function cleanupSshResources(): Promise<void> {
@@ -906,6 +907,11 @@ export class AgentSession {
 		return this.agent.state.isStreaming || this._promptInFlight;
 	}
 
+	/** Current effective system prompt (includes any per-turn extension modifications) */
+	get systemPrompt(): string {
+		return this.agent.state.systemPrompt;
+	}
+
 	/** Current retry attempt (0 if not retrying) */
 	get retryAttempt(): number {
 		return this._retryAttempt;
@@ -1426,6 +1432,11 @@ export class AgentSession {
 					instructionsOrOptions && typeof instructionsOrOptions === "object" ? instructionsOrOptions : undefined;
 				await this.compact(instructions, options);
 			},
+			switchSession: async sessionPath => {
+				const success = await this.switchSession(sessionPath);
+				return { cancelled: !success };
+			},
+			getSystemPrompt: () => this.systemPrompt,
 		};
 	}
 
@@ -1477,25 +1488,25 @@ export class AgentSession {
 	/**
 	 * Queue a steering message to interrupt the agent mid-run.
 	 */
-	async steer(text: string): Promise<void> {
+	async steer(text: string, images?: ImageContent[]): Promise<void> {
 		if (text.startsWith("/")) {
 			this._throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this._promptTemplates]);
-		await this._queueSteer(expandedText);
+		await this._queueSteer(expandedText, images);
 	}
 
 	/**
 	 * Queue a follow-up message to process after the agent would otherwise stop.
 	 */
-	async followUp(text: string): Promise<void> {
+	async followUp(text: string, images?: ImageContent[]): Promise<void> {
 		if (text.startsWith("/")) {
 			this._throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this._promptTemplates]);
-		await this._queueFollowUp(expandedText);
+		await this._queueFollowUp(expandedText, images);
 	}
 
 	/**
@@ -1728,11 +1739,14 @@ export class AgentSession {
 		await this.abort();
 		this.agent.reset();
 		await this.sessionManager.flush();
-		this.sessionManager.newSession(options);
+		await this.sessionManager.newSession(options);
 		this.agent.sessionId = this.sessionManager.getSessionId();
 		this._steeringMessages = [];
 		this._followUpMessages = [];
 		this._pendingNextTurnMessages = [];
+
+		this.sessionManager.appendThinkingLevelChange(this.thinkingLevel);
+
 		this._todoReminderCount = 0;
 		this._planReferenceSent = false;
 		this._reconnectToAgent();
@@ -1934,22 +1948,39 @@ export class AgentSession {
 		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
 	}
 
+	private async _getScopedModelsWithApiKey(): Promise<Array<{ model: Model; thinkingLevel: ThinkingLevel }>> {
+		const apiKeysByProvider = new Map<string, string | undefined>();
+		const result: Array<{ model: Model; thinkingLevel: ThinkingLevel }> = [];
+
+		for (const scoped of this._scopedModels) {
+			const provider = scoped.model.provider;
+			let apiKey: string | undefined;
+			if (apiKeysByProvider.has(provider)) {
+				apiKey = apiKeysByProvider.get(provider);
+			} else {
+				apiKey = await this._modelRegistry.getApiKeyForProvider(provider, this.sessionId);
+				apiKeysByProvider.set(provider, apiKey);
+			}
+
+			if (apiKey) {
+				result.push(scoped);
+			}
+		}
+
+		return result;
+	}
+
 	private async _cycleScopedModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
-		if (this._scopedModels.length <= 1) return undefined;
+		const scopedModels = await this._getScopedModelsWithApiKey();
+		if (scopedModels.length <= 1) return undefined;
 
 		const currentModel = this.model;
-		let currentIndex = this._scopedModels.findIndex(sm => modelsAreEqual(sm.model, currentModel));
+		let currentIndex = scopedModels.findIndex(sm => modelsAreEqual(sm.model, currentModel));
 
 		if (currentIndex === -1) currentIndex = 0;
-		const len = this._scopedModels.length;
+		const len = scopedModels.length;
 		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
-		const next = this._scopedModels[nextIndex];
-
-		// Validate API key
-		const apiKey = await this._modelRegistry.getApiKey(next.model, this.sessionId);
-		if (!apiKey) {
-			throw new Error(`No API key for ${next.model.provider}/${next.model.id}`);
-		}
+		const next = scopedModels[nextIndex];
 
 		// Apply model
 		this.agent.setModel(next.model);
@@ -2005,15 +2036,22 @@ export class AgentSession {
 	/**
 	 * Set thinking level.
 	 * Clamps to model capabilities based on available thinking levels.
-	 * Saves to session, with optional persistence to settings.
+	 * Saves to session and settings only if the level actually changes.
 	 */
 	setThinkingLevel(level: ThinkingLevel, persist: boolean = false): void {
 		const availableLevels = this.getAvailableThinkingLevels();
 		const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
+
+		// Only persist if actually changing
+		const isChanging = effectiveLevel !== this.agent.state.thinkingLevel;
+
 		this.agent.setThinkingLevel(effectiveLevel);
-		this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-		if (persist) {
-			this.settings.set("defaultThinkingLevel", effectiveLevel);
+
+		if (isChanging) {
+			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
+			if (persist) {
+				this.settings.set("defaultThinkingLevel", effectiveLevel);
+			}
 		}
 	}
 
@@ -2404,7 +2442,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 
 			// Start a new session
 			await this.sessionManager.flush();
-			this.sessionManager.newSession();
+			await this.sessionManager.newSession();
 			this.agent.reset();
 			this.agent.sessionId = this.sessionManager.getSessionId();
 			this._steeringMessages = [];
@@ -2903,8 +2941,8 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	}
 
 	private _isRetryableErrorMessage(errorMessage: string): boolean {
-		// Match: overloaded_error, rate limit, usage limit, 429, 500, 502, 503, 504, service unavailable, connection error, fetch failed
-		return /overloaded|rate.?limit|usage.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|fetch failed/i.test(
+		// Match: overloaded_error, rate limit, usage limit, 429, 500, 502, 503, 504, service unavailable, connection error, fetch failed, retry delay exceeded
+		return /overloaded|rate.?limit|usage.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|fetch failed|retry delay/i.test(
 			errorMessage,
 		);
 	}
@@ -3354,9 +3392,19 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			}
 		}
 
-		// Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
-		if (sessionContext.thinkingLevel) {
+		const hasThinkingEntry = this.sessionManager.getBranch().some(entry => entry.type === "thinking_level_change");
+		const defaultThinkingLevel = (this.settings.get("defaultThinkingLevel") ?? "off") as ThinkingLevel;
+
+		if (hasThinkingEntry) {
+			// Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
 			this.setThinkingLevel(sessionContext.thinkingLevel as ThinkingLevel);
+		} else {
+			const availableLevels = this.getAvailableThinkingLevels();
+			const effectiveLevel = availableLevels.includes(defaultThinkingLevel)
+				? defaultThinkingLevel
+				: this._clampThinkingLevel(defaultThinkingLevel, availableLevels);
+			this.agent.setThinkingLevel(effectiveLevel);
+			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
 		}
 
 		this._reconnectToAgent();
@@ -3404,7 +3452,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		await this.sessionManager.flush();
 
 		if (!selectedEntry.parentId) {
-			this.sessionManager.newSession();
+			await this.sessionManager.newSession({ parentSession: previousSessionFile });
 		} else {
 			this.sessionManager.createBranchedSession(selectedEntry.parentId);
 		}
@@ -3826,6 +3874,16 @@ Be thorough - include exact file paths, function names, error messages, and tech
 	formatSessionAsText(): string {
 		const lines: string[] = [];
 
+		/** Serialize an object as XML parameter elements, one per key. */
+		function formatArgsAsXml(args: Record<string, unknown>, indent = "\t"): string {
+			const parts: string[] = [];
+			for (const [key, value] of Object.entries(args)) {
+				const text = typeof value === "string" ? value : JSON.stringify(value);
+				parts.push(`${indent}<parameter name="${key}">${text}</parameter>`);
+			}
+			return parts.join("\n");
+		}
+
 		// Include system prompt at the beginning
 		const systemPrompt = this.agent.state.systemPrompt;
 		if (systemPrompt) {
@@ -3865,12 +3923,11 @@ Be thorough - include exact file paths, function names, error messages, and tech
 		if (tools.length > 0) {
 			lines.push("## Available Tools\n");
 			for (const tool of tools) {
-				lines.push(`### ${tool.name}\n`);
+				lines.push(`<tool name="${tool.name}">`);
 				lines.push(tool.description);
-				lines.push("\n```yaml");
 				const parametersClean = stripTypeBoxFields(tool.parameters);
-				lines.push(YAML.stringify(parametersClean, null, 2));
-				lines.push("```\n");
+				lines.push(`\nParameters:\n${formatArgsAsXml(parametersClean as Record<string, unknown>)}`);
+				lines.push("<" + "/tool>\n");
 			}
 			lines.push("\n");
 		}
@@ -3902,10 +3959,11 @@ Be thorough - include exact file paths, function names, error messages, and tech
 						lines.push(c.thinking);
 						lines.push("</thinking>\n");
 					} else if (c.type === "toolCall") {
-						lines.push(`### Tool: ${c.name}`);
-						lines.push("```yaml");
-						lines.push(YAML.stringify(c.arguments, null, 2));
-						lines.push("```\n");
+						lines.push(`<invoke name="${c.name}">`);
+						if (c.arguments && typeof c.arguments === "object") {
+							lines.push(formatArgsAsXml(c.arguments as Record<string, unknown>));
+						}
+						lines.push("<" + "/invoke>\n");
 					}
 				}
 				lines.push("");

package/src/session/auth-storage.ts

@@ -34,6 +34,7 @@ import {
 } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath } from "../config";
+import { resolveConfigValue } from "../config/resolve-config-value";
 import { AgentStorage } from "./agent-storage";
 
 export type ApiKeyCredential = {
@@ -1294,7 +1295,7 @@ export class AuthStorage {
 		const apiKeySelection = this.selectCredentialByType(provider, "api_key", sessionId);
 		if (apiKeySelection) {
 			this.recordSessionCredential(provider, sessionId, "api_key", apiKeySelection.index);
-			return apiKeySelection.credential.key;
+			return resolveConfigValue(apiKeySelection.credential.key);
 		}
 
 		const oauthKey = await this.resolveOAuthApiKey(provider, sessionId, options);

package/src/session/blob-store.ts

@@ -0,0 +1,105 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+
+const BLOB_PREFIX = "blob:sha256:";
+
+/**
+ * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
+ *
+ * Files are stored at `<dir>/<sha256-hex>` with no extension. The SHA-256 hash is computed
+ * over the raw binary data (not base64). Content-addressing makes writes idempotent and
+ * provides automatic deduplication across sessions.
+ */
+export class BlobStore {
+	constructor(readonly dir: string) {}
+
+	/**
+	 * Write binary data to the blob store.
+	 * @returns SHA-256 hex hash of the data
+	 */
+	async put(data: Buffer): Promise<string> {
+		const hasher = new Bun.CryptoHasher("sha256");
+		hasher.update(data);
+		const hash = hasher.digest("hex");
+		const blobPath = path.join(this.dir, hash);
+
+		// Content-addressed: skip write if blob already exists
+		try {
+			await fs.access(blobPath);
+			return hash;
+		} catch {
+			// Does not exist, write it
+		}
+
+		await Bun.write(blobPath, data);
+		return hash;
+	}
+
+	/** Read blob by hash, returns Buffer or null if not found. */
+	async get(hash: string): Promise<Buffer | null> {
+		const blobPath = path.join(this.dir, hash);
+		try {
+			const file = Bun.file(blobPath);
+			const ab = await file.arrayBuffer();
+			return Buffer.from(ab);
+		} catch (err) {
+			if (isEnoent(err)) return null;
+			throw err;
+		}
+	}
+
+	/** Check if a blob exists. */
+	async has(hash: string): Promise<boolean> {
+		try {
+			await fs.access(path.join(this.dir, hash));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+
+/** Check if a data string is a blob reference. */
+export function isBlobRef(data: string): boolean {
+	return data.startsWith(BLOB_PREFIX);
+}
+
+/** Extract the SHA-256 hash from a blob reference string. */
+export function parseBlobRef(data: string): string | null {
+	if (!data.startsWith(BLOB_PREFIX)) return null;
+	return data.slice(BLOB_PREFIX.length);
+}
+
+/** Create a blob reference string from a SHA-256 hash. */
+export function makeBlobRef(hash: string): string {
+	return `${BLOB_PREFIX}${hash}`;
+}
+
+/**
+ * Externalize an image's base64 data to the blob store, returning a blob reference.
+ * If the data is already a blob reference, returns it unchanged.
+ */
+export async function externalizeImageData(blobStore: BlobStore, base64Data: string): Promise<string> {
+	if (isBlobRef(base64Data)) return base64Data;
+	const buffer = Buffer.from(base64Data, "base64");
+	const hash = await blobStore.put(buffer);
+	return makeBlobRef(hash);
+}
+
+/**
+ * Resolve a blob reference back to base64 data.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, logs a warning and returns a placeholder.
+ */
+export async function resolveImageData(blobStore: BlobStore, data: string): Promise<string> {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+
+	const buffer = await blobStore.get(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for image reference", { hash });
+		return data; // Return the ref as-is; downstream will see invalid base64 but won't crash
+	}
+	return buffer.toString("base64");
+}