@hyperdrive.bot/fleet-client 0.3.218 → 0.3.221

package/dist/index.js

@@ -1,4 +1,10 @@
 import { DaemonClient } from "./daemon-client.js";
+import { createTerminalActions, } from "./terminals/index.js";
+/**
+ * Coding turns routinely run for minutes, so the handle waits far longer than
+ * the transport's own conservative default.
+ */
+const DEFAULT_WAIT_FOR_FINISH_MS = 10 * 60000;
 export { DaemonClient };
 export { DirectorySuggestionsSupersededError, UploadCancelledError, UploadCapExceededError, UploadFailedError, } from "./daemon-client.js";
 export function createPaseoClient(config) {
@@ -7,144 +13,407 @@ export function createPaseoClient(config) {
         clientId: config.clientId ?? createGeneratedClientId(),
         clientType: "cli",
     });
-    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient);
-    const createAgentHandle = createAgentHandleFactory(daemonClient);
+    const api = createPaseoApi(daemonClient);
     return {
+        ...api,
+        connect: () => daemonClient.connect(),
+        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;
+    };
+    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));
+        return createAgentHandle(agent);
+    };
+    const terminals = createTerminalActions(daemonClient, async (workspaceId) => {
+        const workspace = await createWorkspaceHandle(workspaceId).refresh();
+        if (!workspace?.workspaceDirectory) {
+            throw new Error(`Workspace ${workspaceId} is not active or has no available directory`);
+        }
+        return workspace.workspaceDirectory;
+    });
+    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) => {
+                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: (input, requestId) => openWorkspace(daemonClient, createWorkspaceHandle, input, requestId),
+            create: async ({ requestId, agent, ...options }) => {
+                const result = await daemonClient.createWorkspace({ ...options, ...(agent ? { agent: toDaemonAgentCreateOptions(agent) } : {}) }, 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: listAgents,
             ref: (agent) => createAgentHandle(agent),
-            create: async (options) => {
-                const agent = await daemonClient.createAgent(options);
-                return createAgentHandle(agent);
-            },
-            subscribe: (handler) => daemonClient.on("agent_update", (message) => {
-                handler(message.payload);
-            }),
+            create: (options) => createAgent(options),
+            subscribe: listenAgents,
         },
         providers: {
-            codex: (input) => providerConfig("codex", input),
-            claude: (input) => providerConfig("claude", input),
-            opencode: (input) => providerConfig("opencode", input),
-            copilot: (input) => providerConfig("copilot", input),
-            config: (provider, input) => providerConfig(provider, input),
             listModels: (provider, options) => daemonClient.listProviderModels(provider, options),
             listModes: (provider, options) => daemonClient.listProviderModes(provider, options),
-            listFeatures: (draftConfig, options) => daemonClient.listProviderFeatures(draftConfig, options),
+            listFeatures: ({ provider: providerModel, ...draftConfig }, options) => {
+                const { provider, model } = parseProviderModel(providerModel);
+                return daemonClient.listProviderFeatures({ ...draftConfig, provider, model }, options);
+            },
             listAvailable: (options) => daemonClient.listAvailableProviders(options),
             snapshot: (options) => daemonClient.getProvidersSnapshot(options),
+            waitForReady: (options) => waitForProvidersReady(daemonClient, observeEvents(["providers_snapshot_update"]), lifetime.signal, options),
             refresh: (options) => daemonClient.refreshProvidersSnapshot(options),
             // Re-read agents.providers from the daemon's config.json (add/update/remove).
             // Distinct from `refresh`, which only re-probes availability of the
             // providers the daemon already knows about.
             reloadConfig: (options) => daemonClient.reloadProviderConfig(options),
             diagnostic: (provider, options) => daemonClient.getProviderDiagnostic(provider, options),
-            subscribe: (handler) => daemonClient.on("providers_snapshot_update", (message) => {
-                handler(message.payload);
-            }),
+            listUsage: (options) => listProviderUsage(daemonClient, options),
+            subscribe: (handler) => {
+                return subscribeEvent("providers_snapshot_update", (message) => {
+                    if (message.type === "providers_snapshot_update")
+                        handler(message.payload);
+                });
+            },
         },
         config: {
             get: (requestId) => daemonClient.getDaemonConfig(requestId),
             patch: (patch, requestId) => daemonClient.patchDaemonConfig(patch, requestId),
         },
-        connect: () => daemonClient.connect(),
-        close: () => daemonClient.close(),
-        ensureConnected: () => daemonClient.ensureConnected(),
-        getConnectionState: () => daemonClient.getConnectionState(),
     };
 }
-function createWorkspaceHandleFactory(daemonClient) {
+function createWorkspaceHandleFactory(daemonClient, createAgent, terminals, listen) {
     return (workspace) => {
         const id = typeof workspace === "string" ? workspace : workspace.id;
-        let latest = typeof workspace === "string" ? null : workspace;
-        return {
-            id,
-            latest: () => latest,
-            refetch: async (options) => {
-                // Best-effort: fetches one page and matches by id client-side, so a workspace beyond
-                // the first page won't be found. TODO: add a "get workspace by id" lookup and resolve
-                // by exact id instead of paging.
+        let current = typeof workspace === "string" ? null : workspace;
+        const refresh = async (options) => {
+            let cursor;
+            let requestId = options?.requestId;
+            do {
                 const result = await daemonClient.fetchWorkspaces({
-                    requestId: options?.requestId,
-                    page: { limit: 25 },
+                    requestId,
+                    page: { limit: 200, ...(cursor ? { cursor } : {}) },
                 });
-                latest = result.entries.find((entry) => entry.id === id) ?? null;
-                return latest;
+                const match = result.entries.find((entry) => entry.id === id);
+                if (match) {
+                    current = match;
+                    return current;
+                }
+                cursor = result.pageInfo.nextCursor ?? undefined;
+                requestId = undefined;
+            } while (cursor);
+            current = null;
+            return current;
+        };
+        return {
+            id,
+            get projectId() {
+                return current?.projectId ?? null;
+            },
+            get directory() {
+                return current?.workspaceDirectory ?? null;
+            },
+            get name() {
+                return current?.name ?? null;
+            },
+            get status() {
+                return current?.status ?? null;
+            },
+            agents: {
+                create: async (options) => {
+                    const snapshot = current ?? (await refresh());
+                    if (!snapshot?.workspaceDirectory) {
+                        throw new Error(`Workspace ${id} has no available directory`);
+                    }
+                    return createAgent({ ...options, cwd: snapshot.workspaceDirectory }, { workspaceId: id, cwd: snapshot.workspaceDirectory });
+                },
+            },
+            terminals: {
+                create: (options) => terminals.create({ ...options, workspaceId: id }),
+                list: (options) => terminals.list({ ...options, workspaceId: id }),
             },
+            current: () => current,
+            refresh,
+            setTitle: (title, requestId) => daemonClient.setWorkspaceTitle(id, title, requestId),
             archive: async (requestId) => {
                 const result = await daemonClient.archiveWorkspace(id, requestId);
-                if (latest) {
-                    latest = { ...latest, archivingAt: result.archivedAt };
+                if (current) {
+                    current = { ...current, archivingAt: result.archivedAt };
                 }
                 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) {
-                    latest = update.workspace;
+                    current = update.workspace;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.id === id) {
-                    latest = null;
                     handler(update);
                 }
             }),
         };
     };
 }
-function createAgentHandleFactory(daemonClient) {
+function createAgentHandleFactory(daemonClient, listen, subscribeTimeline) {
     return (agent) => {
         const id = typeof agent === "string" ? agent : agent.id;
-        let latest = typeof agent === "string" ? null : agent;
+        let current = typeof agent === "string" ? null : agent;
         const handle = {
             id,
             timeline: {
+                append: (item) => daemonClient.appendAgentTimelineItem(id, item),
                 refetch: async (options) => {
                     const result = await daemonClient.fetchAgentTimeline(id, options);
                     if (result.agent) {
-                        latest = result.agent;
+                        current = result.agent;
                     }
                     return result;
                 },
-                subscribe: (handler) => daemonClient.on("agent_stream", (message) => {
-                    if (message.payload.agentId === id) {
-                        handler(message.payload);
+                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 },
+                            });
                     }
                 }),
             },
-            latest: () => latest,
-            refetch: async (requestId) => {
+            get workspaceId() {
+                return current?.workspaceId ?? null;
+            },
+            get cwd() {
+                return current?.cwd ?? null;
+            },
+            get status() {
+                return current?.status ?? null;
+            },
+            get capabilities() {
+                return current?.capabilities ?? null;
+            },
+            get availableModes() {
+                return current?.availableModes ?? null;
+            },
+            get pendingPermissions() {
+                return current?.pendingPermissions ?? null;
+            },
+            get activeTurn() {
+                return current?.activeTurn ?? null;
+            },
+            get lastUsage() {
+                return current?.lastUsage ?? null;
+            },
+            get lastError() {
+                return current?.lastError ?? null;
+            },
+            get features() {
+                return current?.features ?? null;
+            },
+            get runtimeInfo() {
+                return current?.runtimeInfo ?? null;
+            },
+            get archivedAt() {
+                return current?.archivedAt ?? null;
+            },
+            current: () => current,
+            refresh: async (requestId) => {
                 const result = await daemonClient.fetchAgent({ agentId: id, requestId });
-                latest = result?.agent ?? null;
+                current = result?.agent ?? null;
                 return result;
             },
-            send: (text, options) => daemonClient.sendAgentMessage(id, text, options),
+            send: async (text, options) => {
+                await daemonClient.sendAgentMessage(id, text, options);
+            },
+            respondToPermission: async ({ requestId, response }) => {
+                await daemonClient.respondToPermission(id, requestId, response);
+            },
+            run: async (text, options) => {
+                const { timeoutMs, ...sendOptions } = options ?? {};
+                await daemonClient.sendAgentMessage(id, text, sendOptions);
+                const result = await daemonClient.waitForFinish(id, timeoutMs ?? DEFAULT_WAIT_FOR_FINISH_MS);
+                if (result.final) {
+                    current = result.final;
+                }
+                return result;
+            },
+            waitForFinish: async (timeoutMs) => {
+                const result = await daemonClient.waitForFinish(id, timeoutMs ?? DEFAULT_WAIT_FOR_FINISH_MS);
+                if (result.final) {
+                    current = result.final;
+                }
+                return result;
+            },
+            commands: (options) => daemonClient.listCommands({ agentId: id, ...options }),
             archive: async () => {
                 const result = await daemonClient.archiveAgent(id);
-                if (latest) {
-                    latest = { ...latest, archivedAt: result.archivedAt };
+                if (current) {
+                    current = { ...current, archivedAt: result.archivedAt };
                 }
                 return result;
             },
             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) {
-                    latest = update.agent;
+                    current = update.agent;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.agentId === id) {
-                    latest = null;
                     handler(update);
                 }
             }),
@@ -155,23 +424,117 @@ function createAgentHandleFactory(daemonClient) {
 async function openWorkspace(daemonClient, createWorkspaceHandle, input, requestId) {
     const options = typeof input === "string" ? { cwd: input, requestId } : input;
     const result = await daemonClient.openProject(options.cwd, options.requestId);
-    return {
-        ...result,
-        workspace: result.workspace ? createWorkspaceHandle(result.workspace) : null,
-    };
+    if (result.error || !result.workspace) {
+        throw new Error(result.error ?? `The daemon did not open a workspace for ${options.cwd}`);
+    }
+    return createWorkspaceHandle(result.workspace);
 }
 function resolveWorkspaceId(workspace) {
     return typeof workspace === "string" ? workspace : workspace.id;
 }
-function providerConfig(provider, input = {}) {
+function resolveAgentId(agent) {
+    return typeof agent === "string" ? agent : agent.id;
+}
+function parseProviderModel(selection) {
+    const separator = selection.indexOf("/");
+    if (separator <= 0 || separator === selection.length - 1) {
+        throw new Error('Expected config.provider in "provider/model" format');
+    }
     return {
-        provider,
-        ...(input.model !== undefined ? { model: input.model } : {}),
-        ...(input.modeId !== undefined ? { modeId: input.modeId } : {}),
-        ...(input.thinkingOptionId !== undefined ? { thinkingOptionId: input.thinkingOptionId } : {}),
-        ...(input.featureValues !== undefined ? { featureValues: input.featureValues } : {}),
+        provider: selection.slice(0, separator),
+        model: selection.slice(separator + 1),
     };
 }
+function listProviderUsage(daemonClient, options) {
+    // COMPAT(providerUsageList): added in v0.1.98, remove after 2027-02-28 once daemon floor >= v0.1.98.
+    if (daemonClient.getLastServerInfoMessage()?.features?.providerUsageList !== true) {
+        return Promise.reject(new Error("Update the host to list provider usage."));
+    }
+    return daemonClient.listProviderUsage(options);
+}
+async function waitForProvidersReady(daemonClient, observation, signal, options = {}) {
+    const { timeoutMs = 60000, ...snapshotOptions } = options;
+    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);
+        });
+    }
+    finally {
+        await observation.release();
+    }
+}
 function createGeneratedClientId() {
     const randomId = typeof globalThis.crypto?.randomUUID === "function"
         ? globalThis.crypto.randomUUID()

package/dist/legacy-usage-icons.d.ts

@@ -0,0 +1,2 @@
+export declare function legacyUsageIcon(sourceId: string): string | undefined;
+//# sourceMappingURL=legacy-usage-icons.d.ts.map

package/dist/legacy-usage-icons.js

@@ -0,0 +1,16 @@
+// COMPAT(providerUsageList): added in v0.1.98, remove after 2027-03-26.
+// Released hosts omit source icons. Delete these copies with the list conversion.
+const ICONS = {
+    claude: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z"/></svg>\n',
+    codex: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd"><path d="M21.55 10.004a5.416 5.416 0 00-.478-4.501c-1.217-2.09-3.662-3.166-6.05-2.66A5.59 5.59 0 0010.831 1C8.39.995 6.224 2.546 5.473 4.838A5.553 5.553 0 001.76 7.496a5.487 5.487 0 00.691 6.5 5.416 5.416 0 00.477 4.502c1.217 2.09 3.662 3.165 6.05 2.66A5.586 5.586 0 0013.168 23c2.443.006 4.61-1.546 5.361-3.84a5.553 5.553 0 003.715-2.66 5.488 5.488 0 00-.693-6.497v.001zm-8.381 11.558a4.199 4.199 0 01-2.675-.954c.034-.018.093-.05.132-.074l4.44-2.53a.71.71 0 00.364-.623v-6.176l1.877 1.069c.02.01.033.029.036.05v5.115c-.003 2.274-1.87 4.118-4.174 4.123zM4.192 17.78a4.059 4.059 0 01-.498-2.763c.032.02.09.055.131.078l4.44 2.53c.225.13.504.13.73 0l5.42-3.088v2.138a.068.068 0 01-.027.057L9.9 19.288c-1.999 1.136-4.552.46-5.707-1.51h-.001zM3.023 8.216A4.15 4.15 0 015.198 6.41l-.002.151v5.06a.711.711 0 00.364.624l5.42 3.087-1.876 1.07a.067.067 0 01-.063.005l-4.489-2.559c-1.995-1.14-2.679-3.658-1.53-5.63h.001zm15.417 3.54l-5.42-3.088L14.896 7.6a.067.067 0 01.063-.006l4.489 2.557c1.998 1.14 2.683 3.662 1.529 5.633a4.163 4.163 0 01-2.174 1.807V12.38a.71.71 0 00-.363-.623zm1.867-2.773a6.04 6.04 0 00-.132-.078l-4.44-2.53a.731.731 0 00-.729 0l-5.42 3.088V7.325a.068.068 0 01.027-.057L14.1 4.713c2-1.137 4.555-.46 5.707 1.513.487.833.664 1.809.499 2.757h.001zm-11.741 3.81l-1.877-1.068a.065.065 0 01-.036-.051V6.559c.001-2.277 1.873-4.122 4.181-4.12.976 0 1.92.338 2.671.954-.034.018-.092.05-.131.073l-4.44 2.53a.71.71 0 00-.365.623l-.003 6.173v.002zm1.02-2.168L12 9.25l2.414 1.375v2.75L12 14.75l-2.415-1.375v-2.75z"/></svg>\n',
+    copilot: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 416" fill="currentColor"><path d="M181.33 266.143c0-11.497 9.32-20.818 20.818-20.818 11.498 0 20.819 9.321 20.819 20.818v38.373c0 11.497-9.321 20.818-20.819 20.818-11.497 0-20.818-9.32-20.818-20.818v-38.373zM308.807 245.325c-11.477 0-20.798 9.321-20.798 20.818v38.373c0 11.497 9.32 20.818 20.798 20.818 11.497 0 20.818-9.32 20.818-20.818v-38.373c0-11.497-9.32-20.818-20.818-20.818z"\n        fill-rule="nonzero"/><path d="M512.002 246.393v57.384c-.02 7.411-3.696 14.638-9.67 19.011C431.767 374.444 344.695 416 256 416c-98.138 0-196.379-56.542-246.33-93.21-5.975-4.374-9.65-11.6-9.671-19.012v-57.384a35.347 35.347 0 016.857-20.922l15.583-21.085c8.336-11.312 20.757-14.31 33.98-14.31 4.988-56.953 16.794-97.604 45.024-127.354C155.194 5.77 226.56 0 256 0c29.441 0 100.807 5.77 154.557 62.722 28.19 29.75 40.036 70.401 45.025 127.354 13.263 0 25.602 2.936 33.958 14.31l15.583 21.127c4.476 6.077 6.878 13.345 6.878 20.88zm-97.666-26.075c-.677-13.058-11.292-18.19-22.338-21.824-11.64 7.309-25.848 10.183-39.46 10.183-14.454 0-41.432-3.47-63.872-25.869-5.667-5.625-9.527-14.454-12.155-24.247a212.902 212.902 0 00-20.469-1.088c-6.098 0-13.099.349-20.551 1.088-2.628 9.793-6.509 18.622-12.155 24.247-22.4 22.4-49.418 25.87-63.872 25.87-13.612 0-27.86-2.855-39.501-10.184-11.005 3.613-21.558 8.828-22.277 21.824-1.17 24.555-1.272 49.11-1.375 73.645-.041 12.318-.082 24.658-.288 36.976.062 7.166 4.374 13.818 10.882 16.774 52.97 24.124 103.045 36.278 149.137 36.278 46.01 0 96.085-12.154 149.014-36.278 6.508-2.956 10.84-9.608 10.881-16.774.637-36.832.124-73.809-1.642-110.62h.041zM107.521 168.97c8.643 8.623 24.966 14.392 42.56 14.392 13.448 0 39.03-2.874 60.156-24.329 9.28-8.951 15.05-31.35 14.413-54.079-.657-18.231-5.769-33.28-13.448-39.665-8.315-7.371-27.203-10.574-48.33-8.644-22.399 2.238-41.267 9.588-50.875 19.833-20.798 22.728-16.323 80.317-4.476 92.492zm130.556-56.008c.637 3.51.965 7.35 1.273 11.517 0 2.875 0 5.77-.308 8.952 6.406-.636 11.847-.636 16.959-.636s10.553 0 16.959.636c-.329-3.182-.329-6.077-.329-8.952.329-4.167.657-8.007 1.294-11.517-6.735-.637-12.812-.965-17.924-.965s-11.21.328-17.924.965zm49.275-8.008c-.637 22.728 5.133 45.128 14.413 54.08 21.105 21.454 46.708 24.328 60.155 24.328 17.596 0 33.918-5.769 42.561-14.392 11.847-12.175 16.322-69.764-4.476-92.492-9.608-10.245-28.476-17.595-50.875-19.833-21.127-1.93-40.015 1.273-48.33 8.644-7.679 6.385-12.791 21.434-13.448 39.665z"/></svg>\n',
+    cursor: '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 466.73 532.09">\n  <path fill="currentColor" d="M457.43,125.94L244.42,2.96c-6.84-3.95-15.28-3.95-22.12,0L9.3,125.94c-5.75,3.32-9.3,9.46-9.3,16.11v247.99c0,6.65,3.55,12.79,9.3,16.11l213.01,122.98c6.84,3.95,15.28,3.95,22.12,0l213.01-122.98c5.75-3.32,9.3-9.46,9.3-16.11v-247.99c0-6.65-3.55-12.79-9.3-16.11h-.01ZM444.05,151.99l-205.63,356.16c-1.39,2.4-5.06,1.42-5.06-1.36v-233.21c0-4.66-2.49-8.97-6.53-11.31L24.87,145.67c-2.4-1.39-1.42-5.06,1.36-5.06h411.26c5.84,0,9.49,6.33,6.57,11.39h-.01Z"/>\n</svg>\n',
+    zai: '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="currentColor" fill-rule="evenodd"><title>Z.ai</title><path d="M8.07 1.333L6.618 3.302H.435L1.887 1.333h6.184zM15.503 12.699L14.052 14.667h-6.161l1.449-1.968h6.163zM16 1.333L6.176 14.667H0L9.824 1.333H16z"/></svg>\n',
+    grok: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 8V4H8"/><rect width="16" height="12" x="4" y="8" rx="2"/><path d="M2 14h2M20 14h2M9 13v2M15 13v2"/></svg>\n',
+    kimi: '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24">\n  <path fill="currentColor" d="M19.514 7.342C19.711 7.862 19.814 8.413 19.816 8.969C19.816 12.494 15.998 14.697 12.946 12.934C11.529 12.116 10.657 10.605 10.657 8.969C10.657 5.646 14.085 3.431 17.115 4.793C15.26 3.373 12.99 2.607 10.655 2.612C4.772 2.614 0.005 7.381 0 13.265C0.002 19.148 4.772 23.918 10.655 23.92C16.538 23.916 21.306 19.147 21.31 13.265C21.312 11.155 20.687 9.095 19.514 7.342ZM14.841 4.666C14.841 8.191 18.657 10.395 21.709 8.632C23.127 7.814 24 6.302 24 4.666C24 1.14 20.184-1.061 17.13 0.699C15.714 1.519 14.841 3.03 14.841 4.666"/>\n</svg>\n',
+    minimax: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor"><path d="M16.278 2c1.156 0 2.093.927 2.093 2.07v12.501a.74.74 0 00.744.709.74.74 0 00.743-.709V9.099a2.06 2.06 0 012.071-2.049A2.06 2.06 0 0124 9.1v6.561a.649.649 0 01-.652.645.649.649 0 01-.653-.645V9.1a.762.762 0 00-.766-.758.762.762 0 00-.766.758v7.472a2.037 2.037 0 01-2.048 2.026 2.037 2.037 0 01-2.048-2.026v-12.5a.785.785 0 00-.788-.753.785.785 0 00-.789.752l-.001 15.904A2.037 2.037 0 0113.441 22a2.037 2.037 0 01-2.048-2.026V18.04c0-.356.292-.645.652-.645.36 0 .652.289.652.645v1.934c0 .263.142.506.372.638.23.131.514.131.744 0a.734.734 0 00.372-.638V4.07c0-1.143.937-2.07 2.093-2.07zm-5.674 0c1.156 0 2.093.927 2.093 2.07v11.523a.648.648 0 01-.652.645.648.648 0 01-.652-.645V4.07a.785.785 0 00-.789-.78.785.785 0 00-.789.78v14.013a2.06 2.06 0 01-2.07 2.048 2.06 2.06 0 01-2.071-2.048V9.1a.762.762 0 00-.766-.758.762.762 0 00-.766.758v3.8a2.06 2.06 0 01-2.071 2.049A2.06 2.06 0 010 12.9v-1.378c0-.357.292-.646.652-.646.36 0 .653.29.653.646V12.9c0 .418.343.757.766.757s.766-.339.766-.757V9.099a2.06 2.06 0 012.07-2.048 2.06 2.06 0 012.071 2.048v8.984c0 .419.343.758.767.758.423 0 .766-.339.766-.758V4.07c0-1.143.937-2.07 2.093-2.07z"/></svg>\n',
+};
+export function legacyUsageIcon(sourceId) {
+    return Object.hasOwn(ICONS, sourceId) ? ICONS[sourceId] : undefined;
+}
+//# sourceMappingURL=legacy-usage-icons.js.map

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

@@ -0,0 +1,21 @@
+import type { GetProvidersSnapshotResponseMessage, SessionOutboundMessage } from "@hyperdrive.bot/fleet-protocol/messages";
+type Update = Extract<SessionOutboundMessage, {
+    type: "providers_snapshot_update";
+}>;
+type Snapshot = GetProvidersSnapshotResponseMessage["payload"];
+/** Resolve announcements only while observed, coalescing changes during a fetch. */
+export declare class ProviderSnapshotUpdates {
+    private readonly host;
+    private pending;
+    constructor(host: {
+        active(update: Update): boolean;
+        fetch(cwd: string | undefined): Promise<Snapshot>;
+        emit(update: Update): void;
+        failed(error: unknown): void;
+    });
+    clear(): void;
+    receive(update: Update): void;
+    private resolve;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map