import type { Duplex } from "node:stream";
import type { CreateRemoteTerminalRequest, DurableSkillDefinition, ExternalToolCall, ExternalToolCallResolution, ExternalToolDefinition, ModelCatalog, ProtocolSession, SubagentSummary, RegisterSecretRequest, ResolveExternalToolCallResponse, RemoteTerminalSummary, SecretSummary, SubmitMessageResponse } from "@slopus/rig/types";
export interface RigDaemonConfig {
    daemonMode: "attached" | "managed";
    directory: string;
    socketPath: string;
    tokenPath: string;
    command: string;
}
interface RigBlock {
    type: string;
    text?: string;
    thinking?: string;
}
interface RigMessage {
    role: "agent" | "compaction" | "error" | "system" | "user";
    id?: string;
    blocks: readonly RigBlock[];
    usage?: RigUsage;
}
interface RigUsage {
    totalTokens?: number;
}
export interface RigEffortConfiguration {
    effort: string;
    options: string[];
}
export type RigSecretRegistration = RegisterSecretRequest;
export type RigSecretSummary = SecretSummary;
export interface RigSessionSecretPlan {
    desiredSecretIds: readonly string[];
    managedSecretIds: readonly string[];
}
interface RigPartialMessage {
    content?: Array<{
        type: string;
        text?: string;
        thinking?: string;
    }>;
    id?: string;
    usage?: RigUsage;
}
interface RigAgentLoopEvent {
    content?: string;
    contentIndex?: number;
    delta?: string;
    display?: string;
    error?: RigPartialMessage;
    iteration?: number;
    message?: RigPartialMessage;
    processes?: readonly RigBackgroundProcess[];
    result?: {
        display?: string;
        isError?: boolean;
        toolCallId?: string;
        toolName?: string;
    };
    running?: number;
    status?: string;
    toolCall?: {
        id?: string;
        name?: string;
        arguments?: unknown;
    };
    toolCallId?: string;
    type?: string;
    partial?: RigPartialMessage;
}
export type RigBackgroundProcess = NonNullable<ProtocolSession["backgroundProcesses"]>[number];
export type RigSubagentSummary = SubagentSummary;
export interface RigEvent {
    createdAt: number;
    id: string;
    sessionId: string;
    type: string;
    data: {
        errorMessage?: string;
        event?: RigAgentLoopEvent;
        call?: ExternalToolCall;
        message?: RigMessage;
        messageIds?: readonly string[];
        runId?: string;
        title?: string;
        subagent?: RigSubagentSummary;
    };
}
export interface RigGlobalEvent {
    cursor: string;
    event: RigEvent;
}
export type RigTurnInspection = {
    kind: "not_submitted";
} | {
    kind: "running";
} | {
    kind: "completed";
    text: string;
} | {
    error: string;
    kind: "failed";
};
export declare class RigDaemonClient {
    private readonly config;
    private readonly sessionSecretReconciliations;
    private closeTask?;
    private daemonReload?;
    private daemonReloadAttempted;
    private daemonVersion?;
    private token?;
    private ready?;
    constructor(config: RigDaemonConfig);
    close(): Promise<void>;
    private closeOnce;
    ensureGlobalEventQueue(signal?: AbortSignal): Promise<void>;
    createSession(cwd: string, containerName: string, effort?: string, signal?: AbortSignal, modelId?: string): Promise<{
        effort: string;
        id: string;
    }>;
    modelCatalog(signal?: AbortSignal): Promise<ModelCatalog>;
    effortConfiguration(sessionId: string, signal?: AbortSignal): Promise<RigEffortConfiguration>;
    changeEffort(sessionId: string, effort: string, signal?: AbortSignal): Promise<RigEffortConfiguration>;
    changeModel(sessionId: string, modelId: string, signal?: AbortSignal): Promise<void>;
    ensureFunctionPermission(sessionId: string, signal?: AbortSignal): Promise<void>;
    listSecrets(signal?: AbortSignal): Promise<readonly RigSecretSummary[]>;
    registerSecret(secret: RigSecretRegistration, signal?: AbortSignal): Promise<RigSecretSummary>;
    unregisterSecret(secretId: string, signal?: AbortSignal): Promise<boolean>;
    createRemoteTerminal(sessionId: string, dimensions: CreateRemoteTerminalRequest, signal?: AbortSignal): Promise<RemoteTerminalSummary>;
    attachRemoteTerminal(sessionId: string, terminalId: string): Promise<Duplex>;
    stopRemoteTerminal(sessionId: string, terminalId: string, signal?: AbortSignal): Promise<RemoteTerminalSummary>;
    reconcileSessionSecrets(sessionId: string, loadPlan: () => Promise<RigSessionSecretPlan>, signal?: AbortSignal): Promise<void>;
    watchGlobalEvents(after: string | undefined, onEvent: (event: RigGlobalEvent) => Promise<void>, signal?: AbortSignal): Promise<void>;
    watchSessionEvents(sessionId: string, after: string | undefined, onEvent: (event: RigEvent) => Promise<void>, signal?: AbortSignal): Promise<string | undefined>;
    trimGlobalEvents(through: string, signal?: AbortSignal): Promise<void>;
    sessionCheckpoint(sessionId: string, signal?: AbortSignal): Promise<{
        messageCount: number;
        lastEventId?: string;
    }>;
    turnActivity(sessionId: string, signal?: AbortSignal): Promise<{
        backgroundProcesses: readonly RigBackgroundProcess[];
        subagents: readonly RigSubagentSummary[];
    }>;
    submittedTurnBaseline(sessionId: string, text: string, signal?: AbortSignal): Promise<number>;
    inspectTurn(sessionId: string, baselineMessageCount: number, text: string, signal?: AbortSignal): Promise<RigTurnInspection>;
    submitTurn(sessionId: string, text: string, externalTools: readonly ExternalToolDefinition[], skills: readonly DurableSkillDefinition[], signal?: AbortSignal): Promise<{
        eventId: string;
        runId: string;
    }>;
    /**
     * Folds one message into the run already in flight instead of queueing a new
     * one. `clientSubmissionId` becomes the message's id inside Rig, which is how
     * the applied-steering event names the message Happy sent; `expectedRunId`
     * makes Rig answer 409 rather than steering a run that has since retired.
     */
    steerMessage(sessionId: string, input: {
        clientSubmissionId: string;
        expectedRunId: string;
        text: string;
    }, signal?: AbortSignal): Promise<SubmitMessageResponse>;
    /**
     * Stops the session's in-flight run. `expectedRunId` keeps a stop that was
     * decided against one run from cancelling the next one, and Rig answers 409
     * when the intended run has already retired.
     */
    abortRun(sessionId: string, expectedRunId: string | undefined, signal?: AbortSignal): Promise<void>;
    resolveExternalToolCall(sessionId: string, callId: string, resolution: ExternalToolCallResolution, signal?: AbortSignal): Promise<ResolveExternalToolCallResponse>;
    private session;
    private connectedRequest;
    private ensureReady;
    private reloadDaemon;
    private connect;
    private startDaemon;
    private managedDirectoriesPrepare;
    private stopDaemon;
    private waitForReady;
    private daemonEnvironment;
    private healthy;
    private request;
    private stream;
    private sessionStream;
}
export declare function isRetryableRigError(error: unknown): boolean;
export declare class RigHttpError extends Error {
    readonly status: number;
    constructor(status: number, message: string);
}
export {};
//# sourceMappingURL=daemon.d.ts.map