@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/tools/exit-plan-mode.ts

@@ -21,10 +21,7 @@ export class ExitPlanModeTool implements AgentTool<typeof exitPlanModeSchema, Ex
 	public readonly description: string;
 	public readonly parameters = exitPlanModeSchema;
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(exitPlanModeDescription);
 	}
 

package/src/tools/fetch.ts

@@ -855,10 +855,8 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 	public readonly label = "Fetch";
 	public readonly description: string;
 	public readonly parameters = fetchSchema;
-	private readonly session: ToolSession;
 
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(fetchDescription);
 	}
 

package/src/tools/find.ts

@@ -118,11 +118,12 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 	public readonly description: string;
 	public readonly parameters = findSchema;
 
-	private readonly session: ToolSession;
 	private readonly customOps?: FindOperations;
 
-	constructor(session: ToolSession, options?: FindToolOptions) {
-		this.session = session;
+	constructor(
+		private readonly session: ToolSession,
+		options?: FindToolOptions,
+	) {
 		this.customOps = options?.operations;
 		this.description = renderPromptTemplate(findDescription);
 	}

package/src/tools/gemini-image.ts

@@ -1,7 +1,7 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import { getEnvApiKey, StringEnum } from "@oh-my-pi/pi-ai";
-import { $env, ptree, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
+import { $env, ptree, readSseJson, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { ModelRegistry } from "../config/model-registry";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -316,8 +316,8 @@ async function loadImageFromUrl(imageUrl: string, signal?: AbortSignal): Promise
 	if (!contentType || !contentType.startsWith("image/")) {
 		throw new Error(`Unsupported image type from URL: ${imageUrl}`);
 	}
-	const buffer = Buffer.from(await response.arrayBuffer());
-	return { data: buffer.toString("base64"), mimeType: contentType };
+	const buffer = await response.bytes();
+	return { data: buffer.toBase64(), mimeType: contentType };
 }
 
 function collectOpenRouterResponseText(message: OpenRouterMessage | undefined): string | undefined {
@@ -450,8 +450,8 @@ async function loadImageFromPath(imagePath: string, cwd: string): Promise<Inline
 		throw new Error(`Unsupported image type: ${imagePath}`);
 	}
 
-	const buffer = Buffer.from(await file.arrayBuffer());
-	return { data: buffer.toString("base64"), mimeType };
+	const buffer = await file.bytes();
+	return { data: buffer.toBase64(), mimeType };
 }
 
 async function resolveInputImage(input: ImageInput, cwd: string): Promise<InlineImageData> {
@@ -585,68 +585,37 @@ interface AntigravitySseResult {
 	usage?: GeminiUsageMetadata;
 }
 
+const _prefix = Buffer.from("data: ", "utf-8");
+
 async function parseAntigravitySseForImage(response: Response, signal?: AbortSignal): Promise<AntigravitySseResult> {
 	if (!response.body) {
 		throw new Error("No response body");
 	}
 
-	const reader = response.body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
 	const textParts: string[] = [];
 	const images: InlineImageData[] = [];
 	let usage: GeminiUsageMetadata | undefined;
 
-	try {
-		while (true) {
-			if (signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			const { done, value } = await reader.read();
-			if (done) break;
-
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() ?? "";
-
-			for (const line of lines) {
-				if (!line.startsWith("data:")) continue;
-				const jsonStr = line.slice(5).trim();
-				if (!jsonStr) continue;
-
-				const parsed = Bun.JSONL.parseChunk(`${jsonStr}\n`);
-				if (parsed.error || parsed.values.length === 0) continue;
-
-				for (const value of parsed.values) {
-					const chunk = value as AntigravityResponseChunk;
-					const responseData = chunk.response;
-					if (!responseData?.candidates) continue;
-
-					if (responseData.usageMetadata) {
-						usage = responseData.usageMetadata;
-					}
-
-					for (const candidate of responseData.candidates) {
-						const parts = candidate.content?.parts;
-						if (!parts) continue;
-						for (const part of parts) {
-							if (part.text) {
-								textParts.push(part.text);
-							}
-							if (part.inlineData?.data && part.inlineData?.mimeType) {
-								images.push({
-									data: part.inlineData.data,
-									mimeType: part.inlineData.mimeType,
-								});
-							}
-						}
-					}
+	for await (const chunk of readSseJson<AntigravityResponseChunk>(response.body, signal)) {
+		const responseData = chunk.response;
+		if (!responseData) continue;
+		if (!responseData.candidates) continue;
+		for (const candidate of responseData.candidates) {
+			const parts = candidate.content?.parts;
+			if (!parts) continue;
+			for (const part of parts) {
+				if (part.text) {
+					textParts.push(part.text);
+				}
+				const inlineData = part.inlineData;
+				if (inlineData?.data && inlineData.mimeType) {
+					images.push({ data: inlineData.data, mimeType: inlineData.mimeType });
 				}
 			}
 		}
-	} finally {
-		reader.releaseLock();
+		if (responseData.usageMetadata) {
+			usage = responseData.usageMetadata;
+		}
 	}
 
 	return { images, text: textParts, usage };

package/src/tools/grep.ts

@@ -66,10 +66,10 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 	public readonly description: string;
 	public readonly parameters = grepSchema;
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession, _options?: GrepToolOptions) {
-		this.session = session;
+	constructor(
+		private readonly session: ToolSession,
+		_options?: GrepToolOptions,
+	) {
 		this.description = renderPromptTemplate(grepDescription);
 	}
 

package/src/tools/index.ts

@@ -14,7 +14,7 @@ import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
 import type { EventBus } from "../utils/event-bus";
 import { time } from "../utils/timings";
-import { WebSearchTool } from "../web/search";
+import { SearchTool } from "../web/search";
 import { AskTool } from "./ask";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
@@ -51,16 +51,14 @@ export {
 export { EditTool, type EditToolDetails } from "../patch";
 export { BUNDLED_AGENTS, TaskTool } from "../task";
 export {
-	companyWebSearchTools,
-	exaWebSearchTools,
-	getWebSearchTools,
-	hasExaWebSearch,
-	linkedinWebSearchTools,
-	setPreferredWebSearchProvider,
-	type WebSearchProvider,
-	type WebSearchResponse,
-	WebSearchTool,
-	type WebSearchToolsOptions,
+	companySearchTools,
+	exaSearchTools,
+	getSearchTools,
+	type SearchProvider,
+	type SearchResponse,
+	SearchTool,
+	type SearchToolsOptions,
+	setPreferredSearchProvider,
 	webSearchCodeContextTool,
 	webSearchCompanyTool,
 	webSearchCrawlTool,
@@ -179,7 +177,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	task: TaskTool.create,
 	todo_write: s => new TodoWriteTool(s),
 	fetch: s => new FetchTool(s),
-	web_search: s => new WebSearchTool(s),
+	web_search: s => new SearchTool(s),
 	write: s => new WriteTool(s),
 };
 
@@ -314,9 +312,9 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	const slowTools: Array<{ name: string; ms: number }> = [];
 	const results = await Promise.all(
 		entries.map(async ([name, factory]) => {
-			const start = performance.now();
+			const start = Bun.nanoseconds();
 			const tool = await factory(session);
-			const elapsed = performance.now() - start;
+			const elapsed = (Bun.nanoseconds() - start) / 1e6;
 			if (elapsed > 5) {
 				slowTools.push({ name, ms: Math.round(elapsed) });
 			}

package/src/tools/notebook.ts

@@ -67,11 +67,7 @@ export class NotebookTool implements AgentTool<typeof notebookSchema, NotebookTo
 	public readonly parameters = notebookSchema;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
-	}
+	constructor(private readonly session: ToolSession) {}
 
 	public async execute(
 		_toolCallId: string,

package/src/tools/python.ts

@@ -148,11 +148,12 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 	public readonly parameters = pythonSchema;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession | null;
 	private readonly proxyExecutor?: PythonProxyExecutor;
 
-	constructor(session: ToolSession | null, options?: PythonToolOptions) {
-		this.session = session;
+	constructor(
+		private readonly session: ToolSession | null,
+		options?: PythonToolOptions,
+	) {
 		this.proxyExecutor = options?.proxyExecutor;
 		this.description = getPythonToolDescription();
 	}

package/src/tools/read.ts

@@ -538,12 +538,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	public readonly parameters = readSchema;
 	public readonly nonAbortable = true;
 
-	private readonly session: ToolSession;
 	private readonly autoResizeImages: boolean;
 	private readonly defaultLineNumbers: boolean;
 
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.autoResizeImages = session.settings.get("images.autoResize");
 		this.defaultLineNumbers = session.settings.get("readLineNumbers");
 		this.description = renderPromptTemplate(readDescription, {
@@ -633,7 +631,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					const maxStr = formatSize(MAX_IMAGE_SIZE);
 					throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
 				} else {
-					const base64 = Buffer.from(buffer).toString("base64");
+					const base64 = new Uint8Array(buffer).toBase64();
 
 					if (this.autoResizeImages) {
 						// Resize image if needed - catch errors from Photon

package/src/tools/render-utils.ts

@@ -327,6 +327,19 @@ interface ParsedDiagnostic {
 	code?: string;
 }
 
+function getSeverityRank(severity: ParsedDiagnostic["severity"]): number {
+	switch (severity) {
+		case "error":
+			return 0;
+		case "warning":
+			return 1;
+		case "info":
+			return 2;
+		case "hint":
+			return 3;
+	}
+}
+
 function parseDiagnosticMessage(msg: string): ParsedDiagnostic | null {
 	const match = msg.match(/^(.+?):(\d+):(\d+)\s+\[(\w+)\]\s+(?:\[([^\]]+)\]\s+)?(.+?)(?:\s+\(([^)]+)\))?$/);
 	if (!match) return null;
@@ -363,6 +376,16 @@ export function formatDiagnostics(
 		}
 	}
 
+	for (const diagnostics of byFile.values()) {
+		diagnostics.sort((a, b) => {
+			const severityCompare = getSeverityRank(a.severity) - getSeverityRank(b.severity);
+			if (severityCompare !== 0) return severityCompare;
+			if (a.line !== b.line) return a.line - b.line;
+			if (a.col !== b.col) return a.col - b.col;
+			return a.message.localeCompare(b.message);
+		});
+	}
+
 	const headerIcon = diag.errored
 		? theme.styledSymbol("status.error", "error")
 		: theme.styledSymbol("status.warning", "warning");

package/src/tools/ssh.ts

@@ -126,22 +126,18 @@ interface SshToolParams {
 export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	public readonly name = "ssh";
 	public readonly label = "SSH";
-	public readonly description: string;
 	public readonly parameters = sshSchema;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession;
-
 	private readonly allowedHosts: Set<string>;
-	private readonly hostsByName: Map<string, SSHHost>;
-	private readonly hostNames: string[];
-
-	constructor(session: ToolSession, hostNames: string[], hostsByName: Map<string, SSHHost>, description: string) {
-		this.session = session;
-		this.hostNames = hostNames;
-		this.hostsByName = hostsByName;
-		this.allowedHosts = new Set(hostNames);
-		this.description = description;
+
+	constructor(
+		private readonly session: ToolSession,
+		private readonly hostNames: string[],
+		private readonly hostsByName: Map<string, SSHHost>,
+		public readonly description: string,
+	) {
+		this.allowedHosts = new Set(this.hostNames);
 	}
 
 	public async execute(

package/src/tools/todo-write.ts

@@ -156,10 +156,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 	public readonly parameters = todoWriteSchema;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		this.description = renderPromptTemplate(todoWriteDescription);
 	}
 

package/src/tools/tool-errors.ts

@@ -36,12 +36,9 @@ export interface ErrorEntry {
  * Error with multiple entries (e.g., multiple validation failures, batch errors).
  */
 export class MultiError extends ToolError {
-	readonly errors: ErrorEntry[];
-
-	constructor(errors: ErrorEntry[]) {
+	constructor(readonly errors: ErrorEntry[]) {
 		super(errors.map(e => e.message).join("; "));
 		this.name = "MultiError";
-		this.errors = errors;
 	}
 
 	render(): string {

package/src/tools/write.ts

@@ -74,11 +74,9 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 	public readonly nonAbortable = true;
 	public readonly concurrency = "exclusive";
 
-	private readonly session: ToolSession;
 	private readonly writethrough: WritethroughCallback;
 
-	constructor(session: ToolSession) {
-		this.session = session;
+	constructor(private readonly session: ToolSession) {
 		const enableLsp = session.enableLsp ?? true;
 		const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
 		const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnWrite");

package/src/utils/external-editor.ts

@@ -0,0 +1,59 @@
+/**
+ * Utilities for launching an external text editor ($VISUAL / $EDITOR).
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $env, Snowflake } from "@oh-my-pi/pi-utils";
+
+/** Returns the user's preferred editor command, or undefined if not configured. */
+export function getEditorCommand(): string | undefined {
+	return $env.VISUAL || $env.EDITOR || undefined;
+}
+
+export interface OpenInEditorOptions {
+	/** File extension for the temp file (default: ".md"). */
+	extension?: string;
+	/** Custom stdio configuration (default: all "inherit"). */
+	stdio?: [number | "inherit", number | "inherit", number | "inherit"];
+}
+
+/**
+ * Opens `content` in the user's external editor and returns the edited text.
+ * Returns `null` if the editor exits with a non-zero code.
+ *
+ * The caller is responsible for stopping/starting the TUI around this call.
+ */
+export async function openInEditor(
+	editorCmd: string,
+	content: string,
+	options?: OpenInEditorOptions,
+): Promise<string | null> {
+	const ext = options?.extension ?? ".md";
+	const tmpFile = path.join(os.tmpdir(), `omp-editor-${Snowflake.next()}${ext}`);
+
+	try {
+		await Bun.write(tmpFile, content);
+
+		const [editor, ...editorArgs] = editorCmd.split(" ");
+		const stdio = options?.stdio ?? ["inherit", "inherit", "inherit"];
+
+		const child = spawn(editor, [...editorArgs, tmpFile], { stdio });
+		const exitCode = await new Promise<number>((resolve, reject) => {
+			child.once("exit", (code, signal) => resolve(code ?? (signal ? -1 : 0)));
+			child.once("error", error => reject(error));
+		});
+
+		if (exitCode === 0) {
+			return (await Bun.file(tmpFile).text()).replace(/\n$/, "");
+		}
+		return null;
+	} finally {
+		try {
+			await fs.rm(tmpFile, { force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+}

package/src/utils/file-mentions.ts

@@ -5,12 +5,15 @@
  * we automatically inject the file contents as a FileMentionMessage
  * so the agent doesn't need to read them manually.
  */
+import * as fs from "node:fs/promises";
 import path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { FileMentionMessage } from "../session/messages";
 import { resolveReadPath } from "../tools/path-utils";
 import { formatAge } from "../tools/render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead, truncateStringToBytesFromStart } from "../tools/truncate";
+import { formatDimensionNote, resizeImage } from "./image-resize";
+import { detectSupportedImageMimeTypeFromFile } from "./mime";
 
 /** Regex to match @filepath patterns in text */
 const FILE_MENTION_REGEX = /@([^\s@]+)/g;
@@ -156,9 +159,15 @@ export function extractFileMentions(text: string): string[] {
  * Generate a FileMentionMessage containing the contents of mentioned files.
  * Returns empty array if no files could be read.
  */
-export async function generateFileMentionMessages(filePaths: string[], cwd: string): Promise<AgentMessage[]> {
+export async function generateFileMentionMessages(
+	filePaths: string[],
+	cwd: string,
+	options?: { autoResizeImages?: boolean },
+): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
+	const autoResizeImages = options?.autoResizeImages ?? true;
+
 	const files: FileMentionMessage["files"] = [];
 
 	for (const filePath of filePaths) {
@@ -172,6 +181,35 @@ export async function generateFileMentionMessages(filePaths: string[], cwd: stri
 				continue;
 			}
 
+			const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+			if (mimeType) {
+				const buffer = await fs.readFile(absolutePath);
+				if (buffer.length === 0) {
+					continue;
+				}
+
+				const base64Content = buffer.toBase64();
+				let image = { type: "image" as const, mimeType, data: base64Content };
+				let dimensionNote: string | undefined;
+
+				if (autoResizeImages) {
+					try {
+						const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
+						dimensionNote = formatDimensionNote(resized);
+						image = {
+							type: "image" as const,
+							mimeType: resized.mimeType,
+							data: resized.data,
+						};
+					} catch {
+						image = { type: "image" as const, mimeType, data: base64Content };
+					}
+				}
+
+				files.push({ path: filePath, content: dimensionNote ?? "", image });
+				continue;
+			}
+
 			const content = await Bun.file(absolutePath).text();
 			const { output, lineCount } = buildTextOutput(content);
 			files.push({ path: filePath, content: output, lineCount });

package/src/utils/image-convert.ts

@@ -17,7 +17,7 @@ export async function convertToPng(
 		const image = await PhotonImage.parse(new Uint8Array(Buffer.from(base64Data, "base64")));
 		const pngBuffer = await image.encode(ImageFormat.PNG, 100);
 		return {
-			data: Buffer.from(pngBuffer).toString("base64"),
+			data: Buffer.from(pngBuffer).toBase64(),
 			mimeType: "image/png",
 		};
 	} catch {

package/src/utils/image-resize.ts

@@ -119,7 +119,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 		if (best.buffer.length <= opts.maxBytes) {
 			return {
-				data: Buffer.from(best.buffer).toString("base64"),
+				data: best.buffer.toBase64(),
 				mimeType: best.mimeType,
 				originalWidth,
 				originalHeight,
@@ -135,7 +135,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 			if (best.buffer.length <= opts.maxBytes) {
 				return {
-					data: Buffer.from(best.buffer).toString("base64"),
+					data: best.buffer.toBase64(),
 					mimeType: best.mimeType,
 					originalWidth,
 					originalHeight,
@@ -160,7 +160,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 				if (best.buffer.length <= opts.maxBytes) {
 					return {
-						data: Buffer.from(best.buffer).toString("base64"),
+						data: best.buffer.toBase64(),
 						mimeType: best.mimeType,
 						originalWidth,
 						originalHeight,
@@ -174,7 +174,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 		// Last resort: return smallest version we produced
 		return {
-			data: Buffer.from(best.buffer).toString("base64"),
+			data: best.buffer.toBase64(),
 			mimeType: best.mimeType,
 			originalWidth,
 			originalHeight,

package/src/web/search/auth.ts

@@ -7,13 +7,11 @@
  *   3. OAuth credentials in ~/.omp/agent/agent.db (with expiry check)
  *   4. ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL fallback
  */
-import * as path from "node:path";
 import { buildAnthropicHeaders as buildProviderAnthropicHeaders, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import { $env, logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath, getConfigDirPaths } from "../../config";
 import { AgentStorage } from "../../session/agent-storage";
-import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "../../session/auth-storage";
-import { migrateJsonStorage } from "../../session/storage-migration";
+import type { AuthCredential } from "../../session/auth-storage";
 import type { AnthropicAuthConfig, AnthropicOAuthCredential, ModelsJson } from "./types";
 
 const DEFAULT_BASE_URL = "https://api.anthropic.com";
@@ -60,36 +58,12 @@ function toAnthropicOAuthCredential(credential: AuthCredential): AnthropicOAuthC
 	};
 }
 
-function normalizeAuthEntry(entry: AuthCredentialEntry | undefined): AuthCredential[] {
-	if (!entry) return [];
-	return Array.isArray(entry) ? entry : [entry];
-}
-
-async function readLegacyAnthropicOAuthCredentials(configDir: string): Promise<AnthropicOAuthCredential[]> {
-	const authJson = await readJson<AuthStorageData>(path.join(configDir, "auth.json"));
-	if (!authJson) return [];
-	const entry = authJson.anthropic as AuthCredentialEntry | undefined;
-	const credentials = normalizeAuthEntry(entry);
-	const results: AnthropicOAuthCredential[] = [];
-	for (const credential of credentials) {
-		const mapped = toAnthropicOAuthCredential(credential);
-		if (mapped) results.push(mapped);
-	}
-	return results;
-}
-
 /**
- * Reads Anthropic OAuth credentials from agent.db, migrating from legacy auth.json if needed.
+ * Reads Anthropic OAuth credentials from agent.db.
  * @param configDir - Path to the config directory containing agent.db
  * @returns Array of valid Anthropic OAuth credentials
  */
 async function readAnthropicOAuthCredentials(configDir: string): Promise<AnthropicOAuthCredential[]> {
-	await migrateJsonStorage({
-		agentDir: configDir,
-		settingsPath: path.join(configDir, "settings.json"),
-		authPaths: [path.join(configDir, "auth.json")],
-	});
-
 	const storage = await AgentStorage.open(getAgentDbPath(configDir));
 	const records = storage.listAuthCredentials("anthropic");
 	const credentials: AnthropicOAuthCredential[] = [];
@@ -100,10 +74,6 @@ async function readAnthropicOAuthCredentials(configDir: string): Promise<Anthrop
 		}
 	}
 
-	if (credentials.length === 0) {
-		return readLegacyAnthropicOAuthCredentials(configDir);
-	}
-
 	return credentials;
 }
 
@@ -132,7 +102,7 @@ export async function findAnthropicAuth(): Promise<AnthropicAuthConfig | null> {
 
 	// 2. Provider with api="anthropic-messages" in models.json (check all config dirs)
 	for (const configDir of configDirs) {
-		const modelsJson = await readJson<ModelsJson>(path.join(configDir, "models.json"));
+		const modelsJson = await readJson<ModelsJson>(`${configDir}/models.json`);
 		if (modelsJson?.providers) {
 			// First pass: look for providers with actual API keys
 			for (const [_name, provider] of Object.entries(modelsJson.providers)) {