import { type DshRemoteCapability, type DshRemoteModelCatalog, type DshRemoteModelSelection, type DshRemotePendingInteraction, type DshRemoteSessionSummary, type DshRemoteSnapshot, type DshRemoteWorkspaceView } from './types.js';
import { type DshRemoteHistoryEntry } from './dsh-event-contract.js';
export type { DshRemoteHistoryEntry } from './dsh-event-contract.js';
interface RpcSuccess<T> {
    rpcId: string;
    result: {
        ok: true;
        value: T;
    };
}
interface RpcFailure {
    rpcId: string;
    result: {
        ok: false;
        error: {
            code: string;
            message: string;
            details?: unknown;
        };
    };
}
type RpcResponse<T> = RpcSuccess<T> | RpcFailure;
interface ModelCatalogApiValue {
    default?: {
        provider: string;
        model: string;
        reasoningEffort?: string;
    };
    routableProviders?: string[];
    groups: Array<{
        id: string;
        name: string;
        models: Array<{
            id: string;
            name: string;
            description?: string;
            inputModalities?: readonly string[];
            reasoning?: {
                efforts: Array<{
                    id: string;
                    name: string;
                    description?: string;
                }>;
                defaultEffort?: string;
            };
        }>;
    }>;
    failures: Array<{
        id: string;
        name: string;
        message: string;
    }>;
}
interface WorkspaceApiLike {
    archiveSession?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
        };
    }): Promise<RpcResponse<{
        archivedSessionIds: string[];
    }>>;
    list?(request: {
        rpcId: string;
        payload: Record<string, never>;
    }): Promise<RpcResponse<{
        items: Array<{
            workspaceId: string;
            path: string;
            title: string;
            sessionIds: string[];
        }>;
        archivedSessionIds?: string[];
    }>>;
}
interface DshRemoteWorkspaceInventory {
    items: DshRemoteWorkspaceView[];
    archivedSessionIds: string[];
}
interface SessionsApiLike {
    rename?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
            title: string;
        };
    }): Promise<RpcResponse<{
        title: string;
        seq: number;
    }>>;
    list?(request: {
        rpcId: string;
        payload: {
            cursor?: string;
        };
    }): Promise<RpcResponse<{
        items: Array<{
            sessionId: string;
            updatedAt: number;
            running: boolean;
            blank: boolean;
            parentSessionId?: string;
            origin?: 'subagent';
            cwd?: string;
            projections?: {
                asOfSeq: number;
                values: Record<string, unknown>;
            };
        }>;
    }>>;
    create?(request: {
        rpcId: string;
        payload: {
            workspaceId: string;
            sessionId: string;
        };
    }): Promise<RpcResponse<{
        sessionId: string;
    }>>;
    modelCatalog?(request: {
        rpcId: string;
        payload: Record<string, never>;
    }): Promise<RpcResponse<ModelCatalogApiValue>>;
    models?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
        };
    }): Promise<RpcResponse<{
        current: {
            provider: string;
            model: string;
            reasoningEffort?: string;
        };
        routable: boolean;
        groups: unknown[];
        failures: unknown[];
    }>>;
    selectModel?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
            provider: string;
            model: string;
            reasoningEffort?: string;
        };
    }): Promise<RpcResponse<{
        selected: {
            provider: string;
            model: string;
            reasoningEffort?: string;
        };
    }>>;
    history?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
            beforeSeq?: number;
            maxMessages: number;
        };
    }): Promise<RpcResponse<{
        events: Array<{
            event: {
                type: string;
                seq: number;
                time: number;
                data: unknown;
                sourceEventSeqs?: number[];
                surfaceOp?: unknown;
                ignorable?: true;
            };
            view?: unknown;
        }>;
        hasMore: boolean;
        projections?: {
            asOfSeq: number;
            values: Record<string, unknown>;
        };
    }>>;
    prompt?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
            mode: 'queue' | 'steer';
            content: Array<{
                type: 'text';
                text: string;
            }>;
        };
    }): Promise<RpcResponse<{
        accepted: true;
    }>>;
    cancel?(request: {
        rpcId: string;
        payload: {
            sessionId: string;
        };
    }): Promise<RpcResponse<{
        accepted: true;
    }>>;
}
interface LlmApiLike {
    models?(request: {
        rpcId: string;
        payload: Record<string, never>;
    }): Promise<RpcResponse<ModelCatalogApiValue>>;
}
interface EventsApiLike {
    mux?(request: {
        rpcId: string;
        payload: {
            since?: Record<string, number>;
        };
    }, signal: AbortSignal): AsyncIterable<{
        rpcId: string;
        payload: Record<string, unknown>;
    }>;
}
export type DshRemoteApiProjectionEvent = {
    kind: 'session-metadata';
    sessionId: string;
} | {
    kind: 'session-event';
    sessionId: string;
    entry: DshRemoteHistoryEntry;
} | {
    kind: 'session-projection';
    sessionId: string;
    key: 'goal';
    value: unknown;
    seq: number;
} | {
    kind: 'interactions';
    pendingInteractions: DshRemotePendingInteraction[];
} | {
    kind: 'mux-baseline';
    sessionId: string;
    lastSeq: number;
    pendingInteractions: DshRemotePendingInteraction[];
};
export interface DshPublicApiProxyLike {
    workspace?: WorkspaceApiLike;
    sessions?: SessionsApiLike;
    llm?: LlmApiLike;
    events?: EventsApiLike;
    respond?(message: {
        type: 'client-response';
        rpcId: string;
        result: {
            ok: true;
            value: unknown;
        };
    }): Promise<{
        accepted: true;
    } | {
        accepted: false;
        reason: string;
    }>;
}
export declare function stableDshRemoteSessionId(requestRef: string): string;
export declare class DshApiProxyAdapter {
    private readonly api;
    private readonly options;
    private readonly pendingInteractions;
    private readonly interactionListeners;
    private readonly projectionListeners;
    private eventController;
    private eventLoop;
    private readonly eventPresenter;
    constructor(api: DshPublicApiProxyLike, options?: {
        eventRetryBaseMillis?: number;
        defaultModelSelection?: () => unknown;
        modelInputModalities?: (provider: string, model: string) => Promise<readonly string[] | undefined>;
    });
    capabilities(): DshRemoteCapability[];
    workspaces(): Promise<DshRemoteWorkspaceView[]>;
    workspaceInventory(): Promise<DshRemoteWorkspaceInventory>;
    workspacePage(input?: {
        limit?: number;
        cursor?: string;
    }): Promise<{
        items: DshRemoteWorkspaceView[];
        nextCursor?: string;
    }>;
    sessions(input?: {
        sessionId?: string;
        workspaceId?: string;
        limit?: number;
        cursor?: string;
        workspaceInventory?: DshRemoteWorkspaceInventory;
        sessionInventory?: readonly DshRemoteSessionSummary[];
        includeUngrouped?: boolean;
    }): Promise<{
        items: DshRemoteSessionSummary[];
        nextCursor?: string;
    }>;
    /** One request-owned metadata snapshot; callers page it without another DSH read. */
    sessionInventory(workspaceInventory?: DshRemoteWorkspaceInventory): Promise<DshRemoteSessionSummary[]>;
    localHistorySummaries(): Promise<Map<string, {
        updatedAt: number;
        projectionAsOfSeq?: number;
        running: boolean;
    }>>;
    history(input: {
        sessionId: string;
        beforeSeq?: number;
        limit?: number;
    }): Promise<{
        entries: DshRemoteHistoryEntry[];
        hasMore: boolean;
        nextCursor?: number;
        projectionAsOfSeq?: number;
    }>;
    models(): Promise<DshRemoteModelCatalog>;
    private imageSupport;
    sessionModel(input: {
        sessionId: string;
    }): Promise<{
        current: DshRemoteModelSelection;
        supportsImages?: boolean;
    }>;
    selectSessionModel(input: {
        sessionId: string;
        provider: string;
        model: string;
        reasoningEffort?: string;
        dshRpcId: string;
    }): Promise<{
        selected: DshRemoteModelSelection;
        supportsImages?: boolean;
    }>;
    sessionModelMatches(input: {
        sessionId: string;
        provider: string;
        model: string;
        reasoningEffort?: string;
    }): Promise<boolean>;
    historyContainsRpcId(entries: readonly DshRemoteHistoryEntry[], rpcIdValue: string): boolean;
    createSession(input: {
        workspaceId: string;
        dshRpcId: string;
        modelSelection?: DshRemoteModelSelection;
        beforeCreate?: (sessionId: string) => Promise<void>;
    }): Promise<{
        sessionId: string;
        modelSelection?: DshRemoteModelSelection;
    }>;
    reconcileCreatedSession(input: {
        workspaceId: string;
        dshRpcId: string;
        modelSelection?: DshRemoteModelSelection;
    }): Promise<{
        sessionId: string;
        modelSelection?: DshRemoteModelSelection;
    } | undefined>;
    prompt(input: {
        sessionId: string;
        mode: 'queue' | 'steer';
        content: unknown;
        dshRpcId: string;
    }): Promise<{
        accepted: true;
    }>;
    editCatalog(input: {
        operation: 'session.rename' | 'session.archive';
        sessionId: string;
        title?: string;
        dshRpcId: string;
    }): Promise<unknown>;
    cancel(input: {
        sessionId: string;
        dshRpcId: string;
    }): Promise<{
        accepted: true;
    }>;
    answerQuestion(input: {
        interactionRpcRef: string;
        sessionId: string;
        answer: unknown;
    }): Promise<void>;
    answerApproval(input: {
        interactionRpcRef: string;
        sessionId: string;
        approvalId: string;
        outcome: 'allowed-once' | 'rejected';
    }): Promise<void>;
    pending(): DshRemotePendingInteraction[];
    subscribeInteractions(listener: (interactions: DshRemotePendingInteraction[]) => void): () => void;
    subscribeProjectionEvents(listener: (event: DshRemoteApiProjectionEvent) => void): () => void;
    startEvents(): () => void;
    stopEvents(): void;
    private maintainEvents;
    snapshot(input?: {
        limit?: number;
        cursor?: string;
    }): Promise<DshRemoteSnapshot>;
    private consumeEvents;
    private requireSession;
    private textContent;
    private respond;
    private emitInteractions;
    private emitProjection;
    private unsupported;
    private resolved;
    private hasModelCatalog;
    private modelCatalog;
}
//# sourceMappingURL=api-proxy-adapter.d.ts.map