@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.2

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -0,0 +1,42 @@
+import { type AutocompleteItem, type AutocompleteProvider, type SlashCommand } from "@oh-my-pi/pi-tui";
+import { type KeybindingsManager } from "../config/keybindings";
+interface PromptActionDefinition {
+    id: string;
+    label: string;
+    description: string;
+    keywords: string[];
+    execute: (prefix: string) => void;
+}
+interface PromptActionAutocompleteOptions {
+    commands: SlashCommand[];
+    basePath: string;
+    keybindings: KeybindingsManager;
+    copyCurrentLine: () => void;
+    copyPrompt: () => void;
+    undo: (prefix: string) => void;
+    moveCursorToMessageEnd: () => void;
+    moveCursorToMessageStart: () => void;
+    moveCursorToLineStart: () => void;
+    moveCursorToLineEnd: () => void;
+}
+export declare class PromptActionAutocompleteProvider implements AutocompleteProvider {
+    #private;
+    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+        onApplied?: () => void;
+    };
+    getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    trySyncSlashCompletion(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+}
+export declare function createPromptActionAutocompleteProvider(options: PromptActionAutocompleteOptions): PromptActionAutocompleteProvider;
+export {};

package/dist/types/modes/rpc/host-tools.d.ts

@@ -0,0 +1,16 @@
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate } from "./rpc-types";
+type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
+export declare function isRpcHostToolResult(value: unknown): value is RpcHostToolResult;
+export declare function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate;
+export declare class RpcHostToolBridge {
+    #private;
+    constructor(output: RpcHostToolOutput);
+    getToolNames(): string[];
+    setTools(tools: RpcHostToolDefinition[]): AgentTool[];
+    handleResult(frame: RpcHostToolResult): boolean;
+    handleUpdate(frame: RpcHostToolUpdate): boolean;
+    requestExecution(definition: RpcHostToolDefinition, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<unknown>): Promise<AgentToolResult<unknown>>;
+    rejectAllPending(message: string): void;
+}
+export {};

package/dist/types/modes/rpc/host-uris.d.ts

@@ -0,0 +1,38 @@
+import { InternalUrlRouter } from "../../internal-urls";
+import type { InternalResource, InternalUrl, ResolveContext, WriteContext } from "../../internal-urls/types";
+import type { RpcHostUriCancelRequest, RpcHostUriRequest, RpcHostUriResult, RpcHostUriSchemeDefinition } from "./rpc-types";
+type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
+/** Type guard for inbound `host_uri_result` frames coming from the host. */
+export declare function isRpcHostUriResult(value: unknown): value is RpcHostUriResult;
+/**
+ * Bidirectional bridge that lets the RPC host own a set of URI schemes.
+ *
+ * The host registers schemes via `set_host_uri_schemes`; the bridge installs
+ * a `RpcHostUriProtocolHandler` per scheme into the process-global
+ * {@link InternalUrlRouter}. Reads land on the read tool through the existing
+ * router; writes are intercepted by the write tool and dispatched through
+ * `requestWrite`.
+ */
+export declare class RpcHostUriBridge {
+    #private;
+    constructor(output: RpcHostUriOutput, router?: InternalUrlRouter);
+    getSchemes(): string[];
+    /**
+     * Replace the registered set of host URI schemes. Previously registered
+     * schemes that no longer appear in the new set are unregistered from the
+     * router; surviving and new schemes get fresh handler instances.
+     */
+    setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[];
+    /**
+     * Unregister every host scheme from the router and reject any in-flight
+     * requests. Called on RPC shutdown to keep the global router clean for
+     * subsequent sessions in the same process (used by tests).
+     */
+    clear(message?: string): void;
+    /** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
+    handleResult(frame: RpcHostUriResult): boolean;
+    rejectAllPending(message: string): void;
+    requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
+}
+export {};

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -0,0 +1,249 @@
+/**
+ * RPC Client for programmatic access to the coding agent.
+ *
+ * Spawns the agent in RPC mode and provides a typed API for all operations.
+ */
+import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import type { BashResult } from "../../exec/bash-executor";
+import type { SessionStats } from "../../session/agent-session";
+import type { RpcHandoffResult, RpcHostToolDefinition, RpcSessionState } from "./rpc-types";
+export interface RpcClientOptions {
+    /** Path to the CLI entry point (default: searches for dist/cli.js) */
+    cliPath?: string;
+    /** Working directory for the agent */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Provider to use */
+    provider?: string;
+    /** Model ID to use */
+    model?: string;
+    /** Session directory for the agent */
+    sessionDir?: string;
+    /** Additional CLI arguments */
+    args?: string[];
+    /** Custom tools owned by the embedding host and exposed over the RPC transport */
+    customTools?: RpcClientCustomTool[];
+}
+export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
+export type RpcEventListener = (event: AgentEvent) => void;
+export interface RpcClientToolContext<TDetails = unknown> {
+    toolCallId: string;
+    signal: AbortSignal;
+    sendUpdate(partialResult: RpcClientToolResult<TDetails>): void;
+}
+export type RpcClientToolResult<TDetails = unknown> = AgentToolResult<TDetails> | string;
+export interface RpcClientCustomTool<TParams extends Record<string, unknown> = Record<string, unknown>, TDetails = unknown> extends Omit<RpcHostToolDefinition, "parameters"> {
+    parameters: Record<string, unknown>;
+    execute(params: TParams, context: RpcClientToolContext<TDetails>): Promise<RpcClientToolResult<TDetails>> | RpcClientToolResult<TDetails>;
+}
+export declare function defineRpcClientTool<TParams extends Record<string, unknown> = Record<string, unknown>, TDetails = unknown>(tool: RpcClientCustomTool<TParams, TDetails>): RpcClientCustomTool<TParams, TDetails>;
+export declare class RpcClient {
+    #private;
+    private options;
+    constructor(options?: RpcClientOptions);
+    /**
+     * Start the RPC agent process.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RPC agent process.
+     */
+    stop(): void;
+    /**
+     * Stop the RPC agent process and clean up resources.
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Subscribe to agent events.
+     */
+    onEvent(listener: RpcEventListener): () => void;
+    /**
+     * Get collected stderr output (useful for debugging).
+     */
+    getStderr(): string;
+    /**
+     * Send a prompt to the agent.
+     * Returns immediately after sending; use onEvent() to receive streaming events.
+     * Use waitForIdle() to wait for completion.
+     */
+    prompt(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a steering message to interrupt the agent mid-run.
+     */
+    steer(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a follow-up message to be processed after the agent finishes.
+     */
+    followUp(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Abort current operation.
+     */
+    abort(): Promise<void>;
+    /**
+     * Abort current operation and immediately start a new turn with the given message.
+     */
+    abortAndPrompt(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Start a new session, optionally with parent tracking.
+     * @param parentSession - Optional parent session path for lineage tracking
+     * @returns Object with `cancelled: true` if an extension cancelled the new session
+     */
+    newSession(parentSession?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Get current session state.
+     */
+    getState(): Promise<RpcSessionState>;
+    /**
+     * Set model by provider and ID.
+     */
+    setModel(provider: string, modelId: string): Promise<{
+        provider: string;
+        id: string;
+    }>;
+    /**
+     * Cycle to next model.
+     */
+    cycleModel(): Promise<{
+        model: {
+            provider: string;
+            id: string;
+        };
+        thinkingLevel: ThinkingLevel | undefined;
+        isScoped: boolean;
+    } | null>;
+    /**
+     * Get list of available models.
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Set thinking level.
+     */
+    setThinkingLevel(level: ThinkingLevel): Promise<void>;
+    /**
+     * Cycle thinking level.
+     */
+    cycleThinkingLevel(): Promise<{
+        level: ThinkingLevel;
+    } | null>;
+    /**
+     * Set steering mode.
+     */
+    setSteeringMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Set follow-up mode.
+     */
+    setFollowUpMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Compact session context.
+     */
+    compact(customInstructions?: string): Promise<CompactionResult>;
+    /**
+     * Set auto-compaction enabled/disabled.
+     */
+    setAutoCompaction(enabled: boolean): Promise<void>;
+    /**
+     * Set auto-retry enabled/disabled.
+     */
+    setAutoRetry(enabled: boolean): Promise<void>;
+    /**
+     * Abort in-progress retry.
+     */
+    abortRetry(): Promise<void>;
+    /**
+     * Execute a bash command.
+     */
+    bash(command: string): Promise<BashResult>;
+    /**
+     * Abort running bash command.
+     */
+    abortBash(): Promise<void>;
+    /**
+     * Get session statistics.
+     */
+    getSessionStats(): Promise<SessionStats>;
+    /**
+     * Hand off session context to a new session.
+     */
+    handoff(customInstructions?: string): Promise<RpcHandoffResult | null>;
+    /**
+     * Export session to HTML.
+     */
+    exportHtml(outputPath?: string): Promise<{
+        path: string;
+    }>;
+    /**
+     * Switch to a different session file.
+     * @returns Object with `cancelled: true` if an extension cancelled the switch
+     */
+    switchSession(sessionPath: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Branch from a specific message.
+     * @returns Object with `text` (the message text) and `cancelled` (if extension cancelled)
+     */
+    branch(entryId: string): Promise<{
+        text: string;
+        cancelled: boolean;
+    }>;
+    /**
+     * Get messages available for branching.
+     */
+    getBranchMessages(): Promise<Array<{
+        entryId: string;
+        text: string;
+    }>>;
+    /**
+     * Get text of last assistant message.
+     */
+    getLastAssistantText(): Promise<string | null>;
+    /**
+     * Get all messages in the session.
+     */
+    getMessages(): Promise<AgentMessage[]>;
+    /**
+     * Get list of OAuth providers available for login, with their current authentication status.
+     */
+    getLoginProviders(): Promise<Array<{
+        id: string;
+        name: string;
+        available: boolean;
+        authenticated: boolean;
+    }>>;
+    /**
+     * Trigger OAuth login for the given provider.
+     * The server will emit an `open_url` extension_ui_request for the auth URL.
+     * Resolves when login completes or rejects on failure.
+     *
+     * @param onOpenUrl Called when the server emits the auth URL. The host must open
+     *   it in a browser for the callback-server OAuth flow to complete.
+     */
+    login(providerId: string, options?: {
+        onOpenUrl?: (url: string, instructions?: string) => void;
+    }): Promise<{
+        providerId: string;
+    }>;
+    /**
+     * Replace the host-owned custom tools exposed to the RPC session.
+     * Changes take effect before the next model call.
+     */
+    setCustomTools(tools: RpcClientCustomTool[]): Promise<string[]>;
+    /**
+     * Wait for agent to become idle (no streaming).
+     * Resolves when agent_end event is received.
+     */
+    waitForIdle(timeout?: number): Promise<void>;
+    /**
+     * Collect events until agent becomes idle.
+     */
+    collectEvents(timeout?: number): Promise<AgentEvent[]>;
+    /**
+     * Send prompt and wait for completion, returning all events.
+     */
+    promptAndWait(message: string, images?: ImageContent[], timeout?: number): Promise<AgentEvent[]>;
+}

package/dist/types/modes/rpc/rpc-mode.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+import type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
+export type * from "./rpc-types";
+export type PendingExtensionRequest = {
+    resolve: (response: RpcExtensionUIResponse) => void;
+    reject: (error: Error) => void;
+};
+type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+    promptStyle?: boolean;
+}): Promise<string | undefined>;
+/**
+ * Run in RPC mode.
+ * Listens for JSON commands on stdin, outputs events and responses on stdout.
+ */
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;