jeopi-cli 16.2.14 → 16.2.15

package/dist/types/modes/internal-url-autocomplete.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Autocomplete for internal-url schemes (skill://, rule://, omp://, local://,
+ * memory://, agent://, artifact://) while composing a prompt.
+ *
+ * Detection here MUST stay in sync with the generic URL-scheme trigger in the
+ * TUI editor (`packages/tui/src/components/editor.ts`); the editor fires the
+ * popup, this module decides whether there are candidates to show.
+ */
+import type { AutocompleteItem } from "jeopi-tui";
+export interface InternalUrlContext {
+    /** Lowercased scheme (e.g. `local`). */
+    scheme: string;
+    /** Text typed after the slashes so far (host + path); may be empty. */
+    query: string;
+    /** Exact buffer token from its boundary to the cursor (the completion prefix). */
+    token: string;
+}
+/**
+ * Detect a completable internal-url token immediately before the cursor.
+ * Returns `null` when the text is not a `scheme://` token whose scheme is
+ * registered with a completion-capable handler.
+ */
+export declare function extractInternalUrlContext(textBeforeCursor: string): InternalUrlContext | null;
+/**
+ * Suggestions for the internal-url token ending at the cursor, or `null` when
+ * the text is not such a token or no candidate matches the typed query.
+ */
+export declare function getInternalUrlSuggestions(textBeforeCursor: string, cwd?: string): Promise<{
+    items: AutocompleteItem[];
+    prefix: string;
+} | null>;
+/** Whether `prefix` (the token a completion was offered for) is an internal-url token. */
+export declare function isInternalUrlPrefix(prefix: string): boolean;
+/**
+ * Replace the internal-url token with the selected candidate, appending a
+ * trailing space (matching `@` file-reference behavior) so the user can keep
+ * typing.
+ */
+export declare function applyInternalUrlCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+};

package/dist/types/modes/loop-limit.d.ts

@@ -0,0 +1,35 @@
+export type LoopLimitConfig = {
+    kind: "iterations";
+    iterations: number;
+} | {
+    kind: "duration";
+    durationMs: number;
+};
+export type LoopLimitRuntime = {
+    kind: "iterations";
+    initial: number;
+    remaining: number;
+} | {
+    kind: "duration";
+    durationMs: number;
+    deadlineMs: number;
+};
+export interface ParsedLoopArgs {
+    /** Iteration/duration budget, when the user supplied a leading limit token. */
+    limit?: LoopLimitConfig;
+    /** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+    prompt?: string;
+}
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export declare function parseLoopLimitArgs(args: string): ParsedLoopArgs | string;
+export declare function createLoopLimitRuntime(config: LoopLimitConfig | undefined, nowMs?: number): LoopLimitRuntime | undefined;
+export declare function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
+export declare function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
+export declare function describeLoopLimit(config: LoopLimitConfig): string;
+export declare function describeLoopLimitRuntime(limit: LoopLimitRuntime): string;

package/dist/types/modes/magic-keywords.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gradient-highlight every magic keyword ("ultrathink", "orchestrate",
+ * "workflowz") that appears as standalone prose, skipping any occurrence inside a
+ * code block, inline code span, or XML/HTML section. Each highlighter paints its
+ * own keyword with its own gradient, so chaining is order-independent — the
+ * earlier passes only inject zero-width SGR escapes (no backticks or angle
+ * brackets), which never confuse the later passes' markdown masking.
+ *
+ * `resetTo` is the SGR foreground sequence restored after each painted keyword;
+ * pass the surrounding text color when decorating already-colored content (e.g.
+ * a themed message bubble) so the gradient does not bleed into the rest of the
+ * line. Defaults to a plain foreground reset for default-colored editor text.
+ *
+ * `phase` ∈ [0, 1) cyclically rotates each gradient — the editor passes a
+ * `Date.now()`-derived value to animate a Claude-Code-style shimmer while a
+ * keyword is on screen and the prompt is focused; sent message bubbles omit it
+ * to keep the static gradient.
+ */
+export declare function highlightMagicKeywords(text: string, resetTo?: string, phase?: number): string;
+/**
+ * Cheap test for "does this text contain any magic keyword as standalone prose?".
+ * Short-circuits on a substring probe before paying for the markdown-aware
+ * prose check, so the common "no keyword in buffer" path is just three
+ * `String#indexOf`s. Used by the live editor to gate the shimmer timer.
+ */
+export declare function hasMagicKeyword(text: string): boolean;

package/dist/types/modes/markdown-prose.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Markdown structure awareness for the magic-keyword affordances
+ * ("ultrathink"/"orchestrate"/"workflowz").
+ *
+ * Keyword detection and editor/transcript highlighting must fire only on prose
+ * the user is actually addressing to the model — never on a word that happens to
+ * live inside a fenced code block, an inline code span, or an HTML/XML section.
+ * {@link maskNonProse} returns a length-preserving copy of the text where every
+ * such region is blanked to spaces, so a word-bounded match run against the mask
+ * never lands inside code/markup while its indices still address the original
+ * text for painting.
+ */
+/**
+ * Return a copy of `text` with identical length (indices map 1:1) where every
+ * character inside a non-prose region is replaced by a space. Non-prose regions
+ * are markdown fenced code blocks, inline code spans, and HTML/XML tags together
+ * with the content they enclose. Newlines are preserved. Text with no construct
+ * that could open such a region is returned unchanged.
+ */
+export declare function maskNonProse(text: string): string;
+/**
+ * Whether `text` contains a standalone keyword match (per the non-global,
+ * word-bounded `word` regex) that lives in prose rather than inside a code
+ * block, inline code span, or HTML/XML section. `word` MUST be non-global so
+ * `.test` stays stateless.
+ */
+export declare function keywordInProse(text: string, word: RegExp): boolean;

package/dist/types/modes/oauth-manual-input.d.ts

@@ -0,0 +1,15 @@
+type ClaimedInput = {
+    promise: Promise<string>;
+    clear: (reason?: string) => void;
+};
+export declare class OAuthManualInputManager {
+    #private;
+    waitForInput(providerId: string): Promise<string>;
+    tryWaitForInput(providerId: string): Promise<string> | undefined;
+    tryClaimInput(providerId: string): ClaimedInput | undefined;
+    submit(input: string): boolean;
+    clear(reason?: string): void;
+    hasPending(): boolean;
+    get pendingProviderId(): string | undefined;
+}
+export {};

package/dist/types/modes/orchestrate.d.ts

@@ -0,0 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
+/** Hidden system notice appended after a user message that mentions "orchestrate". */
+export declare const ORCHESTRATE_NOTICE: string;
+/**
+ * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export declare function containsOrchestrate(text: string): boolean;
+/**
+ * Highlight every standalone "orchestrate" in `text` for editor display with a
+ * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
+ * full-spectrum rainbow.
+ */
+export declare const highlightOrchestrate: KeywordHighlighter;

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

@@ -0,0 +1,29 @@
+/**
+ * Print mode (single-shot): Send prompts, output result, exit.
+ *
+ * Used for:
+ * - `omp -p "prompt"` - text output
+ * - `jeopi --mode json "prompt"` - JSON event stream
+ */
+import type { ImageContent } from "jeopi-ai";
+import type { AgentSession } from "../session/agent-session";
+/**
+ * Options for print mode.
+ */
+export interface PrintModeOptions {
+    /** Output mode: "text" for final response only, "json" for all events */
+    mode: "text" | "json";
+    /** Array of additional prompts to send after initialMessage */
+    messages?: string[];
+    /** First message to send (may contain @file content) */
+    initialMessage?: string;
+    /** Images to attach to the initial message */
+    initialImages?: ImageContent[];
+    /** If true, include thinking blocks in text output */
+    printThoughts?: boolean;
+}
+/**
+ * Run in print (single-shot) mode.
+ * Sends prompts to the agent and outputs the result.
+ */
+export declare function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void>;

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

@@ -0,0 +1,46 @@
+import { type AutocompleteItem, type AutocompleteProvider, type SlashCommand } from "jeopi-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;
+    trySyncInlineReplace(textBeforeCursor: string): {
+        replaceLen: number;
+        insert: 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 "jeopi-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,300 @@
+/**
+ * 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 "jeopi-agent-core";
+import type { CompactionResult } from "jeopi-agent-core/compaction";
+import type { ImageContent, Model } from "jeopi-ai";
+import type { BashResult } from "../../exec/bash-executor";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { RpcAvailableSlashCommand, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcSubagentEventFrame, RpcSubagentLifecycleFrame, RpcSubagentMessagesResult, RpcSubagentProgressFrame, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } 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 type RpcSessionEventListener = (event: AgentSessionEvent) => void;
+export type RpcSubagentLifecycleListener = (payload: RpcSubagentLifecycleFrame["payload"]) => void;
+export type RpcSubagentProgressListener = (payload: RpcSubagentProgressFrame["payload"]) => void;
+export type RpcSubagentEventListener = (payload: RpcSubagentEventFrame["payload"]) => void;
+export type RpcAvailableCommandsUpdateListener = (commands: RpcAvailableSlashCommand[]) => 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.
+     *
+     * Safe to call again after {@link stop} on the same instance: a fresh
+     * {@link AbortController} is minted for each start, and any failure after
+     * the child spawn kills the child and clears internal state so callers may
+     * retry without leaking processes.
+     */
+    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;
+    /**
+     * Subscribe to all top-level session events, including non-core session state events.
+     */
+    onSessionEvent(listener: RpcSessionEventListener): () => void;
+    /**
+     * Subscribe to subagent lifecycle frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentLifecycle(listener: RpcSubagentLifecycleListener): () => void;
+    /**
+     * Subscribe to aggregated subagent progress frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentProgress(listener: RpcSubagentProgressListener): () => void;
+    /**
+     * Subscribe to raw subagent session events. Call setSubagentSubscription(\"events\") to enable them server-side.
+     */
+    onSubagentEvent(listener: RpcSubagentEventListener): () => void;
+    /**
+     * Subscribe to slash-command availability updates emitted by the RPC server.
+     */
+    onAvailableCommandsUpdate(listener: RpcAvailableCommandsUpdateListener): () => 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>;
+    /**
+     * Configure subagent frames emitted by the RPC server. Servers default to "off".
+     * "progress" emits lifecycle/progress frames; "events" additionally emits raw subagent session events.
+     */
+    setSubagentSubscription(level: RpcSubagentSubscriptionLevel): Promise<RpcSubagentSubscriptionLevel>;
+    /**
+     * Return the RPC server's current subagent snapshot.
+     */
+    getSubagents(): Promise<RpcSubagentSnapshot[]>;
+    /**
+     * Read persisted transcript entries for a tracked subagent session.
+     */
+    getSubagentMessages(selector: {
+        subagentId?: string;
+        sessionFile?: string;
+        fromByte?: number;
+    }): Promise<RpcSubagentMessagesResult>;
+    /**
+     * 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[]>;
+    /**
+     * Get list of available slash commands.
+     */
+    getAvailableCommands(): Promise<RpcAvailableSlashCommand[]>;
+    /**
+     * 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[]>;
+}