@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-client/dist/daemon-client.d.ts

@@ -0,0 +1,1008 @@
+import type { z } from "zod";
+import { type ClientCapability } from "@bytetrue/byspace-protocol/client-capabilities";
+import { AgentRefreshedStatusPayloadSchema, CheckoutRenameBranchResponseSchema, RenameTerminalResponseSchema, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, DaemonUpdateResponseSchema, type ServerInfoStatusPayload } from "@bytetrue/byspace-protocol/messages";
+import type { AgentStreamEventPayload, AgentSnapshotPayload, ProjectPlacementPayload, AgentPermissionResolvedMessage, CreateAgentRequestMessage, CreateBySpaceWorktreeRequest, FileDownloadTokenResponse, FileUploadResponse, FileExplorerResponse, FetchAgentTimelineResponseMessage, AgentForkContextResponseMessage, GitSetupOptions, CheckoutStatusResponse, CheckoutCommitResponse, CheckoutMergeResponse, CheckoutMergeFromBaseResponse, CheckoutPullResponse, CheckoutPushResponse, CheckoutRefreshResponse, CheckoutPrCreateResponse, CheckoutPrMergeResponse, CheckoutPrMergeMethod, CheckoutGithubSetAutoMergeResponse, CheckoutGithubGetCheckDetailsResponse, CheckoutPrStatusResponse, PullRequestTimelineResponse, CheckoutSwitchBranchResponse, StashSaveResponse, StashPopResponse, StashListResponse, ValidateBranchResponse, BranchSuggestionsResponse, GitHubSearchResponse, GitHubSearchRequest, DirectorySuggestionsResponse, BySpaceWorktreeListResponse, BySpaceWorktreeArchiveResponse, ProjectIconResponse, ProjectAddResponse, OpenProjectResponseMessage, WorkspaceGithubCloneProtocol, WorkspaceGithubCloneResponse, ArchiveWorkspaceResponseMessage, WorkspaceSetupStatusResponseMessage, ListCommandsResponse, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, ListAvailableProvidersResponse, GetProvidersSnapshotResponseMessage, RefreshProvidersSnapshotResponseMessage, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, DaemonGetStatusResponse, DaemonGetPairingOfferResponse, DiagnosticsResponse, AgentRewindResponseMessage, ListTerminalsResponse, CreateTerminalResponse, SubscribeTerminalResponse, SubscribeTerminalRequest, CloseItemsResponse, KillTerminalResponse, CaptureTerminalResponse, TerminalInput, SessionInboundMessage, SessionOutboundMessage, SendAgentMessageRequest, BySpaceConfigRaw, BySpaceConfigRevision, WorkspaceCreateRequest } from "@bytetrue/byspace-protocol/messages";
+import type { AgentPermissionRequest, AgentPermissionResponse, AgentPersistenceHandle, AgentProviderNotice, AgentProvider, AgentSessionConfig } from "@bytetrue/byspace-protocol/agent-types";
+import type { MutableDaemonConfig, MutableDaemonConfigPatch } from "@bytetrue/byspace-protocol/messages";
+import { type DaemonTransportFactory, type WebSocketFactory } from "./daemon-client-transport.js";
+import { type TerminalStreamEvent } from "./terminal-stream-router.js";
+export interface Logger {
+    debug(obj: object, msg?: string): void;
+    info(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+    error(obj: object, msg?: string): void;
+}
+interface ImportAgentInputBase {
+    cwd?: string;
+    labels?: Record<string, string>;
+}
+export type ImportAgentInput = (ImportAgentInputBase & {
+    providerId: string;
+    providerHandleId: string;
+}) | (ImportAgentInputBase & {
+    provider: AgentProvider;
+    sessionId: string;
+});
+export type { DaemonTransport, DaemonTransportFactory, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport.js";
+export type { TerminalStreamEvent };
+export type ConnectionState = {
+    status: "idle";
+} | {
+    status: "connecting";
+    attempt: number;
+} | {
+    status: "connected";
+} | {
+    status: "disconnected";
+    reason?: string;
+} | {
+    status: "disposed";
+};
+export type DaemonEvent = {
+    type: "agent_update";
+    agentId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "agent_update";
+    }>["payload"];
+} | {
+    type: "workspace_update";
+    workspaceId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "workspace_update";
+    }>["payload"];
+} | {
+    type: "workspace_setup_progress";
+    workspaceId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "workspace_setup_progress";
+    }>["payload"];
+} | {
+    type: "agent_stream";
+    agentId: string;
+    event: AgentStreamEventPayload;
+    timestamp: string;
+    seq?: number;
+    epoch?: string;
+} | {
+    type: "status";
+    payload: {
+        status: string;
+    } & Record<string, unknown>;
+} | {
+    type: "agent_deleted";
+    agentId: string;
+} | {
+    type: "agent_permission_request";
+    agentId: string;
+    request: AgentPermissionRequest;
+} | {
+    type: "agent_permission_resolved";
+    agentId: string;
+    requestId: string;
+    resolution: AgentPermissionResponse;
+} | {
+    type: "providers_snapshot_update";
+    payload: Extract<SessionOutboundMessage, {
+        type: "providers_snapshot_update";
+    }>["payload"];
+} | {
+    type: "error";
+    message: string;
+};
+export type DaemonEventHandler = (event: DaemonEvent) => void;
+export interface DaemonClientConfig {
+    url: string;
+    clientId: string;
+    clientType?: "mobile" | "browser" | "cli" | "mcp";
+    appVersion?: string;
+    runtimeGeneration?: number | null;
+    password?: string;
+    authHeader?: string;
+    suppressSendErrors?: boolean;
+    transportFactory?: DaemonTransportFactory;
+    webSocketFactory?: WebSocketFactory;
+    logger?: Logger;
+    connectTimeoutMs?: number;
+    e2ee?: {
+        enabled?: boolean;
+        daemonPublicKeyB64?: string;
+    };
+    reconnect?: {
+        enabled?: boolean;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+    runtimeMetricsIntervalMs?: number;
+    runtimeMetricsWindowMs?: number;
+    capabilities?: Partial<Record<ClientCapability, unknown>>;
+}
+export interface SendMessageOptions {
+    messageId?: string;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    attachments?: SendAgentMessageRequest["attachments"];
+}
+type AgentConfigOverrides = Partial<Omit<AgentSessionConfig, "provider" | "cwd">>;
+export interface CreateAgentRequestOptions extends AgentConfigOverrides {
+    config?: AgentSessionConfig;
+    provider?: AgentProvider;
+    cwd?: string;
+    env?: CreateAgentRequestMessage["env"];
+    workspaceId?: string;
+    initialPrompt?: string;
+    clientMessageId?: string;
+    outputSchema?: Record<string, unknown>;
+    images?: CreateAgentRequestMessage["images"];
+    attachments?: CreateAgentRequestMessage["attachments"];
+    git?: GitSetupOptions;
+    worktree?: CreateAgentRequestMessage["worktree"];
+    autoArchive?: CreateAgentRequestMessage["autoArchive"];
+    worktreeName?: string;
+    requestId?: string;
+    labels?: Record<string, string>;
+}
+export interface CreateBySpaceWorktreeInput extends Pick<CreateBySpaceWorktreeRequest, "cwd" | "projectId" | "worktreeSlug" | "firstAgentContext" | "refName" | "action" | "githubPrNumber"> {
+}
+type CheckoutStatusPayload = CheckoutStatusResponse["payload"];
+type SubscribeCheckoutDiffPayload = Extract<SessionOutboundMessage, {
+    type: "subscribe_checkout_diff_response";
+}>["payload"];
+type CheckoutDiffPayload = Omit<SubscribeCheckoutDiffPayload, "subscriptionId">;
+type CheckoutCommitPayload = CheckoutCommitResponse["payload"];
+type CheckoutMergePayload = CheckoutMergeResponse["payload"];
+type CheckoutMergeFromBasePayload = CheckoutMergeFromBaseResponse["payload"];
+type CheckoutPullPayload = CheckoutPullResponse["payload"];
+type CheckoutPushPayload = CheckoutPushResponse["payload"];
+type CheckoutRefreshPayload = CheckoutRefreshResponse["payload"];
+type CheckoutPrCreatePayload = CheckoutPrCreateResponse["payload"];
+type CheckoutPrMergePayload = CheckoutPrMergeResponse["payload"];
+type CheckoutGithubSetAutoMergePayload = CheckoutGithubSetAutoMergeResponse["payload"];
+type CheckoutGithubGetCheckDetailsPayload = CheckoutGithubGetCheckDetailsResponse["payload"];
+type CheckoutPrStatusPayload = CheckoutPrStatusResponse["payload"];
+type PullRequestTimelinePayload = PullRequestTimelineResponse["payload"];
+type CheckoutSwitchBranchPayload = CheckoutSwitchBranchResponse["payload"];
+export type RenameBranchResult = z.infer<typeof CheckoutRenameBranchResponseSchema>["payload"];
+type StashSavePayload = StashSaveResponse["payload"];
+type StashPopPayload = StashPopResponse["payload"];
+type StashListPayload = StashListResponse["payload"];
+type ValidateBranchPayload = ValidateBranchResponse["payload"];
+type BranchSuggestionsPayload = BranchSuggestionsResponse["payload"];
+type GitHubSearchPayload = GitHubSearchResponse["payload"];
+type DirectorySuggestionsPayload = DirectorySuggestionsResponse["payload"];
+type BySpaceWorktreeListPayload = BySpaceWorktreeListResponse["payload"];
+type BySpaceWorktreeArchivePayload = BySpaceWorktreeArchiveResponse["payload"];
+type CreateBySpaceWorktreePayload = Extract<SessionOutboundMessage, {
+    type: "create_byspace_worktree_response";
+}>["payload"];
+type WorkspaceCreatePayload = Extract<SessionOutboundMessage, {
+    type: "workspace.create.response";
+}>["payload"];
+type FileExplorerPayload = FileExplorerResponse["payload"];
+export type FileExplorerDirectoryPayload = NonNullable<FileExplorerPayload["directory"]>;
+type LegacyFileExplorerFilePayload = NonNullable<FileExplorerPayload["file"]>;
+export interface FileReadResult {
+    bytes: Uint8Array;
+    mime: string;
+    size: number;
+    path: string;
+    kind: LegacyFileExplorerFilePayload["kind"];
+    modifiedAt: string;
+}
+export interface FileUploadInput {
+    fileName: string;
+    mimeType: string;
+    bytes: Uint8Array | ArrayBuffer;
+    modifiedAt?: string;
+    requestId?: string;
+    chunkSize?: number;
+}
+export type FileUploadResult = FileUploadResponse["payload"];
+type FileDownloadTokenPayload = FileDownloadTokenResponse["payload"];
+type ListProviderFeaturesPayload = ListProviderFeaturesResponseMessage["payload"];
+type ListProviderModelsPayload = ListProviderModelsResponseMessage["payload"];
+type ListProviderModesPayload = ListProviderModesResponseMessage["payload"];
+type ListAvailableProvidersPayload = ListAvailableProvidersResponse["payload"];
+type GetProvidersSnapshotPayload = GetProvidersSnapshotResponseMessage["payload"];
+type RefreshProvidersSnapshotPayload = RefreshProvidersSnapshotResponseMessage["payload"];
+type ProviderDiagnosticPayload = ProviderDiagnosticResponseMessage["payload"];
+type ProviderUsageListPayload = ProviderUsageListResponseMessage["payload"];
+type DaemonStatusPayload = DaemonGetStatusResponse["payload"];
+type DaemonPairingOfferPayload = DaemonGetPairingOfferResponse["payload"];
+type DiagnosticsPayload = DiagnosticsResponse["payload"];
+type ReadProjectConfigPayload = Extract<SessionOutboundMessage, {
+    type: "read_project_config_response";
+}>["payload"];
+type WriteProjectConfigPayload = Extract<SessionOutboundMessage, {
+    type: "write_project_config_response";
+}>["payload"];
+type ListCommandsPayload = ListCommandsResponse["payload"];
+type ListCommandsDraftConfig = Pick<AgentSessionConfig, "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId" | "featureValues">;
+export interface WriteProjectConfigInput {
+    repoRoot: string;
+    config: BySpaceConfigRaw;
+    expectedRevision: BySpaceConfigRevision | null;
+    requestId?: string;
+}
+interface ListCommandsOptions {
+    agentId: string;
+    requestId?: string;
+    draftConfig?: ListCommandsDraftConfig;
+}
+type LegacyListCommandsOptions = Omit<ListCommandsOptions, "agentId">;
+type SetVoiceModePayload = Extract<SessionOutboundMessage, {
+    type: "set_voice_mode_response";
+}>["payload"];
+type AgentPermissionResolvedPayload = AgentPermissionResolvedMessage["payload"];
+type ListTerminalsPayload = ListTerminalsResponse["payload"];
+type CreateTerminalPayload = CreateTerminalResponse["payload"];
+export type RenameTerminalResult = z.infer<typeof RenameTerminalResponseSchema>["payload"];
+type SubscribeTerminalPayload = SubscribeTerminalResponse["payload"];
+type CloseItemsPayload = CloseItemsResponse["payload"];
+type KillTerminalPayload = KillTerminalResponse["payload"];
+type CaptureTerminalPayload = CaptureTerminalResponse["payload"];
+type ChatCreatePayload = Extract<SessionOutboundMessage, {
+    type: "chat/create/response";
+}>["payload"];
+type ChatListPayload = Extract<SessionOutboundMessage, {
+    type: "chat/list/response";
+}>["payload"];
+type ChatInspectPayload = Extract<SessionOutboundMessage, {
+    type: "chat/inspect/response";
+}>["payload"];
+type ChatDeletePayload = Extract<SessionOutboundMessage, {
+    type: "chat/delete/response";
+}>["payload"];
+type ChatPostPayload = Extract<SessionOutboundMessage, {
+    type: "chat/post/response";
+}>["payload"];
+type ChatReadPayload = Extract<SessionOutboundMessage, {
+    type: "chat/read/response";
+}>["payload"];
+type ChatWaitPayload = Extract<SessionOutboundMessage, {
+    type: "chat/wait/response";
+}>["payload"];
+type LoopRunPayload = Extract<SessionOutboundMessage, {
+    type: "loop/run/response";
+}>["payload"];
+type LoopListPayload = Extract<SessionOutboundMessage, {
+    type: "loop/list/response";
+}>["payload"];
+type LoopInspectPayload = Extract<SessionOutboundMessage, {
+    type: "loop/inspect/response";
+}>["payload"];
+type LoopLogsPayload = Extract<SessionOutboundMessage, {
+    type: "loop/logs/response";
+}>["payload"];
+type LoopStopPayload = Extract<SessionOutboundMessage, {
+    type: "loop/stop/response";
+}>["payload"];
+type ScheduleCreatePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/create/response";
+}>["payload"];
+type ScheduleListPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/list/response";
+}>["payload"];
+type ScheduleInspectPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/inspect/response";
+}>["payload"];
+type ScheduleLogsPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/logs/response";
+}>["payload"];
+type SchedulePausePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/pause/response";
+}>["payload"];
+type ScheduleResumePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/resume/response";
+}>["payload"];
+type ScheduleDeletePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/delete/response";
+}>["payload"];
+type ScheduleRunOncePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/run-once/response";
+}>["payload"];
+type ScheduleUpdatePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/update/response";
+}>["payload"];
+export type FetchAgentTimelinePayload = FetchAgentTimelineResponseMessage["payload"];
+export type AgentForkContextPayload = AgentForkContextResponseMessage["payload"];
+export type FetchAgentTimelineDirection = FetchAgentTimelinePayload["direction"];
+export type FetchAgentTimelineProjection = FetchAgentTimelinePayload["projection"];
+export type FetchAgentTimelineCursor = NonNullable<FetchAgentTimelinePayload["startCursor"]>;
+export interface FetchAgentOptions {
+    agentId: string;
+    requestId?: string;
+    timeout?: number;
+}
+type LegacyFetchAgentOptions = Omit<FetchAgentOptions, "agentId">;
+export interface FetchAgentTimelineOptions {
+    direction?: FetchAgentTimelineDirection;
+    cursor?: FetchAgentTimelineCursor;
+    limit?: number;
+    projection?: FetchAgentTimelineProjection;
+    requestId?: string;
+    timeout?: number;
+}
+export type ProviderSubagentListPayload = Extract<SessionOutboundMessage, {
+    type: "agent.provider_subagents.list.response";
+}>["payload"];
+export type ProviderSubagentTimelinePayload = Extract<SessionOutboundMessage, {
+    type: "agent.provider_subagents.timeline.get.response";
+}>["payload"];
+export interface FetchProviderSubagentTimelineOptions {
+    direction?: ProviderSubagentTimelinePayload["direction"];
+    cursor?: FetchAgentTimelineCursor;
+    limit?: number;
+    requestId?: string;
+    timeout?: number;
+}
+export interface AgentForkContextOptions {
+    boundaryCursor?: FetchAgentTimelineCursor;
+    boundaryMessageId?: string;
+    requestId?: string;
+}
+type AgentRefreshedStatusPayload = z.infer<typeof AgentRefreshedStatusPayloadSchema>;
+type RestartRequestedStatusPayload = z.infer<typeof RestartRequestedStatusPayloadSchema>;
+type ShutdownRequestedStatusPayload = z.infer<typeof ShutdownRequestedStatusPayloadSchema>;
+export interface ShutdownServerOptions {
+    requestId?: string;
+    timeout?: number;
+}
+export interface DaemonStatusOptions {
+    requestId?: string;
+    timeout?: number;
+}
+export interface DaemonPairingOfferOptions {
+    requestId?: string;
+    timeout?: number;
+}
+type DaemonUpdateResponse = z.infer<typeof DaemonUpdateResponseSchema>;
+type FetchAgentsPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_agents_response";
+}>["payload"];
+type FetchAgentsRequest = Extract<SessionInboundMessage, {
+    type: "fetch_agents_request";
+}>;
+export type FetchAgentsOptions = Omit<FetchAgentsRequest, "type" | "requestId"> & {
+    requestId?: string;
+    timeout?: number;
+};
+export type FetchAgentsEntry = FetchAgentsPayload["entries"][number];
+export type FetchAgentsPageInfo = FetchAgentsPayload["pageInfo"];
+type FetchAgentHistoryPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_agent_history_response";
+}>["payload"];
+type FetchAgentHistoryRequest = Extract<SessionInboundMessage, {
+    type: "fetch_agent_history_request";
+}>;
+export type FetchAgentHistoryOptions = Omit<FetchAgentHistoryRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchAgentHistoryEntry = FetchAgentHistoryPayload["entries"][number];
+export type FetchAgentHistoryPageInfo = FetchAgentHistoryPayload["pageInfo"];
+type FetchRecentProviderSessionsPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_recent_provider_sessions_response";
+}>["payload"];
+type FetchRecentProviderSessionsRequest = Extract<SessionInboundMessage, {
+    type: "fetch_recent_provider_sessions_request";
+}>;
+export type FetchRecentProviderSessionsOptions = Omit<FetchRecentProviderSessionsRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchRecentProviderSessionEntry = FetchRecentProviderSessionsPayload["entries"][number];
+type FetchWorkspacesPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_workspaces_response";
+}>["payload"];
+type FetchWorkspacesRequest = Extract<SessionInboundMessage, {
+    type: "fetch_workspaces_request";
+}>;
+export type FetchWorkspacesOptions = Omit<FetchWorkspacesRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchWorkspacesEntry = FetchWorkspacesPayload["entries"][number];
+export type FetchWorkspacesPageInfo = FetchWorkspacesPayload["pageInfo"];
+export interface CreateChatRoomOptions {
+    name: string;
+    purpose?: string | null;
+    requestId?: string;
+}
+export interface InspectChatRoomOptions {
+    room: string;
+    requestId?: string;
+}
+export interface DeleteChatRoomOptions {
+    room: string;
+    requestId?: string;
+}
+export interface PostChatMessageOptions {
+    room: string;
+    body: string;
+    authorAgentId?: string;
+    replyToMessageId?: string | null;
+    requestId?: string;
+}
+export interface ReadChatMessagesOptions {
+    room: string;
+    limit?: number;
+    since?: string;
+    authorAgentId?: string;
+    requestId?: string;
+    timeout?: number;
+}
+export interface WaitForChatMessagesOptions {
+    room: string;
+    afterMessageId?: string | null;
+    timeoutMs?: number;
+    requestId?: string;
+}
+export interface RunLoopOptions {
+    prompt: string;
+    cwd: string;
+    provider?: string;
+    model?: string;
+    modeId?: string;
+    verifierProvider?: string;
+    verifierModel?: string;
+    verifierModeId?: string;
+    verifyPrompt?: string | null;
+    verifyChecks?: string[];
+    name?: string | null;
+    sleepMs?: number;
+    maxIterations?: number;
+    maxTimeMs?: number;
+    requestId?: string;
+}
+export interface InspectLoopOptions {
+    id: string;
+    requestId?: string;
+}
+export interface LoopLogsOptions {
+    id: string;
+    afterSeq?: number;
+    requestId?: string;
+}
+export interface StopLoopOptions {
+    id: string;
+    requestId?: string;
+}
+export interface CreateScheduleOptions {
+    prompt: string;
+    name?: string | null;
+    cadence: {
+        type: "every";
+        everyMs: number;
+    } | {
+        type: "cron";
+        expression: string;
+        timezone?: string;
+    };
+    target: {
+        type: "self";
+        agentId: string;
+    } | {
+        type: "agent";
+        agentId: string;
+    } | {
+        type: "new-agent";
+        config: {
+            provider: AgentProvider;
+            cwd: string;
+            modeId?: string;
+            model?: string;
+            thinkingOptionId?: string;
+            archiveOnFinish?: boolean;
+            isolation?: "local" | "worktree";
+            title?: string | null;
+            approvalPolicy?: string;
+            sandboxMode?: string;
+            networkAccess?: boolean;
+            webSearch?: boolean;
+            extra?: AgentSessionConfig["extra"];
+            systemPrompt?: string;
+            mcpServers?: AgentSessionConfig["mcpServers"];
+        };
+    };
+    maxRuns?: number;
+    expiresAt?: string;
+    runOnCreate?: boolean;
+    requestId?: string;
+}
+export interface InspectScheduleOptions {
+    id: string;
+    requestId?: string;
+}
+export interface UpdateScheduleNewAgentConfig {
+    provider?: string;
+    model?: string | null;
+    modeId?: string | null;
+    thinkingOptionId?: string | null;
+    archiveOnFinish?: boolean;
+    isolation?: "local" | "worktree";
+    cwd?: string;
+}
+export interface UpdateScheduleOptions {
+    id: string;
+    name?: string | null;
+    prompt?: string;
+    cadence?: {
+        type: "every";
+        everyMs: number;
+    } | {
+        type: "cron";
+        expression: string;
+        timezone?: string;
+    };
+    newAgentConfig?: UpdateScheduleNewAgentConfig;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+    requestId?: string;
+}
+export interface RenameBranchInput {
+    cwd: string;
+    branch: string;
+    requestId?: string;
+}
+export interface RenameTerminalInput {
+    terminalId: string;
+    title: string;
+    requestId?: string;
+}
+type OpenProjectPayload = OpenProjectResponseMessage["payload"];
+type ProjectAddPayload = ProjectAddResponse["payload"];
+type WorkspaceGithubClonePayload = WorkspaceGithubCloneResponse["payload"];
+type ArchiveWorkspacePayload = ArchiveWorkspaceResponseMessage["payload"];
+type WorkspaceSetupStatusPayload = WorkspaceSetupStatusResponseMessage["payload"];
+export interface FetchAgentResult {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload | null;
+}
+export interface WaitForFinishResult {
+    status: "idle" | "error" | "permission" | "timeout";
+    final: AgentSnapshotPayload | null;
+    error: string | null;
+    lastMessage: string | null;
+}
+export declare class DaemonClient {
+    private config;
+    private transport;
+    private transportCleanup;
+    private rawMessageListeners;
+    private messageHandlers;
+    private eventListeners;
+    private waiters;
+    private checkoutStatusInFlight;
+    private connectionListeners;
+    private reconnectTimeout;
+    private connectTimeout;
+    private pendingGenericTransportErrorTimeout;
+    private reconnectAttempt;
+    private shouldReconnect;
+    private connectPromise;
+    private connectResolve;
+    private connectReject;
+    private lastErrorValue;
+    private connectionState;
+    private checkoutDiffSubscriptions;
+    private terminalDirectorySubscriptions;
+    private readonly terminalStreams;
+    private pendingBinaryFileReads;
+    private activeBinaryFileTransfers;
+    private completedBinaryFileReads;
+    private logger;
+    private pendingSendQueue;
+    private readonly logConnectionPath;
+    private readonly logServerId;
+    private readonly logClientIdHash;
+    private readonly logGeneration;
+    private lastServerInfoMessage;
+    private runtimeMetricsInterval;
+    private runtimeMetrics;
+    private pingProbe;
+    private livenessHeartbeatTimer;
+    private lastLivenessRttMs;
+    private consecutiveLivenessFailures;
+    constructor(config: DaemonClientConfig);
+    connect(): Promise<void>;
+    private attemptConnect;
+    private resolveConnect;
+    private rejectConnect;
+    close(): Promise<void>;
+    ensureConnected(): void;
+    getConnectionState(): ConnectionState;
+    subscribeConnectionStatus(listener: (status: ConnectionState) => void): () => void;
+    get isConnected(): boolean;
+    get isConnecting(): boolean;
+    get lastError(): string | null;
+    getLastLivenessRttMs(): number | null;
+    subscribe(handler: DaemonEventHandler): () => void;
+    subscribeRawMessages(handler: (message: SessionOutboundMessage) => void): () => void;
+    on<TType extends SessionOutboundMessage["type"]>(type: TType, handler: (message: Extract<SessionOutboundMessage, {
+        type: TType;
+    }>) => void): () => void;
+    on(handler: DaemonEventHandler): () => void;
+    /**
+     * Send a session message. For fire-and-forget messages (heartbeats, etc.),
+     * failures are suppressed if `suppressSendErrors` is configured.
+     * For RPC methods that wait for responses, use `sendSessionMessageOrThrow` instead.
+     */
+    private sendSessionMessage;
+    private sendBinaryFrame;
+    /**
+     * Send a session message for RPC methods that create waiters.
+     * If the connection is still being established ("connecting"), the message
+     * is queued and will be sent once connected (or rejected after timeout).
+     * This prevents waiters from hanging forever when called during connection.
+     */
+    private sendSessionMessageOrThrow;
+    /**
+     * Flush pending send queue - called when connection is established.
+     */
+    private flushPendingSendQueue;
+    /**
+     * Reject all pending sends - called when connection fails or is closed.
+     */
+    private rejectPendingSendQueue;
+    private sendRequest;
+    private sendCorrelatedRequest;
+    private sendCorrelatedSessionRequest;
+    private sendNamespacedCorrelatedSessionRequest;
+    private sendSessionMessageStrict;
+    clearAgentAttention(agentId: string | string[]): Promise<void>;
+    clearWorkspaceAttention(workspaceId: string | string[]): Promise<void>;
+    sendHeartbeat(params: {
+        deviceType: "web" | "mobile";
+        focusedAgentId: string | null;
+        focusedTerminalId?: string | null;
+        lastActivityAt: string;
+        appVisible: boolean;
+        appVisibilityChangedAt?: string;
+    }): void;
+    registerPushToken(token: string): void;
+    ping(params?: {
+        requestId?: string;
+        timeoutMs?: number;
+    }): Promise<{
+        requestId: string;
+        clientSentAt: number;
+        serverReceivedAt: number;
+        serverSentAt: number;
+        rttMs: number;
+    }>;
+    measureLatency(params?: {
+        timeoutMs?: number;
+    }): Promise<number>;
+    private livenessPing;
+    private sendPingAwaitRtt;
+    private startLivenessHeartbeat;
+    private stopLivenessHeartbeat;
+    private scheduleNextLivenessHeartbeat;
+    fetchAgents(options?: FetchAgentsOptions): Promise<FetchAgentsPayload>;
+    fetchAgentHistory(options?: FetchAgentHistoryOptions): Promise<FetchAgentHistoryPayload>;
+    fetchRecentProviderSessions(options?: FetchRecentProviderSessionsOptions): Promise<FetchRecentProviderSessionsPayload>;
+    fetchWorkspaces(options?: FetchWorkspacesOptions): Promise<FetchWorkspacesPayload>;
+    openProject(cwd: string, requestId?: string): Promise<OpenProjectPayload>;
+    addProject(cwd: string, requestId?: string): Promise<ProjectAddPayload>;
+    cloneGithubWorkspace(input: {
+        repo: string;
+        targetDirectory: string;
+        cloneProtocol?: WorkspaceGithubCloneProtocol;
+    }, requestId?: string): Promise<WorkspaceGithubClonePayload>;
+    startWorkspaceScript(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
+        type: "start_workspace_script_response";
+    }>["payload"]>;
+    archiveWorkspace(workspaceId: string, requestId?: string): Promise<ArchiveWorkspacePayload>;
+    fetchWorkspaceSetupStatus(workspaceId: string, requestId?: string): Promise<WorkspaceSetupStatusPayload>;
+    fetchAgent(options: FetchAgentOptions): Promise<FetchAgentResult | null>;
+    fetchAgent(agentId: string, requestId?: string): Promise<FetchAgentResult | null>;
+    fetchAgent(agentId: string, options?: LegacyFetchAgentOptions): Promise<FetchAgentResult | null>;
+    private resubscribeCheckoutDiffSubscriptions;
+    private resubscribeTerminalDirectorySubscriptions;
+    createAgent(options: CreateAgentRequestOptions): Promise<AgentSnapshotPayload>;
+    deleteAgent(agentId: string): Promise<void>;
+    archiveAgent(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    detachAgent(agentId: string): Promise<void>;
+    updateAgent(agentId: string, updates: {
+        name?: string;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+    renameProject(projectId: string, customName: string | null, requestId?: string): Promise<{
+        customName: string | null;
+    }>;
+    removeProject(projectId: string, requestId?: string): Promise<{
+        removedWorkspaceIds: string[];
+    }>;
+    setWorkspaceTitle(workspaceId: string, title: string | null, requestId?: string): Promise<{
+        title: string | null;
+    }>;
+    setWorkspacePinned(workspaceId: string, pinned: boolean, requestId?: string): Promise<{
+        pinnedAt: string | null;
+    }>;
+    resumeAgent(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>): Promise<AgentSnapshotPayload>;
+    importAgent(input: ImportAgentInput): Promise<AgentSnapshotPayload>;
+    refreshAgent(agentId: string, requestId?: string): Promise<AgentRefreshedStatusPayload>;
+    fetchAgentTimeline(agentId: string, options?: FetchAgentTimelineOptions): Promise<FetchAgentTimelinePayload>;
+    listProviderSubagents(parentAgentId: string, options?: {
+        requestId?: string;
+        timeout?: number;
+    }): Promise<ProviderSubagentListPayload>;
+    fetchProviderSubagentTimeline(parentAgentId: string, subagentId: string, options?: FetchProviderSubagentTimelineOptions): Promise<ProviderSubagentTimelinePayload>;
+    buildAgentForkContext(agentId: string, options?: AgentForkContextOptions): Promise<AgentForkContextPayload>;
+    sendAgentMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
+    sendMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
+    rewindAgent(agentId: string, messageId: string, mode: "conversation" | "files" | "both"): Promise<AgentRewindResponseMessage["payload"]>;
+    cancelAgent(agentId: string): Promise<void>;
+    setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    setAgentModel(agentId: string, modelId: string | null): Promise<void>;
+    setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
+    setAgentThinkingOption(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
+    restartServer(reason?: string, requestId?: string): Promise<RestartRequestedStatusPayload>;
+    shutdownServer(options?: ShutdownServerOptions): Promise<ShutdownRequestedStatusPayload>;
+    updateDaemon(requestId?: string): Promise<DaemonUpdateResponse["payload"]>;
+    setVoiceMode(enabled: boolean, agentId?: string): Promise<SetVoiceModePayload>;
+    sendVoiceAudioChunk(audio: string, format: string, isLast?: boolean): Promise<void>;
+    startDictationStream(dictationId: string, format: string): Promise<void>;
+    sendDictationStreamChunk(dictationId: string, seq: number, audio: string, format: string): void;
+    finishDictationStream(dictationId: string, finalSeq: number): Promise<{
+        dictationId: string;
+        text: string;
+    }>;
+    cancelDictationStream(dictationId: string): void;
+    abortRequest(): Promise<void>;
+    audioPlayed(id: string): Promise<void>;
+    getCheckoutStatus(cwd: string, options?: {
+        requestId?: string;
+    }): Promise<CheckoutStatusPayload>;
+    private normalizeCheckoutDiffCompare;
+    getCheckoutDiff(cwd: string, compare: {
+        mode: "uncommitted" | "base";
+        baseRef?: string;
+        ignoreWhitespace?: boolean;
+    }, requestId?: string): Promise<CheckoutDiffPayload>;
+    subscribeCheckoutDiff(cwd: string, compare: {
+        mode: "uncommitted" | "base";
+        baseRef?: string;
+        ignoreWhitespace?: boolean;
+    }, options?: {
+        subscriptionId?: string;
+        requestId?: string;
+    }): Promise<SubscribeCheckoutDiffPayload>;
+    unsubscribeCheckoutDiff(subscriptionId: string): void;
+    checkoutCommit(cwd: string, input: {
+        message?: string;
+        addAll?: boolean;
+    }, requestId?: string): Promise<CheckoutCommitPayload>;
+    checkoutMerge(cwd: string, input: {
+        baseRef?: string;
+        strategy?: "merge" | "squash";
+        requireCleanTarget?: boolean;
+    }, requestId?: string): Promise<CheckoutMergePayload>;
+    checkoutMergeFromBase(cwd: string, input: {
+        baseRef?: string;
+        requireCleanTarget?: boolean;
+    }, requestId?: string): Promise<CheckoutMergeFromBasePayload>;
+    checkoutPull(cwd: string, requestId?: string): Promise<CheckoutPullPayload>;
+    checkoutPush(cwd: string, requestId?: string): Promise<CheckoutPushPayload>;
+    checkoutRefresh(cwd: string, requestId?: string): Promise<CheckoutRefreshPayload>;
+    checkoutPrCreate(cwd: string, input: {
+        title?: string;
+        body?: string;
+        baseRef?: string;
+    }, requestId?: string): Promise<CheckoutPrCreatePayload>;
+    checkoutPrMerge(cwd: string, input: {
+        method: CheckoutPrMergeMethod;
+    }, requestId?: string): Promise<CheckoutPrMergePayload>;
+    checkoutGithubSetAutoMerge(cwd: string, input: {
+        enabled: true;
+        method: CheckoutPrMergeMethod;
+    } | {
+        enabled: false;
+    }, requestId?: string): Promise<CheckoutGithubSetAutoMergePayload>;
+    checkoutGithubGetCheckDetails(input: {
+        cwd: string;
+        repoOwner: string;
+        repoName: string;
+        checkRunId: number;
+        workflowRunId?: number;
+    }, requestId?: string): Promise<CheckoutGithubGetCheckDetailsPayload>;
+    checkoutPrStatus(cwd: string, requestId?: string): Promise<CheckoutPrStatusPayload>;
+    pullRequestTimeline(input: {
+        cwd: string;
+        prNumber: number;
+        repoOwner: string;
+        repoName: string;
+    }, requestId?: string): Promise<PullRequestTimelinePayload>;
+    checkoutSwitchBranch(cwd: string, branch: string, requestId?: string): Promise<CheckoutSwitchBranchPayload>;
+    renameBranch(input: RenameBranchInput): Promise<RenameBranchResult>;
+    stashSave(cwd: string, options?: {
+        branch?: string;
+    }, requestId?: string): Promise<StashSavePayload>;
+    stashPop(cwd: string, stashIndex: number, requestId?: string): Promise<StashPopPayload>;
+    stashList(cwd: string, options?: {
+        byspaceOnly?: boolean;
+    }, requestId?: string): Promise<StashListPayload>;
+    getBySpaceWorktreeList(input: {
+        cwd?: string;
+        repoRoot?: string;
+    }, requestId?: string): Promise<BySpaceWorktreeListPayload>;
+    archiveBySpaceWorktree(input: {
+        worktreePath?: string;
+        repoRoot?: string;
+        branchName?: string;
+        workspaceId?: string;
+        scope?: "workspace" | "worktree";
+    }, requestId?: string): Promise<BySpaceWorktreeArchivePayload>;
+    createBySpaceWorktree(input: CreateBySpaceWorktreeInput, requestId?: string): Promise<CreateBySpaceWorktreePayload>;
+    createWorkspace(input: {
+        source: WorkspaceCreateRequest["source"];
+        title?: string;
+        firstAgentContext?: WorkspaceCreateRequest["firstAgentContext"];
+    }, requestId?: string): Promise<WorkspaceCreatePayload>;
+    validateBranch(options: {
+        cwd: string;
+        branchName: string;
+    }, requestId?: string): Promise<ValidateBranchPayload>;
+    getBranchSuggestions(options: {
+        cwd: string;
+        query?: string;
+        limit?: number;
+    }, requestId?: string): Promise<BranchSuggestionsPayload>;
+    searchGitHub(options: {
+        cwd: string;
+        query: string;
+        limit?: number;
+        kinds?: GitHubSearchRequest["kinds"];
+    }, requestId?: string): Promise<GitHubSearchPayload>;
+    getDirectorySuggestions(options: {
+        query: string;
+        limit?: number;
+        cwd?: string;
+        includeFiles?: boolean;
+        includeDirectories?: boolean;
+        matchMode?: "fuzzy" | "suffix";
+    }, requestId?: string): Promise<DirectorySuggestionsPayload>;
+    private requestFileExplorer;
+    listDirectory(cwd: string, path: string, requestId?: string): Promise<FileExplorerDirectoryPayload>;
+    readFile(cwd: string, path: string, requestId?: string): Promise<FileReadResult>;
+    uploadFile(input: FileUploadInput): Promise<FileUploadResult>;
+    requestDownloadToken(cwd: string, path: string, requestId?: string): Promise<FileDownloadTokenPayload>;
+    requestProjectIcon(cwd: string, requestId?: string): Promise<ProjectIconResponse["payload"]>;
+    listProviderModels(provider: AgentProvider, options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<ListProviderModelsPayload>;
+    listProviderModes(provider: AgentProvider, options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<ListProviderModesPayload>;
+    listProviderFeatures(draftConfig: ListCommandsDraftConfig, options?: {
+        requestId?: string;
+    }): Promise<ListProviderFeaturesPayload>;
+    listAvailableProviders(options?: {
+        requestId?: string;
+    }): Promise<ListAvailableProvidersPayload>;
+    getProvidersSnapshot(options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<GetProvidersSnapshotPayload>;
+    getDaemonConfig(requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+    getDaemonStatus(options?: DaemonStatusOptions): Promise<DaemonStatusPayload>;
+    getDaemonPairingOffer(options?: DaemonPairingOfferOptions): Promise<DaemonPairingOfferPayload>;
+    collectDiagnostics(requestId?: string): Promise<DiagnosticsPayload>;
+    patchDaemonConfig(config: MutableDaemonConfigPatch, requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+    readProjectConfig(repoRoot: string, requestId?: string): Promise<ReadProjectConfigPayload>;
+    writeProjectConfig(input: WriteProjectConfigInput): Promise<WriteProjectConfigPayload>;
+    refreshProvidersSnapshot(options?: {
+        cwd?: string;
+        providers?: AgentProvider[];
+        requestId?: string;
+    }): Promise<RefreshProvidersSnapshotPayload>;
+    getProviderDiagnostic(provider: AgentProvider, options?: {
+        requestId?: string;
+    }): Promise<ProviderDiagnosticPayload>;
+    listProviderUsage(options?: {
+        requestId?: string;
+    }): Promise<ProviderUsageListPayload>;
+    listCommands(options: ListCommandsOptions): Promise<ListCommandsPayload>;
+    listCommands(agentId: string, requestId?: string): Promise<ListCommandsPayload>;
+    listCommands(agentId: string, options?: LegacyListCommandsOptions): Promise<ListCommandsPayload>;
+    respondToPermission(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<void>;
+    respondToPermissionAndWait(agentId: string, requestId: string, response: AgentPermissionResponse, timeout?: number): Promise<AgentPermissionResolvedPayload>;
+    waitForAgentUpsert(agentId: string, predicate: (snapshot: AgentSnapshotPayload) => boolean, timeout?: number): Promise<AgentSnapshotPayload>;
+    waitForFinish(agentId: string, timeout?: number): Promise<WaitForFinishResult>;
+    subscribeTerminals(input: {
+        cwd: string;
+        workspaceId?: string;
+    }): void;
+    unsubscribeTerminals(input: {
+        cwd: string;
+        workspaceId?: string;
+    }): void;
+    listTerminals(cwd?: string, requestId?: string, options?: {
+        workspaceId?: string;
+    }): Promise<ListTerminalsPayload>;
+    createTerminal(cwd: string, name?: string, requestId?: string, options?: {
+        agentId?: string;
+        command?: string;
+        args?: string[];
+        workspaceId?: string;
+        size?: {
+            rows: number;
+            cols: number;
+        };
+    }): Promise<CreateTerminalPayload>;
+    renameTerminal(input: RenameTerminalInput): Promise<RenameTerminalResult>;
+    subscribeTerminal(terminalId: string, optionsOrRequestId?: {
+        restore?: SubscribeTerminalRequest["restore"];
+        requestId?: string;
+    } | string): Promise<SubscribeTerminalPayload>;
+    unsubscribeTerminal(terminalId: string): void;
+    sendTerminalInput(terminalId: string, message: TerminalInput["message"]): void;
+    killTerminal(terminalId: string, requestId?: string): Promise<KillTerminalPayload>;
+    closeItems(input: {
+        agentIds?: string[];
+        terminalIds?: string[];
+    }, requestId?: string): Promise<CloseItemsPayload>;
+    captureTerminal(terminalId: string, options?: {
+        start?: number;
+        end?: number;
+        stripAnsi?: boolean;
+    }, requestId?: string): Promise<CaptureTerminalPayload>;
+    createChatRoom(options: CreateChatRoomOptions): Promise<ChatCreatePayload>;
+    listChatRooms(requestId?: string): Promise<ChatListPayload>;
+    inspectChatRoom(options: InspectChatRoomOptions): Promise<ChatInspectPayload>;
+    deleteChatRoom(options: DeleteChatRoomOptions): Promise<ChatDeletePayload>;
+    postChatMessage(options: PostChatMessageOptions): Promise<ChatPostPayload>;
+    readChatMessages(options: ReadChatMessagesOptions): Promise<ChatReadPayload>;
+    waitForChatMessages(options: WaitForChatMessagesOptions): Promise<ChatWaitPayload>;
+    scheduleCreate(options: CreateScheduleOptions): Promise<ScheduleCreatePayload>;
+    scheduleList(requestId?: string): Promise<ScheduleListPayload>;
+    scheduleInspect(options: InspectScheduleOptions): Promise<ScheduleInspectPayload>;
+    scheduleLogs(options: InspectScheduleOptions): Promise<ScheduleLogsPayload>;
+    schedulePause(options: InspectScheduleOptions): Promise<SchedulePausePayload>;
+    scheduleResume(options: InspectScheduleOptions): Promise<ScheduleResumePayload>;
+    scheduleDelete(options: InspectScheduleOptions): Promise<ScheduleDeletePayload>;
+    scheduleRunOnce(options: InspectScheduleOptions): Promise<ScheduleRunOncePayload>;
+    scheduleUpdate(options: UpdateScheduleOptions): Promise<ScheduleUpdatePayload>;
+    loopRun(options: RunLoopOptions): Promise<LoopRunPayload>;
+    loopList(requestId?: string): Promise<LoopListPayload>;
+    loopInspect(options: string | InspectLoopOptions): Promise<LoopInspectPayload>;
+    loopLogs(options: string | LoopLogsOptions, afterSeq?: number): Promise<LoopLogsPayload>;
+    loopStop(options: string | StopLoopOptions): Promise<LoopStopPayload>;
+    onTerminalStreamEvent(handler: (event: TerminalStreamEvent) => void): () => void;
+    waitForTerminalStreamEvent(predicate: (event: TerminalStreamEvent) => boolean, timeout?: number): Promise<TerminalStreamEvent>;
+    private createRequestId;
+    getLastServerInfoMessage(): ServerInfoStatusPayload | null;
+    private resolveTransportUrlForAttempt;
+    private sendHelloMessage;
+    private disposeTransport;
+    private cleanupTransport;
+    private resetConnectTimeout;
+    private handleTransportMessage;
+    private handleJsonPayload;
+    private tryHandleBinaryFrame;
+    private handleFileTransferFrame;
+    private updateConnectionState;
+    setReconnectEnabled(enabled: boolean): void;
+    private scheduleReconnect;
+    private emitDisconnectedStateForReconnect;
+    private armReconnectTimer;
+    private resolvePingProbe;
+    private clearPingProbe;
+    private rejectPingProbe;
+    private recordLivenessFailure;
+    private handleSessionMessage;
+    private resolveWaiters;
+    private clearWaiters;
+    private toEvent;
+    private waitForWithCancel;
+}
+//# sourceMappingURL=daemon-client.d.ts.map