import { type AppServerClient, type AppServerExternalToolCallHandler } from "@letta-ai/letta-code/app-server-client";
import { RemoteClientSessionCore, type ProtocolMessage, type RemoteClientRuntimeController, type RuntimeSendTurnOptions, type RuntimeScope, type RuntimeSessionInit, type RuntimeSessionMode } from "./remote-client-session-core.js";
import type { AnyAgentTool, CanUseToolContext, CanUseToolResponse, ClientToolsetConfig, CreateAgentOptions, LettaCodeRemoteClientOptions, LettaCodeClientSessionOptions, ListModelsResult, ListMessagesOptions, ListMessagesResult, RecoverPendingApprovalsOptions, RecoverPendingApprovalsResult, SendMessage, UpdateModelResult } from "./types.js";
type UpdateModelPayload = {
    model_id?: string;
    model_handle?: string;
};
export declare function agentToolNames(agent: object | null | undefined): string[] | undefined;
export type AppServerSessionOptions = Partial<LettaCodeRemoteClientOptions> & {
    /** Base websocket URL. */
    url?: string;
    /**
     * Internal lazy connection hook. The Node entry point uses this to start a
     * local app-server without pulling process-management code into `/client`.
     */
    connect?: (sessionEnv?: Record<string, string>) => Promise<{
        url: string;
        close(): void;
    }>;
};
export type AppServerSessionMode = RuntimeSessionMode;
export declare function externalToolGroups(tools: AnyAgentTool[] | undefined): Array<Record<string, unknown>> | undefined;
export declare function createExternalToolCallHandler(externalTools: Map<string, AnyAgentTool>): AppServerExternalToolCallHandler;
type AppServerApprovalOptions = LettaCodeClientSessionOptions | CreateAgentOptions;
type AppServerApprovalResponseDecision = {
    behavior: "allow";
    message?: string;
    updated_input?: Record<string, unknown> | null;
    selected_permission_suggestion_ids?: string[];
} | {
    behavior: "deny";
    message: string;
};
export declare function resolveAppServerToolApproval(options: AppServerApprovalOptions, toolName: string, toolInput: Record<string, unknown>, context?: CanUseToolContext): Promise<CanUseToolResponse>;
export declare function toAppServerApprovalDecision(decision: CanUseToolResponse): AppServerApprovalResponseDecision;
export declare function registerAppServerControlRequestHandler(config: {
    client: AppServerClient;
    getRuntime: () => RuntimeScope | null;
    getOptions: () => AppServerApprovalOptions;
}): () => void;
export declare class AppServerRuntimeController implements RemoteClientRuntimeController {
    private readonly client;
    private readonly options;
    private readonly clientToolAllowlist?;
    private readonly clientToolset?;
    constructor(client: AppServerClient, options: AppServerSessionOptions, clientToolAllowlist?: readonly string[] | undefined, clientToolset?: ClientToolsetConfig | undefined);
    onMessage(handler: (message: ProtocolMessage, channel?: string) => void): () => void;
    send(command: Record<string, unknown>): void;
    sendTurnMessage(runtime: RuntimeScope, message: SendMessage, options: RuntimeSendTurnOptions): void;
    abort(runtime: RuntimeScope): Promise<void>;
    request<TResponse extends ProtocolMessage = ProtocolMessage>(type: string, body: Record<string, unknown>, options?: {
        timeoutMs?: number;
        predicate?: (message: ProtocolMessage) => boolean;
    }): Promise<TResponse>;
    listModels(): Promise<ListModelsResult>;
    updateModel(runtime: RuntimeScope, payload: UpdateModelPayload): Promise<UpdateModelResult>;
    recoverPendingApprovals(runtime: RuntimeScope, options?: RecoverPendingApprovalsOptions): Promise<RecoverPendingApprovalsResult>;
    listMessages(conversationId: string, options?: ListMessagesOptions): Promise<ListMessagesResult>;
    close(): void;
}
export declare class AppServerSession extends RemoteClientSessionCore {
    private readonly remoteOptions;
    private ownedConnection;
    private externalTools;
    private mcpBridge;
    private mcpCleanup;
    private removeExternalToolHandler;
    private removeControlRequestHandler;
    constructor(remoteOptions: AppServerSessionOptions, mode: AppServerSessionMode);
    protected shouldEnableMemfs(options: LettaCodeClientSessionOptions | CreateAgentOptions): boolean;
    protected initializeRuntimeController(): Promise<RuntimeSessionInit>;
    protected onCoreClose(): void;
    protected onCoreDisposed(): Promise<void>;
    private closeMcpBridge;
    private resolveAppServerUrl;
    private startRuntime;
    private buildRuntimeStartCommand;
    private resolveConversationAgentId;
}
export {};
//# sourceMappingURL=app-server-session.d.ts.map