import type { Credential } from "@bastani/pi-ai";
import type { Api, ImageContent, Model } from "@bastani/pi-ai/compat";
import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
import type { PromptDisposition, QueuedInputDisposition, SessionRecoveryReport, SessionStats } from "../../core/agent-session.js";
import type { BashResult } from "../../core/bash-executor.ts";
import type { VerbatimCompactionResult } from "../../core/compaction/index.ts";
import type { SessionRecoveryReason } from "../../core/extensions/index.js";
import type { WorkflowRunDetail, WorkflowRunFilterStatus, WorkflowRunSummary } from "../../core/extensions/workflow-run-control.js";
import type { AtomicProviderCompat } from "../../core/model-capabilities.ts";
import type { SaveCredentialOptions } from "../../core/model-runtime.js";
import type { SessionEntry, SessionSummaryEntry, SessionTreeNode } from "../../core/session-manager.ts";
import type { ToolStatusReport } from "../../core/tool-status.js";
import type { RpcAutocompleteItem, RpcCommand, RpcLoginProviderResult, RpcLogoutProviderResult, RpcModelCatalog, RpcModelRefreshResult, RpcResponse, RpcSessionInfo, RpcSessionState, RpcSlashCommand } from "./rpc-types.ts";
type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
export type RpcCommandBody = DistributiveOmit<RpcCommand, "id">;
export interface ModelInfo {
    provider: string;
    id: string;
    contextWindow: number;
    reasoning: boolean;
    /** Provider/model capability metadata used to gate constrained sampling. */
    compat?: AtomicProviderCompat;
}
export declare abstract class RpcClientApi {
    protected abstract request(command: RpcCommandBody): Promise<RpcResponse>;
    protected abstract data<T>(response: RpcResponse): T;
    /**
     * Send a prompt and return its disposition once accepted.
     * If the disposition is "handled", no run started for this prompt, so don't wait for agent_settled.
     */
    prompt(message: string, images?: ImageContent[], streamingBehavior?: "steer" | "followUp"): Promise<PromptDisposition>;
    steer(message: string, images?: ImageContent[]): Promise<QueuedInputDisposition>;
    followUp(message: string, images?: ImageContent[]): Promise<QueuedInputDisposition>;
    abort(): Promise<void>;
    clearQueue(): Promise<{
        steering: string[];
        followUp: string[];
    }>;
    newSession(parentSession?: string): Promise<{
        cancelled: boolean;
    }>;
    deleteSession(sessionId: string): Promise<void>;
    getState(): Promise<RpcSessionState>;
    getSessionSummary(): Promise<SessionSummaryEntry | null>;
    listSessions(): Promise<RpcSessionInfo[]>;
    listWorkflowRuns(status?: WorkflowRunFilterStatus): Promise<readonly WorkflowRunSummary[]>;
    getWorkflowRunSummary(runId: string): Promise<WorkflowRunDetail>;
    setModel(provider: string, modelId: string, options?: {
        persist?: boolean;
    }): Promise<{
        provider: string;
        id: string;
    }>;
    cycleModel(direction?: "forward" | "backward", options?: {
        persist?: boolean;
    }): Promise<{
        model: Model<Api>;
        thinkingLevel: ThinkingLevel;
        isScoped: boolean;
    } | null>;
    getAvailableModels(): Promise<ModelInfo[]>;
    loginProvider(provider: string, signal?: AbortSignal): Promise<RpcLoginProviderResult>;
    saveProviderCredential(provider: string, credential: Credential, options?: SaveCredentialOptions): Promise<RpcModelCatalog>;
    cancelLoginProvider(provider: string, loginId?: string): Promise<void>;
    logoutProvider(provider: string): Promise<RpcLogoutProviderResult>;
    refreshModels(options?: {
        timeoutMs?: number;
        force?: boolean;
        allowNetwork?: boolean;
    }): Promise<RpcModelRefreshResult>;
    setThinkingLevel(level: ThinkingLevel): Promise<void>;
    /**
     * Isolated persist path: forwards `persist` and returns the engine's effective
     * level plus the provider/model the engine persisted against. Public callers
     * must keep using one-argument {@link setThinkingLevel}.
     */
    setThinkingLevelAck(level: ThinkingLevel, options?: {
        persist?: boolean;
    }): Promise<{
        level: ThinkingLevel;
        provider?: string;
        modelId?: string;
    }>;
    cycleThinkingLevel(): Promise<{
        level: ThinkingLevel;
    } | null>;
    getAvailableThinkingLevels(): Promise<ThinkingLevel[]>;
    setSteeringMode(mode: "all" | "one-at-a-time"): Promise<void>;
    setFollowUpMode(mode: "all" | "one-at-a-time"): Promise<void>;
    compact(): Promise<VerbatimCompactionResult>;
    setAutoCompaction(enabled: boolean): Promise<void>;
    setAutoRetry(enabled: boolean): Promise<void>;
    abortRetry(): Promise<void>;
    bash(command: string): Promise<BashResult>;
    abortBash(requestId?: string): Promise<void>;
    /** Recover work an earlier process left unfinished; call once the transcript is shown. */
    startPendingRecovery(reason?: SessionRecoveryReason): Promise<SessionRecoveryReport>;
    getSessionStats(): Promise<SessionStats>;
    /** Which tools are active, which are not (and why), and which selected names nothing registered. */
    getTools(): Promise<ToolStatusReport>;
    exportHtml(outputPath?: string): Promise<{
        path: string;
    }>;
    switchSession(sessionId: string, cwdOverride?: string, sessionDirectory?: string): Promise<{
        cancelled: boolean;
    }>;
    fork(entryId: string): Promise<{
        text: string;
        cancelled: boolean;
    }>;
    clone(): Promise<{
        cancelled: boolean;
    }>;
    getForkMessages(): Promise<Array<{
        entryId: string;
        text: string;
    }>>;
    getEntries(since?: string): Promise<{
        entries: SessionEntry[];
        leafId: string | null;
    }>;
    getTree(): Promise<{
        tree: SessionTreeNode[];
        leafId: string | null;
    }>;
    getLastAssistantText(): Promise<string | null>;
    setSessionName(name: string): Promise<void>;
    getMessages(): Promise<AgentMessage[]>;
    getCommands(): Promise<RpcSlashCommand[]>;
    getCommandCompletions(commandName: string, argumentPrefix: string): Promise<RpcAutocompleteItem[] | null>;
}
export {};
//# sourceMappingURL=rpc-client-api.d.ts.map