export interface JsonRpcRequest {
    jsonrpc: '2.0';
    id: number | string;
    method: string;
    params?: unknown;
}
export interface JsonRpcResponse {
    jsonrpc: '2.0';
    id: number | string;
    result?: unknown;
    error?: {
        code: number;
        message: string;
    };
}
export interface JsonRpcNotification {
    jsonrpc: '2.0';
    method: string;
    params?: unknown;
}
export interface InitializeParams {
    protocolVersion?: number;
    clientCapabilities?: {
        fs?: {
            readTextFile?: boolean;
            writeTextFile?: boolean;
        };
        terminal?: boolean;
    };
    clientInfo?: {
        name: string;
        version: string;
    };
}
export interface AgentCapabilities {
    loadSession?: boolean;
    promptCapabilities?: {
        image?: boolean;
        audio?: boolean;
        embeddedContext?: boolean;
    };
    mcpCapabilities?: {
        stdio?: boolean;
        sse?: boolean;
        http?: boolean;
    };
    sessionCapabilities?: {
        close?: Record<string, unknown>;
        list?: Record<string, unknown>;
        resume?: Record<string, unknown>;
    };
}
export interface InitializeResult {
    protocolVersion: number;
    agentCapabilities: AgentCapabilities;
    agentInfo: {
        name: string;
        version: string;
    };
    authMethods: unknown[];
}
export interface McpServer {
    name: string;
    /** Spawn command (stdio transport). Mutually exclusive with `url`. */
    command?: string;
    args?: string[];
    env?: Record<string, string>;
    /**
     * If set, the client uses MCP Streamable HTTP transport against this URL
     * instead of spawning a child process. Per spec, the same endpoint
     * accepts POST (request) and GET (server-side SSE stream).
     */
    url?: string;
    /** Optional headers for the HTTP transport (Authorization etc.). */
    headers?: Record<string, string>;
}
export interface SessionMode {
    id: string;
    name: string;
    description?: string | null;
}
export interface SessionModeState {
    availableModes: SessionMode[];
    currentModeId: string;
}
export interface SessionConfigOption {
    id: string;
    name: string;
    description?: string | null;
    category?: 'mode' | 'model' | 'thought_level' | null;
    type: 'select';
    currentValue: string;
    options: {
        value: string;
        name: string;
    }[];
}
export interface SessionNewParams {
    cwd: string;
    mcpServers?: McpServer[];
    fresh?: boolean;
}
export interface SessionNewResult {
    sessionId: string;
    history?: {
        role: string;
        content: string;
    }[];
    modes?: SessionModeState | null;
    configOptions?: SessionConfigOption[] | null;
}
export interface SessionLoadParams {
    sessionId: string;
    cwd: string;
    mcpServers?: McpServer[];
}
export interface SessionLoadResult {
    sessionId?: string;
    history?: {
        role: string;
        content: string;
    }[];
    modes?: SessionModeState | null;
    configOptions?: SessionConfigOption[] | null;
}
export interface SessionResumeParams {
    sessionId: string;
    cwd: string;
    mcpServers?: McpServer[];
}
export interface SessionResumeResult {
    sessionId: string;
    modes?: SessionModeState | null;
    configOptions?: SessionConfigOption[] | null;
}
export interface ContentBlock {
    type: 'text' | 'image' | 'audio' | 'resource_link' | 'resource';
    text?: string;
    data?: string;
    mimeType?: string;
    uri?: string;
    name?: string;
    description?: string;
    resource?: {
        uri?: string;
        mimeType?: string;
        text?: string;
        blob?: string;
    };
}
export interface SessionPromptParams {
    sessionId: string;
    prompt: ContentBlock[];
}
export interface SessionPromptResult {
    stopReason: 'end_turn' | 'cancelled';
}
export interface SessionCancelParams {
    sessionId: string;
}
export interface SetSessionModeParams {
    sessionId: string;
    modeId: string;
}
export interface SetSessionConfigOptionParams {
    sessionId: string;
    configId: string;
    value: unknown;
}
export interface SessionUpdateAgentMessageChunk {
    sessionUpdate: 'agent_message_chunk';
    content: ContentBlock;
}
export interface SessionUpdateAgentThoughtChunk {
    sessionUpdate: 'agent_thought_chunk';
    content: ContentBlock;
}
export interface SessionUpdateToolCall {
    sessionUpdate: 'tool_call';
    toolCallId: string;
    title: string;
    kind?: string;
    status: 'pending' | 'in_progress';
    locations?: {
        path: string;
    }[];
}
export interface SessionUpdateToolCallUpdate {
    sessionUpdate: 'tool_call_update';
    toolCallId: string;
    status: 'completed' | 'failed';
    rawOutput?: string;
}
export interface SessionUpdateAvailableCommands {
    sessionUpdate: 'available_commands_update';
    availableCommands: {
        name: string;
        description: string;
        input?: {
            hint: string;
        } | null;
    }[];
}
export interface SessionUpdateCurrentMode {
    sessionUpdate: 'current_mode_update';
    currentModeId: string;
}
export interface SessionUpdateConfigOption {
    sessionUpdate: 'config_option_update';
    configOptions: SessionConfigOption[];
}
export interface SessionUpdateSessionInfo {
    sessionUpdate: 'session_info_update';
    title: string;
    updatedAt?: string;
}
export interface PlanEntry {
    id: string;
    content: string;
    priority: 'high' | 'medium' | 'low';
    status: 'pending' | 'in_progress' | 'completed';
}
export interface SessionUpdatePlan {
    sessionUpdate: 'plan';
    entries: PlanEntry[];
}
export type SessionUpdateInner = SessionUpdateAgentMessageChunk | SessionUpdateAgentThoughtChunk | SessionUpdateToolCall | SessionUpdateToolCallUpdate | SessionUpdatePlan | SessionUpdateAvailableCommands | SessionUpdateCurrentMode | SessionUpdateConfigOption | SessionUpdateSessionInfo;
export interface SessionUpdateParams {
    sessionId: string;
    update: SessionUpdateInner;
}
export type PermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
export interface PermissionOption {
    optionId: string;
    name: string;
    kind: PermissionOptionKind;
}
export interface RequestPermissionParams {
    sessionId: string;
    toolCall: {
        toolCallId: string;
        toolName: string;
        toolInput: unknown;
        status: 'pending' | 'completed' | 'failed';
        content: unknown[];
    };
    options: PermissionOption[];
}
export interface RequestPermissionResult {
    outcome: {
        type: 'cancelled';
    } | {
        type: 'selected';
        optionId: string;
    };
}
export interface ListSessionsParams {
    cwd?: string;
    cursor?: string;
}
export interface AcpSessionInfo {
    sessionId: string;
    cwd: string;
    title?: string | null;
    updatedAt?: string | null;
}
export interface ListSessionsResult {
    sessions: AcpSessionInfo[];
    nextCursor?: string | null;
}
export interface ListPersonalitiesParams {
    sessionId: string;
}
export interface AcpPersonalityInfo {
    name: string;
    displayName: string;
    description: string;
    structured: boolean;
    /** True only when Tools was explicitly declared; [] then means conversation-only. */
    restrictTools: boolean;
    scope: 'builtin' | 'project' | 'global';
    model: string;
    tools: string[];
    projectScope: 'all' | 'selected' | 'personal' | 'unspecified';
    projects: string[];
    available: boolean;
}
export interface ListPersonalitiesResult {
    personalities: AcpPersonalityInfo[];
    activePersonality: string | null;
}
export interface SetPersonalityParams {
    sessionId: string;
    personalityId: string | null;
}
export interface SetPersonalityResult {
    activePersonality: string | null;
}
export interface SyncPersonalitiesParams {
    sessionId: string;
}
export interface SyncPersonalitiesResult extends ListPersonalitiesResult {
    updated: number;
}
export interface DeleteSessionParams {
    sessionId: string;
    cwd?: string;
}
export interface DeleteSessionResult {
}
export interface FsReadTextFileParams {
    sessionId: string;
    path: string;
    line?: number;
    limit?: number;
}
export interface FsReadTextFileResult {
    content: string;
}
export interface FsWriteTextFileParams {
    sessionId: string;
    path: string;
    content: string;
}
export interface TerminalCreateParams {
    sessionId: string;
    command: string;
    args: string[];
    cwd: string;
    env?: Record<string, string>;
    outputByteLimit?: number;
}
export interface TerminalCreateResult {
    terminalId: string;
}
export interface TerminalWaitForExitParams {
    sessionId: string;
    terminalId: string;
    timeoutMs?: number;
}
export interface TerminalExitStatus {
    exitCode?: number | null;
    signal?: string | null;
}
export type LegacyTerminalExitStatus = {
    type: 'exited';
    code: number;
} | {
    type: 'killed';
    signal?: string;
};
export type TerminalWaitForExitResult = TerminalExitStatus | {
    exitStatus: TerminalExitStatus | LegacyTerminalExitStatus;
};
export interface TerminalOutputParams {
    sessionId: string;
    terminalId: string;
    offset?: number;
}
export interface TerminalOutputResult {
    output: string;
    truncated?: boolean;
    /** Absent while the process is still running; present once the process has exited. */
    exitStatus?: TerminalExitStatus | null;
}
export interface TerminalKillParams {
    sessionId: string;
    terminalId: string;
}
export interface TerminalReleaseParams {
    sessionId: string;
    terminalId: string;
}
export interface TerminalReleaseResult {
}
export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;