@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/src/web/search/providers/tavily.ts

@@ -4,13 +4,13 @@
  * Uses Tavily's agent-focused search API to return structured results with an
  * optional synthesized answer.
  */
-import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { type AuthStorage, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { clampNumResults, dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
-import { classifyProviderHttpError, findCredential, isApiKeyAvailable, withHardTimeout } from "./utils";
+import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const TAVILY_SEARCH_URL = "https://api.tavily.com/search";
 const DEFAULT_NUM_RESULTS = 5;
@@ -58,9 +58,13 @@ function getErrorMessage(value: unknown): string | null {
 	return null;
 }
 
-/** Find Tavily API key from environment or agent.db credentials. */
-export async function findApiKey(): Promise<string | null> {
-	return findCredential(getEnvApiKey("tavily"), "tavily");
+/** Find Tavily API key through AuthStorage's unified refresh pipeline. */
+export async function findApiKey(
+	authStorage: AuthStorage,
+	sessionId: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string | null> {
+	return (await authStorage.getApiKey("tavily", sessionId, { signal })) ?? null;
 }
 
 /** Exported for testing. Builds the Tavily request body from unified params. */
@@ -116,16 +120,22 @@ async function callTavilySearch(apiKey: string, params: TavilySearchParams): Pro
 }
 
 /** Execute Tavily web search. */
-export async function searchTavily(params: TavilySearchParams): Promise<SearchResponse> {
-	const apiKey = await findApiKey();
+export async function searchTavily(params: SearchParams): Promise<SearchResponse> {
+	const tavilyParams: TavilySearchParams = {
+		query: params.query,
+		num_results: params.numSearchResults ?? params.limit,
+		recency: params.recency,
+		signal: params.signal,
+	};
+	const apiKey = await findApiKey(params.authStorage, params.sessionId, params.signal);
 	if (!apiKey) {
 		throw new Error(
-			'Tavily credentials not found. Set TAVILY_API_KEY or store an API key for provider "tavily" in agent.db.',
+			'Tavily credentials not found. Set TAVILY_API_KEY or configure an API key for provider "tavily".',
 		);
 	}
 
-	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
-	const response = await callTavilySearch(apiKey, params);
+	const numResults = clampNumResults(tavilyParams.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	const response = await callTavilySearch(apiKey, tavilyParams);
 	const sources: SearchSource[] = [];
 
 	for (const result of response.results ?? []) {
@@ -153,16 +163,11 @@ export class TavilyProvider extends SearchProvider {
 	readonly id = "tavily";
 	readonly label = "Tavily";
 
-	isAvailable(): Promise<boolean> {
-		return isApiKeyAvailable(findApiKey);
+	isAvailable(authStorage: AuthStorage): boolean {
+		return authStorage.hasAuth("tavily") || !!getEnvApiKey("tavily");
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
-		return searchTavily({
-			query: params.query,
-			num_results: params.numSearchResults ?? params.limit,
-			recency: params.recency,
-			signal: params.signal,
-		});
+		return searchTavily(params);
 	}
 }

package/src/web/search/providers/utils.ts

@@ -1,5 +1,4 @@
-import { getAgentDbPath } from "@oh-my-pi/pi-utils";
-import { AgentStorage } from "../../../session/agent-storage";
+import type { AgentStorage } from "../../../session/agent-storage";
 import { SearchProviderError, type SearchProviderId, type SearchSource } from "../../../web/search/types";
 import { dateToAgeSeconds } from "../utils";
 
@@ -7,17 +6,24 @@ import { dateToAgeSeconds } from "../utils";
  * Search for an API credential by checking an env-derived key first,
  * then falling back to agent.db stored credentials for the given providers.
  *
+ * The caller MUST supply an open {@link AgentStorage} handle so the helper
+ * never reaches out to global filesystem state; both the unified web_search
+ * chain and one-shot CLI calls open storage exactly once and thread it
+ * through every provider.
+ *
+ * @param storage - Open agent storage handle
  * @param envKey - Pre-resolved environment variable value (or null)
  * @param storageProviders - Provider names to look up in AgentStorage
  */
-export async function findCredential(
+export function findCredential(
+	storage: AgentStorage | null | undefined,
 	envKey: string | null | undefined,
 	...storageProviders: string[]
-): Promise<string | null> {
+): string | null {
 	if (envKey) return envKey;
+	if (!storage) return null;
 
 	try {
-		const storage = await AgentStorage.open(getAgentDbPath());
 		for (const provider of storageProviders) {
 			const records = storage.listAuthCredentials(provider);
 			for (const record of records) {
@@ -37,18 +43,6 @@ export async function findCredential(
 	return null;
 }
 
-/**
- * Probe whether a provider's API key lookup resolves to a truthy value.
- * Swallows lookup errors and reports unavailability.
- */
-export async function isApiKeyAvailable(findApiKey: () => string | null | Promise<string | null>) {
-	try {
-		return !!(await findApiKey());
-	} catch {
-		return false;
-	}
-}
-
 /**
  * Default hard ceiling for a single web-search round-trip. 60s tolerates
  * legitimate slow LLM-mediated responses (anthropic web_search_20250305,

package/src/web/search/providers/zai.ts

@@ -4,14 +4,14 @@
  * Calls Z.AI's remote MCP server (`webSearchPrime`) and adapts results into
  * the unified SearchResponse shape used by the web search tool.
  */
-import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { type AuthStorage, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import { asRecord, asString } from "../../../web/scrapers/utils";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { dateToAgeSeconds } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
-import { classifyProviderHttpError, findCredential, isApiKeyAvailable, withHardTimeout } from "./utils";
+import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const ZAI_MCP_URL = "https://api.z.ai/api/mcp/web_search_prime/mcp";
 const ZAI_TOOL_NAME = "web_search_prime";
@@ -21,6 +21,8 @@ export interface ZaiSearchParams {
 	query: string;
 	num_results?: number;
 	signal?: AbortSignal;
+	authStorage: AuthStorage;
+	sessionId?: string;
 }
 
 interface ZaiSearchResult {
@@ -51,9 +53,13 @@ interface JsonRpcPayload {
 	error?: JsonRpcError;
 }
 
-/** Find Z.AI API credentials from environment or saved auth storage. */
-export async function findApiKey(): Promise<string | null> {
-	return findCredential(getEnvApiKey("zai"), "zai");
+/** Resolve Z.AI API credentials through the unified auth storage pipeline. */
+export async function findApiKey(
+	authStorage: AuthStorage,
+	sessionId?: string,
+	signal?: AbortSignal,
+): Promise<string | null> {
+	return (await authStorage.getApiKey("zai", sessionId, { signal })) ?? null;
 }
 
 async function callZaiTool(apiKey: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
@@ -272,7 +278,7 @@ function toSources(results: ZaiSearchResult[]): SearchSource[] {
 
 /** Execute Z.AI web search via remote MCP endpoint. */
 export async function searchZai(params: ZaiSearchParams): Promise<SearchResponse> {
-	const apiKey = await findApiKey();
+	const apiKey = await findApiKey(params.authStorage, params.sessionId, params.signal);
 	if (!apiKey) {
 		throw new Error("Z.AI credentials not found. Set ZAI_API_KEY or login with 'omp /login zai'.");
 	}
@@ -298,8 +304,8 @@ export class ZaiProvider extends SearchProvider {
 	readonly id = "zai";
 	readonly label = "Z.AI";
 
-	isAvailable(): Promise<boolean> {
-		return isApiKeyAvailable(findApiKey);
+	isAvailable(authStorage: AuthStorage): Promise<boolean> | boolean {
+		return authStorage.hasAuth("zai") || !!getEnvApiKey("zai");
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
@@ -307,6 +313,8 @@ export class ZaiProvider extends SearchProvider {
 			query: params.query,
 			num_results: params.numSearchResults ?? params.limit,
 			signal: params.signal,
+			authStorage: params.authStorage,
+			sessionId: params.sessionId,
 		});
 	}
 }

package/dist/types/hashline/parser.d.ts

@@ -1,7 +0,0 @@
-import type { HashlineCursor, HashlineEdit } from "./types";
-export declare function cloneCursor(cursor: HashlineCursor): HashlineCursor;
-export declare function parseHashline(diff: string): HashlineEdit[];
-export declare function parseHashlineWithWarnings(diff: string): {
-    edits: HashlineEdit[];
-    warnings: string[];
-};

package/dist/types/mcp/discoverable-tool-metadata.d.ts

@@ -1,7 +0,0 @@
-/**
- * Back-compat re-export layer.
- * All types and functions have moved to src/tool-discovery/tool-index.ts.
- * This file exists solely so existing imports continue to compile without changes.
- */
-export type { DiscoverableMCPSearchDocument, DiscoverableMCPSearchIndex, DiscoverableMCPSearchResult, DiscoverableMCPTool, DiscoverableMCPToolServerSummary, DiscoverableMCPToolSummary, } from "../tool-discovery/tool-index";
-export { buildDiscoverableMCPSearchIndex, collectDiscoverableMCPTools, formatDiscoverableMCPToolServerSummary, getDiscoverableMCPTool, isMCPToolName, searchDiscoverableMCPTools, selectDiscoverableMCPToolNamesByServer, summarizeDiscoverableMCPTools, } from "../tool-discovery/tool-index";

package/dist/types/tools/vim.d.ts

@@ -1,58 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { type Theme } from "../modes/theme/theme";
-import type { VimToolDetails } from "../vim/types";
-import type { ToolSession } from ".";
-declare const vimSchema: z.ZodObject<{
-    file: z.ZodString;
-    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        kbd: z.ZodArray<z.ZodString>;
-        insert: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    pause: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type VimParams = z.infer<typeof vimSchema>;
-interface VimRenderStep {
-    kbd?: string[];
-    insert?: string;
-}
-export interface VimRenderArgs {
-    file?: string;
-    steps?: VimRenderStep[];
-    pause?: boolean;
-    __partialJson?: string;
-}
-export declare class VimTool implements AgentTool<typeof vimSchema, VimToolDetails> {
-    #private;
-    private readonly session;
-    readonly name = "vim";
-    readonly label = "Vim";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        file: z.ZodString;
-        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            kbd: z.ZodArray<z.ZodString>;
-            insert: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        pause: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
-    readonly concurrency = "exclusive";
-    constructor(session: ToolSession);
-    execute(_toolCallId: string, params: VimParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<VimToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<VimToolDetails>>;
-}
-export declare function resetVimRendererStateForTest(): void;
-export declare const vimToolRenderer: {
-    renderCall(args: VimRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: VimToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme): Component;
-    mergeCallAndResult: boolean;
-};
-export { vimSchema };

package/dist/types/vim/buffer.d.ts

@@ -1,41 +0,0 @@
-import { type Position, type VimBufferSnapshot, type VimFingerprint, type VimLoadedFile } from "./types";
-export declare function snapshotEqual(left: VimBufferSnapshot, right: VimBufferSnapshot): boolean;
-export declare class VimBuffer {
-    displayPath: string;
-    filePath: string;
-    lines: string[];
-    cursor: Position;
-    modified: boolean;
-    trailingNewline: boolean;
-    baseFingerprint: VimFingerprint | null;
-    editabilityChecked: boolean;
-    constructor(input: VimLoadedFile);
-    clone(): VimBuffer;
-    createSnapshot(): VimBufferSnapshot;
-    restore(snapshot: VimBufferSnapshot): void;
-    replaceLoadedFile(input: VimLoadedFile): void;
-    markSaved(input: VimLoadedFile): void;
-    lineCount(): number;
-    lastLineIndex(): number;
-    getLine(line: number): string;
-    clampLine(line: number): number;
-    clampCol(line: number, col: number): number;
-    setCursor(position: Position): void;
-    clampCursor(): void;
-    firstNonBlank(line: number): number;
-    getText(): string;
-    setText(text: string, trailingNewline?: boolean): void;
-    currentOffset(): number;
-    positionToOffset(position: Position): number;
-    offsetToPosition(offset: number): Position;
-    setCursorFromOffset(offset: number): void;
-    replaceOffsets(start: number, end: number, replacement: string, cursorOffset?: number): void;
-    deleteOffsets(start: number, end: number): string;
-    deleteLines(startLine: number, endLine: number): string[];
-    insertLines(index: number, newLines: string[]): void;
-    replaceLine(line: number, content: string): void;
-    joinLines(startLine: number, count: number): void;
-    indentLines(startLine: number, endLine: number, indentUnit: string, direction: 1 | -1): void;
-    getCharacterAtOffset(offset: number): string;
-    getCharacter(position: Position): string;
-}

package/dist/types/vim/commands.d.ts

@@ -1,6 +0,0 @@
-import type { VimExCommand } from "./types";
-export interface VimExParseContext {
-    currentLine: number;
-    lastLine: number;
-}
-export declare function parseExCommand(input: string, context?: VimExParseContext): VimExCommand;

package/dist/types/vim/engine.d.ts

@@ -1,47 +0,0 @@
-import type { FileDiagnosticsResult } from "../lsp";
-import { type VimBuffer } from "./buffer";
-import type { Position, VimInputMode, VimKeyToken, VimLoadedFile, VimPendingInput, VimRegister, VimSearchState, VimSelection } from "./types";
-export interface VimSaveResult {
-    loaded: VimLoadedFile;
-    diagnostics?: FileDiagnosticsResult;
-}
-export interface VimEngineCallbacks {
-    beforeMutate: (buffer: VimBuffer) => Promise<void>;
-    loadBuffer: (path: string) => Promise<VimLoadedFile>;
-    saveBuffer: (buffer: VimBuffer, options?: {
-        force?: boolean;
-    }) => Promise<VimSaveResult>;
-}
-export declare class VimEngine {
-    #private;
-    buffer: VimBuffer;
-    inputMode: VimInputMode;
-    selectionAnchor: Position | null;
-    register: VimRegister;
-    lastSearch: VimSearchState | null;
-    lastCharFind: {
-        char: string;
-        mode: "f" | "F" | "t" | "T";
-    } | null;
-    lastVisual: {
-        anchor: Position;
-        cursor: Position;
-        mode: VimInputMode;
-    } | null;
-    lastCommand?: string;
-    statusMessage?: string;
-    diagnostics?: FileDiagnosticsResult;
-    viewportStart: number;
-    closed: boolean;
-    constructor(buffer: VimBuffer, callbacks: VimEngineCallbacks);
-    clone(callbacks?: Partial<VimEngineCallbacks>): VimEngine;
-    getPublicMode(): import("./types").VimMode;
-    getSelection(): VimSelection | undefined;
-    getPendingInput(): VimPendingInput | undefined;
-    rollbackPendingInsert(): void;
-    setCursor(line: number, col: number): void;
-    executeTokens(tokens: readonly VimKeyToken[], lastCommand?: string, onStep?: () => Promise<void>): Promise<void>;
-    close(force: boolean): Promise<void>;
-    centerViewportOnCursor(size?: number): void;
-    applyLiteralInsert(text: string, exitInsertMode: boolean): Promise<void>;
-}

package/dist/types/vim/parser.d.ts

@@ -1,3 +0,0 @@
-import { type VimKeyToken } from "./types";
-export declare function parseKeySequences(sequences: string[]): VimKeyToken[];
-export declare function replayTokens(values: readonly string[]): VimKeyToken[];

package/dist/types/vim/render.d.ts

@@ -1,25 +0,0 @@
-import type { VimErrorLocation, VimMode, VimPendingInput, VimSelection, VimToolDetails, VimViewport } from "./types";
-export declare const VIM_OPEN_VIEWPORT_LINES = 80;
-export declare const VIM_DEFAULT_VIEWPORT_LINES = 10;
-interface ViewportRenderInput {
-    file: string;
-    mode: VimMode;
-    cursor: {
-        line: number;
-        col: number;
-    };
-    totalLines: number;
-    modified: boolean;
-    lines: string[];
-    viewport: VimViewport;
-    selection?: VimSelection;
-    statusMessage?: string;
-    lastCommand?: string;
-    pendingInput?: VimPendingInput;
-    errorLocation?: VimErrorLocation;
-    closed?: boolean;
-}
-export declare function computeViewport(cursorLine: number, totalLines: number, size: number, preferredStart?: number): VimViewport;
-export declare function renderVimDetails(details: VimToolDetails): string;
-export declare function buildDetails(input: ViewportRenderInput): VimToolDetails;
-export {};

package/dist/types/vim/types.d.ts

@@ -1,182 +0,0 @@
-import type { FileDiagnosticsResult } from "../lsp";
-import type { OutputMeta } from "../tools/output-meta";
-export type VimMode = "NORMAL" | "INSERT" | "VISUAL" | "VISUAL-LINE" | "COMMAND";
-export type VimInputMode = "normal" | "insert" | "visual" | "visual-line" | "command" | "search-forward" | "search-backward";
-export interface Position {
-    line: number;
-    col: number;
-}
-export interface VimViewport {
-    start: number;
-    end: number;
-}
-export interface VimSelection {
-    kind: "char" | "line";
-    start: Position;
-    end: Position;
-}
-export interface VimFocusLine {
-    line: number;
-    text: string;
-    windowStartCol: number;
-    windowEndCol: number;
-    caretCol: number;
-}
-export interface VimViewportLine {
-    line: number;
-    text: string;
-    isCursor: boolean;
-    isSelected: boolean;
-    cursorCol?: number;
-}
-export interface VimPendingInput {
-    kind: "insert" | "command" | "search-forward" | "search-backward";
-    text: string;
-}
-export interface VimErrorLocation {
-    sequenceIndex: number;
-    offset: number;
-}
-export interface VimToolDetails {
-    file: string;
-    mode: VimMode;
-    cursor: {
-        line: number;
-        col: number;
-    };
-    totalLines: number;
-    modified: boolean;
-    viewport: VimViewport;
-    focus?: VimFocusLine;
-    viewportLines?: VimViewportLine[];
-    selection?: VimSelection;
-    pendingInput?: VimPendingInput;
-    errorLocation?: VimErrorLocation;
-    closed?: boolean;
-    meta?: OutputMeta;
-    lastCommand?: string;
-    statusMessage?: string;
-    diagnostics?: FileDiagnosticsResult;
-}
-export interface VimFingerprint {
-    exists: boolean;
-    size: number;
-    mtimeMs: number;
-    hash: string;
-}
-export interface VimLoadedFile {
-    absolutePath: string;
-    displayPath: string;
-    lines: string[];
-    trailingNewline: boolean;
-    fingerprint: VimFingerprint | null;
-}
-export interface VimKeyToken {
-    value: string;
-    display: string;
-    sequenceIndex: number;
-    offset: number;
-}
-export interface VimRegister {
-    kind: "char" | "line";
-    text: string;
-}
-export interface VimSearchState {
-    pattern: string;
-    direction: 1 | -1;
-}
-export interface VimBufferSnapshot {
-    displayPath: string;
-    filePath: string;
-    lines: string[];
-    cursor: Position;
-    modified: boolean;
-    trailingNewline: boolean;
-    baseFingerprint: VimFingerprint | null;
-    editabilityChecked: boolean;
-}
-export interface VimUndoEntry {
-    before: VimBufferSnapshot;
-    after: VimBufferSnapshot;
-}
-export interface VimLineRange {
-    start: number;
-    end: number;
-}
-export type VimExCommand = {
-    kind: "write";
-    force: boolean;
-} | {
-    kind: "update";
-    force: boolean;
-} | {
-    kind: "quit";
-    force: boolean;
-} | {
-    kind: "write-quit";
-    force: boolean;
-} | {
-    kind: "edit";
-    force: boolean;
-    path?: string;
-} | {
-    kind: "goto-line";
-    line: number;
-} | {
-    kind: "substitute";
-    range?: VimLineRange | "all";
-    pattern: string;
-    replacement: string;
-    flags: string;
-} | {
-    kind: "delete";
-    range?: VimLineRange | "all";
-} | {
-    kind: "yank";
-    range?: VimLineRange | "all";
-} | {
-    kind: "put";
-    range?: VimLineRange | "all";
-    before: boolean;
-} | {
-    kind: "copy";
-    range?: VimLineRange | "all";
-    destination: number;
-} | {
-    kind: "move";
-    range?: VimLineRange | "all";
-    destination: number;
-} | {
-    kind: "sort";
-    range?: VimLineRange | "all";
-    flags: string;
-} | {
-    kind: "join";
-    range?: VimLineRange | "all";
-    trimWhitespace: boolean;
-} | {
-    kind: "global";
-    range?: VimLineRange | "all";
-    pattern: string;
-    command: string;
-    invert: boolean;
-} | {
-    kind: "append";
-    range?: VimLineRange;
-    text: string;
-} | {
-    kind: "insert-before";
-    range?: VimLineRange;
-    text: string;
-};
-export declare class VimInputError extends Error {
-    location?: {
-        sequenceIndex: number;
-        offset: number;
-    };
-    constructor(message: string, token?: VimKeyToken);
-}
-export declare function clonePosition(position: Position): Position;
-export declare function minPosition(left: Position, right: Position): Position;
-export declare function maxPosition(left: Position, right: Position): Position;
-export declare function toPublicMode(mode: VimInputMode): VimMode;