@qoder-ai/qoder-agent-sdk 1.0.26 → 1.0.28

package/README.md

@@ -448,13 +448,37 @@ the main session.
 
 `sessionStoreFlush: "batched"` is the default. `"eager"` starts each append
 without waiting for the result boundary. Final append failures are emitted as
-non-fatal `system/mirror_error` messages. `loadTimeoutMs` defaults to 60,000 ms.
+non-fatal `system/mirror_error` messages. Each append batch is submitted once:
+the SDK does not retry a mutation whose commit outcome may be unknown.
+`loadTimeoutMs` defaults to 60,000 ms.
 Session storage cannot be combined with `persistSession: false`, file
 checkpointing, custom transports, or the Cloud Agent runtime. Session storage
 supports the built-in Process and Worker transports. Use
 `importSessionToStore(sessionId, store, options)` to copy an existing local main
 transcript, child-agent transcripts, and metadata into a store.
 
+For a shared daemon, implement `DaemonSessionStore`, which adds
+`listAllSessions()`, and bind it once at daemon startup:
+
+```ts
+const daemon = await startDaemon({
+  auth: qodercliAuth(),
+  capacity: 4,
+  sessionStore,
+});
+
+const running = query({
+  prompt,
+  options: { daemon, cwd: "/path/to/project" },
+});
+```
+
+`listAllSessions()` returns only main Sessions owned by that Host Store. Each
+summary contains the exact stored `key`, a non-empty title, an ISO timestamp,
+and the canonical working directory. Daemon-bound Queries reuse this one Store
+and cannot override it per Query. Registration sends summaries only; transcript
+entries are loaded lazily when a Worker needs to resume the Session.
+
 ### Production stores
 
 The SDK exports the `SessionStore` interface but does not ship a

package/dist/core/bounded-line-transform.d.ts

@@ -0,0 +1,16 @@
+import { Transform, type TransformCallback } from 'node:stream';
+export declare const DEFAULT_MAX_JSONL_FRAME_BYTES: number;
+export declare class FrameTooLargeError extends Error {
+    readonly direction: string;
+    readonly limit: number;
+    readonly code = "DAEMON_FRAME_TOO_LARGE";
+    constructor(direction: string, limit: number);
+}
+export declare class BoundedLineTransform extends Transform {
+    private readonly maxLineBytes;
+    private readonly direction;
+    private bytesSinceNewline;
+    constructor(maxLineBytes?: number, direction?: string);
+    _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void;
+}
+export declare function assertBoundedSerializedFrame(serializedFrame: string, maxFrameBytes?: number, direction?: string): void;

package/dist/core/process-transport.d.ts

@@ -17,6 +17,7 @@ import type { McpServerConfigForProcessTransport, McpServerToolPolicy } from '..
 import type { InternalAuthOptions } from '../types/auth.js';
 import type { SecurityScanOptions, SpawnedProcess, SpawnOptions, SettingSource } from '../types/options.js';
 import type { DiagnosticsSink } from './sdk-diagnostics.js';
+import type { SessionExtra } from '../daemon/session-metadata.js';
 export declare class QoderCliProcessError extends Error {
     readonly code: "QODER_CLI_PROCESS_ERROR";
     readonly exitCode?: number | null;
@@ -46,6 +47,8 @@ export interface ProcessTransportOptions {
     cwd?: string;
     /** Custom environment variables (defaults to process.env) */
     env?: Record<string, string | undefined>;
+    /** SDK-internal: config root created by SessionStore materialization. */
+    materializedSessionConfigDir?: string;
     proxy?: string;
     /**
      * VPC private-deployment endpoint (CN deployments only). Written to the
@@ -71,6 +74,8 @@ export interface ProcessTransportOptions {
     /** SDK-internal diagnostics sink. This is not forwarded to qodercli. */
     diagnostics?: DiagnosticsSink;
     agent?: string;
+    /** SDK-internal Session metadata consumed by the shared daemon. */
+    extra?: SessionExtra;
     sessionId?: string;
     continue?: boolean;
     resume?: string;

package/dist/daemon/daemon-auth-rpc.d.ts

@@ -0,0 +1,9 @@
+import type { InternalAuthOptions } from '../types/auth.js';
+import { type DaemonRequestHandler } from './daemon-connection.js';
+export declare function createDaemonAuthRequestHandler(auth: InternalAuthOptions, callbackTimeoutMs?: number): DaemonRequestHandler;
+export declare function createDaemonRequestHandler(options: {
+    auth: InternalAuthOptions;
+    sessionStoreHandler?: DaemonRequestHandler;
+    remoteSessionLaunchHandler?: DaemonRequestHandler;
+    callbackTimeoutMs?: number;
+}): DaemonRequestHandler;

package/dist/daemon/daemon-connection.d.ts

@@ -0,0 +1,98 @@
+import type { Readable, Writable } from "node:stream";
+import { type DaemonControlRequestFrame, type DaemonEventFrame, type DaemonWireSessionMessage, type JsonObject, type JsonValue, type EnableRemoteControlParams, type EnableRemoteControlResult, type OpenSessionParams, type RenameSessionResult, type SubscribeSessionResult, type UpdateSessionMetadataResult } from "./protocol.js";
+import { DaemonSessionTransport, type DaemonSessionTransportOptions } from "./daemon-session-transport.js";
+export interface DaemonConnectionOptions {
+    input: Writable;
+    output: Readable;
+    requestHandler?: DaemonRequestHandler;
+    maxFrameBytes?: number;
+}
+export type DaemonRequestHandler = (request: DaemonControlRequestFrame) => Promise<JsonValue>;
+export type RemoteControlFailure = {
+    environmentId: string;
+    error: DaemonRpcError;
+};
+export declare class DaemonRpcError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(options: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    });
+}
+export declare class DaemonRequestError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly details: JsonObject | undefined;
+    constructor(options: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: JsonObject;
+    });
+}
+export declare class DaemonConnection {
+    private readonly input;
+    private readonly requestHandler;
+    private readonly pendingRequests;
+    private readonly timedOutRequestIds;
+    private readonly activeInboundRequestIds;
+    private readonly sessions;
+    private readonly closedSessionIds;
+    private readonly pendingSessionMessages;
+    private readonly pendingSessionMessageBytes;
+    private pendingSessionMessageFrameCount;
+    private pendingSessionMessageByteCount;
+    private readonly maxFrameBytes;
+    private readonly readTask;
+    private writeChain;
+    private nextRequestId;
+    private initializing;
+    private initialized;
+    private readonly capabilities;
+    private stopping;
+    private failure;
+    private remoteControlFailureListener;
+    private readonly daemonEventListeners;
+    private readonly failureListeners;
+    constructor(options: DaemonConnectionOptions);
+    initialize(sdkVersion: string, optionalCapabilitiesOrTimeout?: readonly string[] | number, timeoutMs?: number): Promise<void>;
+    createSessionTransport(options: DaemonSessionTransportOptions): DaemonSessionTransport;
+    createAttachedSessionTransport(remoteSessionId: string): DaemonSessionTransport;
+    onRemoteControlFailure(listener: (failure: RemoteControlFailure) => void): void;
+    onDaemonEvent(listener: (event: DaemonEventFrame) => void): () => void;
+    onFailure(listener: (error: Error) => void): () => void;
+    openSession(params: OpenSessionParams, transport: DaemonSessionTransport): Promise<string>;
+    subscribeSession(remoteSessionId: string, transport: DaemonSessionTransport): Promise<SubscribeSessionResult>;
+    enableRemoteControl(params: EnableRemoteControlParams): Promise<EnableRemoteControlResult>;
+    listSessions(): Promise<import("./protocol.js").DaemonSessionInfo[]>;
+    renameSession(sessionId: string, title: string): Promise<RenameSessionResult>;
+    disableRemoteControl(): Promise<void>;
+    syncSessionRegistrations(localSessionIds: string[]): Promise<void>;
+    updateSessionMetadata(sessionId: string, extra: JsonObject): Promise<UpdateSessionMetadataResult>;
+    sendSessionMessage(message: DaemonWireSessionMessage): Promise<void>;
+    closeSession(sessionId: string): Promise<void>;
+    deleteSession(localSessionId: string): Promise<void>;
+    unsubscribeSession(sessionId: string): Promise<void>;
+    shutdown(timeoutMs?: number): Promise<void>;
+    fail(error: unknown, notifyListeners?: boolean): void;
+    private request;
+    private readOutput;
+    private acceptFrame;
+    private rememberTimedOutRequestId;
+    private routeSessionMessage;
+    private acceptControlResponse;
+    private hasPendingSessionRequest;
+    private failIfSessionMessagesAreOrphaned;
+    private bufferPendingSessionMessage;
+    private takePendingSessionMessages;
+    private deletePendingSessionMessages;
+    private clearPendingSessionMessages;
+    private rejectLegacyInitialize;
+    private acceptRequest;
+    private writeInboundError;
+    private acceptEvent;
+    private acceptRemoteControlEvent;
+    private writeFrame;
+}

package/dist/daemon/daemon-session-transport.d.ts

@@ -0,0 +1,60 @@
+import type { Transport } from '../core/transport.js';
+import type { StdoutMessage } from '../types/control.js';
+import type { DaemonWireSessionMessage, JsonObject } from './protocol.js';
+import type { DaemonConnection } from './daemon-connection.js';
+import type { SessionExtra } from './session-metadata.js';
+export type DaemonSessionTransportOptions = {
+    workerArgs: string[];
+    cwd?: string;
+    configDir?: string;
+    extra?: SessionExtra;
+    cleanup?: () => void;
+    remoteSessionId?: never;
+} | {
+    remoteSessionId: string;
+    workerArgs?: never;
+    cwd?: never;
+    configDir?: never;
+    extra?: never;
+    cleanup?: never;
+};
+export declare class DaemonSessionTransport implements Transport {
+    private readonly connection;
+    private readonly options;
+    private readonly messages;
+    private readonly pendingMessages;
+    private initializePromise;
+    private sessionId;
+    private flushingPendingMessages;
+    private inputEnded;
+    private resultReceived;
+    private commandLifecycleSupported;
+    private readonly pendingCommandUuids;
+    private closed;
+    private cleaned;
+    private releasePromise;
+    private subscribeResult;
+    private readonly remoteSessionId;
+    constructor(connection: DaemonConnection, options: DaemonSessionTransportOptions);
+    initialize(): Promise<void>;
+    initializationResult(): Promise<JsonObject>;
+    write(data: string): void;
+    readMessages(): AsyncGenerator<StdoutMessage, void, unknown>;
+    endInput(): void;
+    close(): void;
+    isReady(): boolean;
+    acceptOutput(message: DaemonWireSessionMessage): void;
+    fail(error: unknown): void;
+    private open;
+    private failAndRelease;
+    private startRelease;
+    private releaseSessionOnce;
+    private releaseSession;
+    private trackOutboundCommand;
+    private observeCapabilities;
+    private updateCommandLifecycleCapability;
+    private observeCommandLifecycle;
+    private maybeCloseAfterResult;
+    private closeAfterResult;
+    private cleanup;
+}

package/dist/daemon/protocol.d.ts

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const DAEMON_PROTOCOL_VERSION: 2;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export interface DaemonControlRequestFrame<Method extends string = string, Params extends JsonObject = JsonObject> {
+    type: "control_request";
+    request_id: string;
+    session_id?: string;
+    request: {
+        type: `daemon.${Method}`;
+    } & Params;
+}
+export interface DaemonSuccessResponseFrame<Result extends JsonObject = JsonObject> {
+    type: "control_response";
+    session_id?: string;
+    response: {
+        subtype: "success";
+        request_id: string;
+        response?: Result;
+    };
+}
+export interface DaemonErrorResponseFrame {
+    type: "control_response";
+    session_id?: string;
+    response: {
+        subtype: "error";
+        request_id: string;
+        error: string;
+        code?: string;
+        retryable?: boolean;
+        details?: JsonObject;
+    };
+}
+export type DaemonControlResponseFrame = DaemonSuccessResponseFrame | DaemonErrorResponseFrame;
+export interface DaemonEventFrame {
+    type: "event";
+    event: string;
+    session_id?: string;
+    data: JsonObject;
+}
+export interface KeepAliveFrame {
+    type: "keep_alive";
+}
+/** A raw Query message carrying a daemon-local Session route. */
+export type DaemonWireSessionMessage = JsonObject & {
+    type: string;
+    session_id?: string;
+};
+export type DaemonProtocolFrame = DaemonControlRequestFrame | DaemonControlResponseFrame | DaemonEventFrame | KeepAliveFrame | DaemonWireSessionMessage;
+export type InitializeDaemonParams = {
+    daemon_protocol_version: typeof DAEMON_PROTOCOL_VERSION;
+    sdk_version: string;
+    capabilities: string[];
+};
+export type InitializeDaemonResult = {
+    daemon_protocol_version: typeof DAEMON_PROTOCOL_VERSION;
+    daemon_version: string;
+    capabilities: string[];
+};
+export type OpenSessionParams = {
+    worker_args: string[];
+    cwd?: string;
+    config_dir?: string;
+    extra?: JsonObject;
+};
+export type OpenSessionResult = {
+    session_id: string;
+};
+export type SubscribeSessionParams = {
+    remote_session_id: string;
+};
+export type SubscribeSessionResult = {
+    session_id: string;
+    initialization_result: JsonObject;
+};
+export type UnsubscribeSessionParams = Record<string, never>;
+export type SessionRuntimeState = "pending" | "ready" | "inactive" | "failed";
+export type DaemonSessionInfo = {
+    local_session_id: string;
+    remote_session_id?: string;
+    environment_id?: string;
+    title: string;
+    cwd?: string;
+    extra?: JsonObject;
+    state: SessionRuntimeState;
+    created_at: string;
+    updated_at: string;
+};
+export type ListSessionsParams = Record<string, never>;
+export type ListSessionsResult = {
+    sessions: DaemonSessionInfo[];
+};
+export type RenameSessionParams = {
+    title: string;
+};
+export type RenameSessionResult = {
+    session: DaemonSessionInfo;
+};
+export type EnableRemoteControlParams = {
+    external_id: string;
+    environment_type: string;
+    name?: string;
+    metadata?: JsonObject;
+};
+export type EnableRemoteControlResult = {
+    environment_id: string;
+};
+export type DisableRemoteControlParams = Record<string, never>;
+export type SyncSessionRegistrationsParams = {
+    local_session_ids: string[];
+};
+export type UpdateSessionMetadataParams = {
+    extra: JsonObject;
+};
+export type UpdateSessionMetadataResult = {
+    session: DaemonSessionInfo;
+};
+export type CloseSessionParams = Record<string, never>;
+export type DeleteSessionParams = {
+    local_session_id: string;
+};
+export type ShutdownParams = Record<string, never>;
+export type DaemonCommandMethod = "initialize" | "open_session" | "list_sessions" | "rename_session" | "subscribe_session" | "unsubscribe_session" | "enable_remote_control" | "sync_session_registrations" | "update_session_metadata" | "disable_remote_control" | "close_session" | "delete_session" | "shutdown";
+export interface DaemonCommandParamsMap {
+    initialize: InitializeDaemonParams;
+    open_session: OpenSessionParams;
+    list_sessions: ListSessionsParams;
+    rename_session: RenameSessionParams;
+    subscribe_session: SubscribeSessionParams;
+    unsubscribe_session: UnsubscribeSessionParams;
+    enable_remote_control: EnableRemoteControlParams;
+    sync_session_registrations: SyncSessionRegistrationsParams;
+    update_session_metadata: UpdateSessionMetadataParams;
+    disable_remote_control: DisableRemoteControlParams;
+    close_session: CloseSessionParams;
+    delete_session: DeleteSessionParams;
+    shutdown: ShutdownParams;
+}
+export type DaemonCommandRequest = DaemonControlRequestFrame<"initialize", InitializeDaemonParams> | DaemonControlRequestFrame<"open_session", OpenSessionParams> | DaemonControlRequestFrame<"list_sessions", ListSessionsParams> | DaemonControlRequestFrame<"rename_session", RenameSessionParams> | DaemonControlRequestFrame<"subscribe_session", SubscribeSessionParams> | DaemonControlRequestFrame<"unsubscribe_session", UnsubscribeSessionParams> | DaemonControlRequestFrame<"enable_remote_control", EnableRemoteControlParams> | DaemonControlRequestFrame<"sync_session_registrations", SyncSessionRegistrationsParams> | DaemonControlRequestFrame<"update_session_metadata", UpdateSessionMetadataParams> | DaemonControlRequestFrame<"disable_remote_control", DisableRemoteControlParams> | DaemonControlRequestFrame<"close_session", CloseSessionParams> | DaemonControlRequestFrame<"delete_session", DeleteSessionParams> | DaemonControlRequestFrame<"shutdown", ShutdownParams>;
+export interface DaemonCommandResultMap {
+    initialize: InitializeDaemonResult;
+    open_session: OpenSessionResult;
+    list_sessions: ListSessionsResult;
+    rename_session: RenameSessionResult;
+    subscribe_session: SubscribeSessionResult;
+    unsubscribe_session: null;
+    enable_remote_control: EnableRemoteControlResult;
+    sync_session_registrations: null;
+    update_session_metadata: UpdateSessionMetadataResult;
+    disable_remote_control: null;
+    close_session: null;
+    delete_session: null;
+    shutdown: null;
+}
+export declare class DaemonProtocolError extends Error {
+    readonly code: "DAEMON_PROTOCOL_ERROR";
+    constructor(message: string);
+}
+export declare function parseDaemonProtocolLine(line: string): DaemonProtocolFrame;
+export declare function serializeDaemonProtocolFrame(frame: DaemonProtocolFrame): string;
+export declare function parseDaemonCommandRequest(frame: DaemonProtocolFrame): DaemonCommandRequest;
+export declare function parseDaemonCommandResult<Method extends DaemonCommandMethod>(method: Method, frame: DaemonSuccessResponseFrame): DaemonCommandResultMap[Method];

package/dist/daemon/remote-session-launch-rpc.d.ts

@@ -0,0 +1,3 @@
+import { type DaemonRequestHandler } from './daemon-connection.js';
+import { type ResolveRemoteSessionLaunch } from './session-metadata.js';
+export declare function createRemoteSessionLaunchRequestHandler(resolveLaunch: ResolveRemoteSessionLaunch, callbackTimeoutMs?: number): DaemonRequestHandler;

package/dist/daemon/session-metadata.d.ts

@@ -0,0 +1,19 @@
+export type SessionExtraValue = string | number | boolean | null | readonly SessionExtraValue[] | {
+    readonly [key: string]: SessionExtraValue;
+};
+/** Opaque, JSON-safe metadata owned by the Host application. */
+export type SessionExtra = Readonly<Record<string, SessionExtraValue>>;
+/** Replaces the complete metadata snapshot for one Session. */
+export interface SessionMetadataUpdate {
+    extra: SessionExtra;
+}
+export interface RemoteSessionLaunchRequest {
+    remoteSessionId: string;
+    extra?: SessionExtra;
+}
+export interface RemoteSessionLaunch {
+    cwd: string;
+    additionalDirectories?: readonly string[];
+}
+export type ResolveRemoteSessionLaunch = (request: RemoteSessionLaunchRequest) => Promise<RemoteSessionLaunch>;
+export declare function normalizeSessionExtra(value: SessionExtra, path?: string): SessionExtra;

package/dist/daemon/session-registration-store.d.ts

@@ -0,0 +1,10 @@
+import type { DaemonSessionStore } from "./session-store-rpc.js";
+export interface SessionRegistrationStore {
+    readonly store: DaemonSessionStore;
+    flush(): Promise<void>;
+    dispose(): void;
+}
+export declare function createSessionRegistrationStore(store: DaemonSessionStore, options: {
+    sync: (localSessionIds: string[]) => Promise<void>;
+    retryDelaysMs?: readonly number[];
+}): SessionRegistrationStore;

package/dist/daemon/session-store-rpc.d.ts

@@ -0,0 +1,37 @@
+import type { SessionKey, SessionStore } from "../session/session-store.js";
+import { DaemonRequestError, type DaemonRequestHandler } from "./daemon-connection.js";
+import { type SessionExtra, type SessionMetadataUpdate } from "./session-metadata.js";
+export interface DaemonSessionStore extends SessionStore {
+    listAllSessions(): Promise<readonly DaemonSessionSummary[]>;
+    /**
+     * Persists a complete replacement of one Session's metadata. Implementations
+     * must use upsert semantics: the daemon may call this before the first
+     * transcript entry exists, and listAllSessions() must later return the same
+     * extra snapshot.
+     */
+    updateSessionMetadata?(key: Omit<SessionKey, "subpath">, update: SessionMetadataUpdate): Promise<void>;
+}
+export interface DaemonSessionSummary {
+    key: SessionKey;
+    title: string;
+    lastActiveAt: string;
+    cwd: string;
+    extra?: SessionExtra;
+}
+export interface DaemonSessionStoreRpcOptions {
+    callbackTimeoutMs?: number;
+    maxEntriesPerPage?: number;
+    maxPayloadBytes?: number;
+}
+export type DaemonSessionStoreRequestHandler = DaemonRequestHandler & {
+    dispose(): Promise<void>;
+};
+export declare class DaemonSessionStoreRpcError extends DaemonRequestError {
+    constructor(options: {
+        code: string;
+        message: string;
+        retryable?: boolean;
+        operation?: string;
+    });
+}
+export declare function createDaemonSessionStoreRequestHandler(store: DaemonSessionStore, options?: DaemonSessionStoreRpcOptions): DaemonSessionStoreRequestHandler;

package/dist/daemon/start-daemon.d.ts

@@ -0,0 +1,95 @@
+import type { InternalAuthOptions } from '../types/auth.js';
+import type { Query, OnElicitation } from '../types/options.js';
+import type { CanUseTool } from '../types/permissions.js';
+import type { ProcessTransportOptions } from '../core/process-transport.js';
+import type { QueryTransportProvider } from '../core/transport.js';
+import { type DaemonSessionStore } from './session-store-rpc.js';
+import { type ResolveRemoteSessionLaunch, type SessionExtra, type SessionMetadataUpdate } from './session-metadata.js';
+export type DaemonState = 'ready' | 'stopping' | 'stopped' | 'failed';
+export type RemoteControlState = 'ready' | 'stopping' | 'stopped' | 'failed';
+export interface EnableRemoteControlOptions {
+    externalId: string;
+    /**
+     * Remote Manager-registered push-family Environment type for this Host.
+     * The value is an Environment identity component and must remain stable.
+     */
+    environmentType: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RemoteControl {
+    readonly environmentId: string;
+    readonly state: RemoteControlState;
+    disable(): Promise<void>;
+}
+export interface AttachSessionOptions {
+    canUseTool?: CanUseTool;
+    onElicitation?: OnElicitation;
+}
+export type SessionRuntimeState = 'pending' | 'ready' | 'inactive' | 'failed';
+export interface DaemonSessionInfo {
+    localSessionId: string;
+    remoteSessionId?: string;
+    environmentId?: string;
+    title: string;
+    cwd?: string;
+    extra?: SessionExtra;
+    state: SessionRuntimeState;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface StartDaemonOptions {
+    auth: InternalAuthOptions;
+    capacity: number;
+    /** Idle Worker timeout in milliseconds. Set to 0 to disable reclamation. */
+    workerIdleTimeoutMs?: number;
+    cwd?: string;
+    pathToQoderCLIExecutable?: string;
+    proxy?: string;
+    env?: Record<string, string | undefined>;
+    sessionStore?: DaemonSessionStore;
+    /** Resolves a remotely-created Session to trusted local launch paths. */
+    resolveRemoteSessionLaunch?: ResolveRemoteSessionLaunch;
+}
+export type DaemonEvent = {
+    type: 'daemonStateChanged';
+    previousState: DaemonState;
+    state: DaemonState;
+    error?: Error;
+} | {
+    type: 'remoteControlStateChanged';
+    environmentId?: string;
+    previousState: RemoteControlState;
+    state: RemoteControlState;
+    error?: Error;
+} | {
+    type: 'sessionDiscovered';
+    session: DaemonSessionInfo;
+} | {
+    type: 'sessionUpdated';
+    session: DaemonSessionInfo;
+    previousState?: SessionRuntimeState;
+} | {
+    type: 'sessionDeleted';
+    localSessionId: string;
+};
+export type DaemonEventCallback = (event: DaemonEvent) => void;
+export interface Daemon {
+    readonly state: DaemonState;
+    listSessions(): Promise<DaemonSessionInfo[]>;
+    onEvent(callback: DaemonEventCallback): () => void;
+    renameSession(localSessionId: string, title: string): Promise<DaemonSessionInfo>;
+    updateSessionMetadata(localSessionId: string, update: SessionMetadataUpdate): Promise<DaemonSessionInfo>;
+    deleteSession(localSessionId: string): Promise<void>;
+    enableRemoteControl(options: EnableRemoteControlOptions): Promise<RemoteControl>;
+    attachSession(remoteSessionId: string, options?: AttachSessionOptions): Promise<Query>;
+    stop(): Promise<void>;
+}
+interface InternalDaemonRuntime {
+    readonly auth: InternalAuthOptions;
+    readonly transportProvider: QueryTransportProvider<ProcessTransportOptions>;
+    readonly sessionStore?: DaemonSessionStore;
+}
+export declare function getDaemonRuntime(daemon: Daemon): InternalDaemonRuntime | undefined;
+export declare function startDaemon(options: StartDaemonOptions): Promise<Daemon>;
+export {};

package/dist/index.d.ts

@@ -55,6 +55,10 @@ export { query } from './query/query.js';
 export { startup } from './query/startup.js';
 export type { StartupParams, WarmQuery } from './query/startup.js';
 export { resolveSettings } from './settings/resolve-settings.js';
+export { startDaemon } from './daemon/start-daemon.js';
+export type { Daemon, DaemonEvent, DaemonEventCallback, DaemonState, AttachSessionOptions, DaemonSessionInfo, SessionRuntimeState, EnableRemoteControlOptions, RemoteControl, RemoteControlState, StartDaemonOptions, } from './daemon/start-daemon.js';
+export type { RemoteSessionLaunch, RemoteSessionLaunchRequest, ResolveRemoteSessionLaunch, SessionExtra, SessionExtraValue, SessionMetadataUpdate, } from './daemon/session-metadata.js';
+export type { DaemonSessionStore, DaemonSessionSummary, } from './daemon/session-store-rpc.js';
 export { DEFAULT_RUNTIME_TRANSPORT, } from './core/default-runtime.js';
 export { ProcessTransport, QoderCliProcessError, } from './core/process-transport.js';
 export { hasResolvableQoderWorkerRuntime, QoderWorkerRuntimeError, WorkerTransport, resolveQoderWorkerRuntimePath, } from './core/worker-transport.js';
@@ -86,7 +90,7 @@ export type { AccessTokenInput, AuthOptions, FetchServiceAccountToken, ServiceAc
  */
 export type { FetchJobToken, JobTokenAuthOptions, JobTokenRequest, JobTokenResult, } from './types/auth.js';
 export type { AccountInfo, UsageAddOnQuotaBucket, UsageInfo, UsageOrgResourcePackage, UsageQuotaBucket, SessionCreditsUsage, ApiKeySource, ExitReason, FastModeState, ConfigScope, SettingSource, SDKAssistantMessageError, SDKStatus, EffortLevel, ThinkingAdaptive, ThinkingEnabled, ThinkingDisabled, ThinkingConfig, ModelInfo, ModelSource, ServerModelJson, ServerModelJsonValue, ModelStrategy, ModelPromotion, LocalizedModelText, ModelContextConfig, ModelContextWindowEntry, ModelEffortEntry, ModelThinkingConfig, ModelThinkingDisabled, ModelThinkingEnabled, ModelUsage, NonNullableUsage, SlashCommand, ToolConfig, SdkPluginConfig, } from './types/common.js';
-export type { SDKMessage, SDKAssistantMessage, SDKToolNonExecutionKind, SDKToolResultMeta, SDKUserMessage, SDKUserMessageReplay, SDKResultMessage, SDKResultSuccess, SDKResultError, SDKSystemMessage, SDKSystemInitMessage, SDKSystemMessageSubtype, SDKSystemMessageBySubtype, SDKPartialAssistantMessage, SDKCompactBoundaryMessage, SDKStatusMessage, SDKAPIRetryMessage, SDKModelQueueStatusMessage, SDKControlRequestProgressMessage, SDKHookStartedMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKPermissionDeniedMessage, SDKMirrorErrorMessage, SDKTaskNotificationMessage, SDKTaskStartedMessage, SDKTaskProgressMessage, SDKTaskUpdatedMessage, SDKBackgroundTasksChangedMessage, SDKSessionStateChangedMessage, SDKPlanModeChangedMessage, SDKSessionTitleChangedMessage, SDKFilesPersistedEvent, SDKElicitationCompleteMessage, SDKPromptSuggestionMessage, SDKCloudAgentEventMessage, SDKMemoryGenerationMessage, SDKMemoryConsumptionMessage, SDKSkillEvolutionMessage, SDKPermissionDenial, } from './types/messages.js';
+export type { SDKMessage, SDKAssistantMessage, SDKToolNonExecutionKind, SDKToolResultMeta, SDKArtifactInfo, SDKArtifactUpdateMessage, SDKAvailableModelsUpdateMessage, SDKUserMessage, SDKUserMessageReplay, SDKResultMessage, SDKResultSuccess, SDKResultError, SDKSystemMessage, SDKSystemInitMessage, SDKSystemMessageSubtype, SDKSystemMessageBySubtype, SDKPartialAssistantMessage, SDKCompactBoundaryMessage, SDKStatusMessage, SDKAPIRetryMessage, SDKModelQueueStatusMessage, SDKControlRequestProgressMessage, SDKCommandLifecycleMessage, SDKHookStartedMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKPermissionDeniedMessage, SDKMirrorErrorMessage, SDKTaskNotificationMessage, SDKTaskStartedMessage, SDKTaskProgressMessage, SDKTaskUpdatedMessage, SDKBackgroundTasksChangedMessage, SDKSessionStateChangedMessage, SDKPlanModeChangedMessage, SDKSessionTitleChangedMessage, SDKFilesPersistedEvent, SDKElicitationCompleteMessage, SDKPromptSuggestionMessage, SDKCloudAgentEventMessage, SDKMemoryGenerationMessage, SDKMemoryConsumptionMessage, SDKSkillEvolutionMessage, SDKPermissionDenial, } from './types/messages.js';
 export type { DefaultRuntimeTransport, } from './core/default-runtime.js';
 export type { QueryTransportCreateOptions, QueryTransportProviderOption, } from './core/query-transport.js';
 export type { ProcessTransportOptions } from './core/process-transport.js';