@camerontaylor/paseo-client 0.8.0-fork.1 → 0.8.0-fork.3

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+import type { OwnedSubscription } from "./connection/index.js";
+export type { OwnedSubscription, SubscriptionObserver } from "./connection/index.js";
 import type { DaemonClientConfig } from "./daemon-client.js";
 import type { AgentPermissionResponse } from "@camerontaylor/paseo-protocol/agent-types";
-import type { AgentSnapshotPayload, CreationSnapshot, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListCommandsResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ProjectListRequestMessage, ProjectListResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, ProjectPlacementPayload, WorkspaceProjectDescriptorPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@camerontaylor/paseo-protocol/messages";
+import type { AgentSnapshotPayload, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListCommandsResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ProjectListRequestMessage, ProjectListResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, ProjectPlacementPayload, WorkspaceProjectDescriptorPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@camerontaylor/paseo-protocol/messages";
 import { DaemonClient } from "./daemon-client.js";
 import { type PaseoTerminalActions, type PaseoWorkspaceTerminalActions } from "./terminals/index.js";
 export type { PaseoTerminal, PaseoTerminalActions, PaseoTerminalHandle, PaseoTerminalCreateOptions, PaseoTerminalListOptions, PaseoTerminalListResult, PaseoTerminalCaptureOptions, PaseoTerminalCaptureResult, PaseoWorkspaceTerminalActions, } from "./terminals/index.js";
@@ -61,6 +63,7 @@ export type PaseoProjectUpdate = Extract<SessionOutboundMessage, {
 }>["payload"];
 export type PaseoProjectUpdateHandler = (update: PaseoProjectUpdate) => void;
 export interface PaseoAgentListResult {
+    subscription?: OwnedSubscription<PaseoAgentListResult>;
     requestId: string;
     subscriptionId?: string | null;
     entries: FetchAgentsEntry[];
@@ -70,6 +73,7 @@ export type PaseoWorkspaceListOptions = Omit<FetchWorkspacesRequestMessage, "typ
     requestId?: string;
 };
 export interface PaseoWorkspaceListResult {
+    subscription?: OwnedSubscription<PaseoWorkspaceListResult>;
     requestId: string;
     subscriptionId?: string | null;
     entries: PaseoWorkspace[];
@@ -79,10 +83,8 @@ export interface PaseoWorkspaceOpenOptions {
     cwd: string;
     requestId?: string;
 }
-export type PaseoWorkspaceCreateOptions = Omit<WorkspaceCreateRequest, "type" | "requestId" | "agent" | "subscribe"> & {
+export type PaseoWorkspaceCreateOptions = Omit<WorkspaceCreateRequest, "type" | "requestId"> & {
     requestId?: string;
-    agent?: Omit<PaseoAgentCreateOptions, "worktree" | "git" | "onEvent" | "idempotencyKey" | "requestId">;
-    onEvent?: (snapshot: CreationSnapshot) => void;
 };
 export interface PaseoWorkspaceArchiveResult {
     requestId: string;
@@ -125,6 +127,12 @@ export interface PaseoProjectActions {
     subscribe(handler: PaseoProjectUpdateHandler): () => void;
 }
 export interface PaseoWorkspaceActions {
+    list(options: PaseoWorkspaceListOptions & {
+        subscribe: {};
+    }): Promise<PaseoWorkspaceListResult & {
+        subscriptionId: string;
+        subscription: OwnedSubscription<PaseoWorkspaceListResult>;
+    }>;
     list(options?: PaseoWorkspaceListOptions): Promise<PaseoWorkspaceListResult>;
     ref(workspace: string | PaseoWorkspace): PaseoWorkspaceHandle;
     open(input: string | PaseoWorkspaceOpenOptions, requestId?: string): Promise<PaseoWorkspaceHandle>;
@@ -152,9 +160,6 @@ export interface PaseoAgentConfig {
     mcpServers?: PaseoAgentSessionConfig["mcpServers"];
 }
 export interface PaseoAgentCreateOptions {
-    idempotencyKey?: string;
-    agentId?: string;
-    onEvent?: (snapshot: CreationSnapshot) => void;
     config: PaseoAgentConfig;
     cwd: string;
     parent?: string | PaseoAgentHandle;
@@ -217,6 +222,18 @@ export type PaseoAgentTimelineEvent = PaseoAgentStream | {
         type: "replacement";
         epoch: string;
     };
+} | {
+    agentId: string;
+    subscriptionId: string;
+    event: {
+        type: "subscription_restored";
+    };
+} | {
+    agentId: string;
+    event: {
+        type: "error";
+        error: string;
+    };
 };
 export type PaseoAgentTimelineSubscription = ReturnType<DaemonClient["subscribeAgentTimeline"]>;
 export interface PaseoAgentTimelineHandle {
@@ -231,8 +248,10 @@ export interface PaseoAgentTimelineHandle {
      */
     refetch(options?: PaseoAgentTimelineRefetchOptions): Promise<FetchAgentTimelinePayload>;
     /**
-     * Subscribe to this agent and restore demand after reconnect. A replacement
-     * event invalidates previously fetched history; refetch the page you need.
+     * Delivers live events only. After reconnect, subscription_restored precedes
+     * subsequent updates. History may have been missed; use refetch() to request
+     * the range you need. No history is fetched automatically. A replacement event
+     * invalidates the previous epoch. Subscription errors release this observation.
      * Await the returned unsubscribe function's `ready` promise before starting
      * work that must be observed. It rejects if establishment fails.
      */
@@ -283,6 +302,12 @@ export interface PaseoAgentHandle {
     subscribe(handler: (update: PaseoAgentUpdate) => void): () => void;
 }
 export interface PaseoAgentActions {
+    list(options: PaseoAgentListOptions & {
+        subscribe: {};
+    }): Promise<PaseoAgentListResult & {
+        subscriptionId: string;
+        subscription: OwnedSubscription<PaseoAgentListResult>;
+    }>;
     list(options?: PaseoAgentListOptions): Promise<PaseoAgentListResult>;
     ref(agent: string | PaseoAgent): PaseoAgentHandle;
     create(options: PaseoAgentCreateOptions): Promise<PaseoAgentHandle>;
@@ -365,6 +390,8 @@ export interface PaseoConfigActions {
     }>;
 }
 export interface PaseoApi {
+    dispose(): Promise<void>;
+    observeEvents: DaemonClient["observeEvents"];
     readonly terminals: PaseoTerminalActions;
     readonly workspaces: PaseoWorkspaceActions;
     readonly projects: PaseoProjectActions;
@@ -379,5 +406,7 @@ export interface PaseoClient extends PaseoApi {
     getConnectionState(): ConnectionState;
 }
 export declare function createPaseoClient(config: PaseoClientConfig): PaseoClient;
-export declare function createPaseoApi(daemonClient: DaemonClient): PaseoApi;
+export declare function createPaseoApi(daemonClient: DaemonClient, scopeOptions?: {
+    signal?: AbortSignal;
+}): PaseoApi;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -11,37 +11,75 @@ export function createPaseoClient(config) {
         clientId: config.clientId ?? createGeneratedClientId(),
         clientType: "cli",
     });
+    const api = createPaseoApi(daemonClient);
     return {
-        ...createPaseoApi(daemonClient),
+        ...api,
         connect: () => daemonClient.connect(),
-        close: () => daemonClient.close(),
+        close: async () => {
+            try {
+                await api.dispose();
+            }
+            finally {
+                await daemonClient.close();
+            }
+        },
         ensureConnected: () => daemonClient.ensureConnected(),
         getConnectionState: () => daemonClient.getConnectionState(),
     };
 }
-function toDaemonAgentCreateOptions(options, placement) {
-    const { config: agentConfig, cwd, parent, title, prompt, ...requestOptions } = options;
-    const { provider: providerModel, options: providerOptions, ...runtimeConfig } = agentConfig;
-    const { provider, model } = parseProviderModel(providerModel);
-    return {
-        ...requestOptions,
-        config: {
-            ...runtimeConfig,
-            provider,
-            model,
-            cwd: placement?.cwd ?? cwd,
-            ...(title !== undefined ? { title } : {}),
-            ...(providerOptions !== undefined ? { providerOptions } : {}),
-        },
-        ...(placement ? { workspaceId: placement.workspaceId } : {}),
-        ...(parent ? { callerAgentId: resolveAgentId(parent) } : {}),
-        ...(prompt !== undefined ? { initialPrompt: prompt } : {}),
+export function createPaseoApi(daemonClient, scopeOptions) {
+    const handles = new Set();
+    const agentListeners = new Set();
+    const workspaceListeners = new Set();
+    const lifetime = new AbortController();
+    const own = (create) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        const handle = create();
+        handles.add(handle);
+        const release = handle.release.bind(handle);
+        handle.release = async () => {
+            await release();
+            handles.delete(handle);
+        };
+        return handle;
     };
-}
-export function createPaseoApi(daemonClient) {
-    const createAgentHandle = createAgentHandleFactory(daemonClient);
+    const listenAgents = (handler) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        agentListeners.add(handler);
+        return () => {
+            agentListeners.delete(handler);
+        };
+    };
+    const listenWorkspaces = (handler) => {
+        if (lifetime.signal.aborted)
+            throw new Error("Paseo API is disposed");
+        workspaceListeners.add(handler);
+        return () => {
+            workspaceListeners.delete(handler);
+        };
+    };
+    const createAgentHandle = createAgentHandleFactory(daemonClient, listenAgents, (agentId, handler) => own(() => daemonClient.subscribeAgentTimeline(agentId, handler)));
     const createAgent = async (options, placement) => {
-        const agent = await daemonClient.createAgent(toDaemonAgentCreateOptions(options, placement));
+        const { config: agentConfig, cwd, parent, title, prompt, ...requestOptions } = options;
+        const { provider: providerModel, options: providerOptions, ...runtimeConfig } = agentConfig;
+        const { provider, model } = parseProviderModel(providerModel);
+        const effectiveCwd = placement?.cwd ?? cwd;
+        const agent = await daemonClient.createAgent({
+            ...requestOptions,
+            config: {
+                ...runtimeConfig,
+                provider,
+                model,
+                cwd: effectiveCwd,
+                ...(title !== undefined ? { title } : {}),
+                ...(providerOptions !== undefined ? { providerOptions } : {}),
+            },
+            ...(placement ? { workspaceId: placement.workspaceId } : {}),
+            ...(parent ? { callerAgentId: resolveAgentId(parent) } : {}),
+            ...(prompt !== undefined ? { initialPrompt: prompt } : {}),
+        });
         return createAgentHandle(agent);
     };
     const terminals = createTerminalActions(daemonClient, async (workspaceId) => {
@@ -51,38 +89,105 @@ export function createPaseoApi(daemonClient) {
         }
         return workspace.workspaceDirectory;
     });
-    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient, createAgent, terminals);
+    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient, createAgent, terminals, listenWorkspaces);
+    let disposal = null;
+    const dispose = () => {
+        if (disposal)
+            return disposal;
+        lifetime.abort();
+        scopeOptions?.signal?.removeEventListener("abort", abort);
+        agentListeners.clear();
+        workspaceListeners.clear();
+        disposal = Promise.allSettled([...handles].map((handle) => handle.release())).then((results) => {
+            handles.clear();
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length)
+                throw new AggregateError(failures, "Failed to release API subscriptions");
+            return undefined;
+        });
+        return disposal;
+    };
+    const abort = () => {
+        void dispose().catch((error) => console.error("API subscription cleanup failed", error));
+    };
+    if (scopeOptions?.signal?.aborted)
+        abort();
+    else
+        scopeOptions?.signal?.addEventListener("abort", abort, { once: true });
+    const observeEvents = (events, options) => own(() => daemonClient.observeEvents(events, options));
+    const subscribeEvent = (event, update) => {
+        const observation = observeEvents([event]);
+        observation.subscribe({ snapshot: () => { }, update });
+        return () => {
+            void observation
+                .release()
+                .catch((error) => console.error("Event subscription cleanup failed", error));
+        };
+    };
+    async function listWorkspaces(options) {
+        if (!options?.subscribe)
+            return daemonClient.fetchWorkspaces(options);
+        if (options.subscribe.subscriptionId !== undefined)
+            throw new Error("Subscription IDs are assigned by the host");
+        const subscription = own(() => daemonClient.observeWorkspaces(options));
+        subscription.subscribe({
+            snapshot: () => { },
+            update: (message) => {
+                if (message.type === "workspace_update")
+                    for (const listener of workspaceListeners)
+                        listener(message.payload);
+            },
+        });
+        return { ...(await subscription.ready), subscription };
+    }
+    async function listAgents(options) {
+        if (!options?.subscribe)
+            return daemonClient.fetchAgents(options);
+        if (options.subscribe.subscriptionId !== undefined)
+            throw new Error("Subscription IDs are assigned by the host");
+        const subscription = own(() => daemonClient.observeAgents(options));
+        subscription.subscribe({
+            snapshot: () => { },
+            update: (message) => {
+                if (message.type === "agent_update")
+                    for (const listener of agentListeners)
+                        listener(message.payload);
+            },
+        });
+        return { ...(await subscription.ready), subscription };
+    }
     return {
+        dispose,
+        observeEvents,
         terminals,
         projects: {
             list: (options) => daemonClient.listProjects(options),
-            subscribe: (handler) => daemonClient.on("project.update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: (handler) => {
+                return subscribeEvent("project.update", (message) => {
+                    if (message.type === "project.update")
+                        handler(message.payload);
+                });
+            },
         },
         workspaces: {
-            list: (options) => daemonClient.fetchWorkspaces(options),
+            list: listWorkspaces,
             ref: (workspace) => createWorkspaceHandle(workspace),
             open: (input, requestId) => openWorkspace(daemonClient, createWorkspaceHandle, input, requestId),
-            create: async ({ requestId, agent, ...options }) => {
-                const result = await daemonClient.createWorkspace({ ...options, ...(agent ? { agent: toDaemonAgentCreateOptions(agent) } : {}) }, requestId);
+            create: async ({ requestId, ...options }) => {
+                const result = await daemonClient.createWorkspace(options, requestId);
                 if (result.error || !result.workspace) {
                     throw new Error(result.error ?? "The daemon did not create a workspace");
                 }
                 return createWorkspaceHandle(result.workspace);
             },
             archive: (workspace, requestId) => daemonClient.archiveWorkspace(resolveWorkspaceId(workspace), requestId),
-            subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: listenWorkspaces,
         },
         agents: {
-            list: (options) => daemonClient.fetchAgents(options),
+            list: listAgents,
             ref: (agent) => createAgentHandle(agent),
             create: (options) => createAgent(options),
-            subscribe: (handler) => daemonClient.on("agent_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: listenAgents,
         },
         providers: {
             listModels: (provider, options) => daemonClient.listProviderModels(provider, options),
@@ -93,13 +198,16 @@ export function createPaseoApi(daemonClient) {
             },
             listAvailable: (options) => daemonClient.listAvailableProviders(options),
             snapshot: (options) => daemonClient.getProvidersSnapshot(options),
-            waitForReady: (options) => waitForProvidersReady(daemonClient, options),
+            waitForReady: (options) => waitForProvidersReady(daemonClient, observeEvents(["providers_snapshot_update"]), lifetime.signal, options),
             refresh: (options) => daemonClient.refreshProvidersSnapshot(options),
             diagnostic: (provider, options) => daemonClient.getProviderDiagnostic(provider, options),
             listUsage: (options) => listProviderUsage(daemonClient, options),
-            subscribe: (handler) => daemonClient.on("providers_snapshot_update", (message) => {
-                handler(message.payload);
-            }),
+            subscribe: (handler) => {
+                return subscribeEvent("providers_snapshot_update", (message) => {
+                    if (message.type === "providers_snapshot_update")
+                        handler(message.payload);
+                });
+            },
         },
         config: {
             get: (requestId) => daemonClient.getDaemonConfig(requestId),
@@ -107,7 +215,7 @@ export function createPaseoApi(daemonClient) {
         },
     };
 }
-function createWorkspaceHandleFactory(daemonClient, createAgent, terminals) {
+function createWorkspaceHandleFactory(daemonClient, createAgent, terminals, listen) {
     return (workspace) => {
         const id = typeof workspace === "string" ? workspace : workspace.id;
         let current = typeof workspace === "string" ? null : workspace;
@@ -167,21 +275,19 @@ function createWorkspaceHandleFactory(daemonClient, createAgent, terminals) {
                 }
                 return result;
             },
-            subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
-                const update = message.payload;
+            subscribe: (handler) => listen((update) => {
                 if (update.kind === "upsert" && update.workspace.id === id) {
                     current = update.workspace;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.id === id) {
-                    current = null;
                     handler(update);
                 }
             }),
         };
     };
 }
-function createAgentHandleFactory(daemonClient) {
+function createAgentHandleFactory(daemonClient, listen, subscribeTimeline) {
     return (agent) => {
         const id = typeof agent === "string" ? agent : agent.id;
         let current = typeof agent === "string" ? null : agent;
@@ -196,13 +302,27 @@ function createAgentHandleFactory(daemonClient) {
                     }
                     return result;
                 },
-                subscribe: (handler) => daemonClient.subscribeAgentTimeline(id, (message) => {
-                    handler(message.type === "agent_stream"
-                        ? message.payload
-                        : {
-                            agentId: message.payload.agentId,
-                            event: { type: "replacement", epoch: message.payload.epoch },
-                        });
+                subscribe: (handler) => subscribeTimeline(id, (message) => {
+                    switch (message.type) {
+                        case "agent_stream":
+                            return handler(message.payload);
+                        case "agent.timeline.subscription_restored":
+                            return handler({
+                                agentId: id,
+                                subscriptionId: message.payload.subscriptionId,
+                                event: { type: "subscription_restored" },
+                            });
+                        case "agent.timeline.error":
+                            return handler({
+                                agentId: id,
+                                event: { type: "error", error: message.payload.error },
+                            });
+                        case "agent.timeline.replacement":
+                            return handler({
+                                agentId: id,
+                                event: { type: "replacement", epoch: message.payload.epoch },
+                            });
+                    }
                 }),
             },
             get workspaceId() {
@@ -280,14 +400,12 @@ function createAgentHandleFactory(daemonClient) {
             detach: async () => {
                 await daemonClient.detachAgent(id);
             },
-            subscribe: (handler) => daemonClient.on("agent_update", (message) => {
-                const update = message.payload;
+            subscribe: (handler) => listen((update) => {
                 if (update.kind === "upsert" && update.agent.id === id) {
                     current = update.agent;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.agentId === id) {
-                    current = null;
                     handler(update);
                 }
             }),
@@ -326,77 +444,88 @@ function listProviderUsage(daemonClient, options) {
     }
     return daemonClient.listProviderUsage(options);
 }
-function waitForProvidersReady(daemonClient, options = {}) {
-    // COMPAT(providersSnapshotCwd): added in v0.3.2, remove gate after 2027-02-10.
-    if (daemonClient.getLastServerInfoMessage()?.features?.providersSnapshotCwd !== true) {
-        return Promise.reject(new Error("Update the host to wait for provider discovery."));
-    }
+async function waitForProvidersReady(daemonClient, observation, signal, options = {}) {
     const { timeoutMs = 60000, ...snapshotOptions } = options;
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let requestId = null;
-        let snapshotCwd;
-        const pendingUpdates = new Map();
-        let latestEntries = [];
-        const cleanup = () => {
-            clearTimeout(timeout);
-            unsubscribe();
-        };
-        const finish = (snapshot) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(snapshot);
-        };
-        const fail = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error instanceof Error ? error : new Error(String(error)));
-        };
-        const updateMatches = (update) => update.cwd === snapshotCwd;
-        const unsubscribe = daemonClient.on("providers_snapshot_update", (message) => {
-            const update = message.payload;
-            if (!requestId) {
-                pendingUpdates.set(update.cwd, update);
-                return;
-            }
-            if (!updateMatches(update))
-                return;
-            latestEntries = update.entries;
-            if (update.entries.some((entry) => entry.status === "loading"))
-                return;
-            finish({ ...update, requestId });
+    try {
+        await observation.ready;
+        signal.throwIfAborted();
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let requestId = null;
+            let snapshotCwd;
+            const pendingUpdates = new Map();
+            let latestEntries = [];
+            const cleanup = () => {
+                clearTimeout(timeout);
+                unsubscribe();
+                signal.removeEventListener("abort", abort);
+            };
+            const finish = (snapshot) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(snapshot);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            };
+            const updateMatches = (update) => update.cwd === snapshotCwd;
+            const unsubscribe = observation.subscribe({
+                snapshot: () => { },
+                update: (message) => {
+                    if (message.type !== "providers_snapshot_update")
+                        return;
+                    const update = message.payload;
+                    if (!requestId) {
+                        pendingUpdates.set(update.cwd, update);
+                        return;
+                    }
+                    if (!updateMatches(update))
+                        return;
+                    latestEntries = update.entries;
+                    if (update.entries.some((entry) => entry.status === "loading"))
+                        return;
+                    finish({ ...update, requestId });
+                },
+            });
+            const abort = () => fail(new Error("Paseo API is disposed"));
+            signal.addEventListener("abort", abort, { once: true });
+            const timeout = setTimeout(() => {
+                const loading = latestEntries
+                    .filter((entry) => entry.status === "loading")
+                    .map((entry) => entry.provider)
+                    .join(", ");
+                fail(new Error(loading
+                    ? `Timed out waiting for providers: ${loading}`
+                    : "Timed out waiting for provider discovery"));
+            }, timeoutMs);
+            void daemonClient
+                .getProvidersSnapshot(snapshotOptions)
+                .then((snapshot) => {
+                requestId = snapshot.requestId;
+                snapshotCwd = snapshot.cwd;
+                latestEntries = snapshot.entries;
+                if (!snapshot.entries.some((entry) => entry.status === "loading")) {
+                    finish(snapshot);
+                    return;
+                }
+                const pendingUpdate = pendingUpdates.get(snapshotCwd);
+                if (pendingUpdate && !pendingUpdate.entries.some((entry) => entry.status === "loading")) {
+                    finish({ ...pendingUpdate, requestId });
+                }
+                return undefined;
+            })
+                .catch(fail);
         });
-        const timeout = setTimeout(() => {
-            const loading = latestEntries
-                .filter((entry) => entry.status === "loading")
-                .map((entry) => entry.provider)
-                .join(", ");
-            fail(new Error(loading
-                ? `Timed out waiting for providers: ${loading}`
-                : "Timed out waiting for provider discovery"));
-        }, timeoutMs);
-        void daemonClient
-            .getProvidersSnapshot(snapshotOptions)
-            .then((snapshot) => {
-            requestId = snapshot.requestId;
-            snapshotCwd = snapshot.cwd;
-            latestEntries = snapshot.entries;
-            if (!snapshot.entries.some((entry) => entry.status === "loading")) {
-                finish(snapshot);
-                return;
-            }
-            const pendingUpdate = pendingUpdates.get(snapshotCwd);
-            if (pendingUpdate && !pendingUpdate.entries.some((entry) => entry.status === "loading")) {
-                finish({ ...pendingUpdate, requestId });
-            }
-            return undefined;
-        })
-            .catch(fail);
-    });
+    }
+    finally {
+        await observation.release();
+    }
 }
 function createGeneratedClientId() {
     const randomId = typeof globalThis.crypto?.randomUUID === "function"

package/dist/provider-snapshots/index.d.ts

@@ -7,15 +7,13 @@ type Snapshot = GetProvidersSnapshotResponseMessage["payload"];
 export declare class ProviderSnapshotUpdates {
     private readonly host;
     private pending;
-    private paused;
     constructor(host: {
+        active(update: Update): boolean;
         fetch(cwd: string | undefined): Promise<Snapshot>;
         emit(update: Update): void;
         failed(error: unknown): void;
     });
     clear(): void;
-    pause(): void;
-    resume(): void;
     receive(update: Update): void;
     private resolve;
 }