@pipeline-moe/client-core 0.1.0

package/dist/state.js

@@ -0,0 +1,300 @@
+// Framework-agnostic room state + a pure SSE reducer.
+//
+// Every handler here was lifted verbatim from the web app's `useRoom` hook,
+// which already wrote every update as a functional `setX(prev => next)` — i.e.
+// each was already a pure function of (prevState, eventData). That made the
+// transposition mechanical: this file holds exactly the same transitions with
+// no React, no fetch, no timers.
+//
+// Notices are the one transition that isn't pure state→state (they auto-expire
+// on a timer), so the reducer surfaces them as `effects` for the store to
+// apply, rather than mutating a notice list here.
+/** The initial state of a freshly-opened room, before any snapshot or SSE. */
+export const initialRoomState = {
+    roster: [],
+    messages: [],
+    streaming: {},
+    liveActivity: {},
+    liveReasoning: {},
+    receipts: {},
+    workspace: [],
+    notices: [],
+    connected: false,
+    turnActive: false,
+    runningAgentId: null,
+    paused: false,
+    pausedQuestion: null,
+    pausedAskerId: null,
+    chaining: true,
+    routingMode: "auto",
+    defaultAgent: null,
+    fallbackAgent: null,
+    maxChainHops: 30,
+    circuitBreaker: true,
+    defaultThinkingLevel: "medium",
+    allowCloud: false,
+    compactionReserveTokens: 38000,
+    pendingRoute: null,
+    maxRooms: 8,
+    conversations: [],
+    currentConversationId: "",
+    providers: [],
+    explicitlyEnabled: [],
+    oauthProgress: null,
+};
+/**
+ * Reset the per-turn transient fields. These are driven only by
+ * `turn`/`token`/`activity` SSE events; on a room/conversation switch they must
+ * be cleared, otherwise a turn the new context never started would leave them
+ * pinned (e.g. a stuck "agents running…" or a stale ask_user prompt).
+ */
+export function resetTransient(state) {
+    return {
+        ...state,
+        turnActive: false,
+        runningAgentId: null,
+        paused: false,
+        pausedQuestion: null,
+        pausedAskerId: null,
+        pendingRoute: null,
+        streaming: {},
+        liveActivity: {},
+        liveReasoning: {},
+        receipts: {},
+    };
+}
+/** The named SSE events a room client subscribes to. */
+export const SSE_EVENT_NAMES = [
+    "roster",
+    "status",
+    "token",
+    "activity",
+    "reasoning",
+    "message",
+    "receipt",
+    "workspace",
+    "notice",
+    "turn",
+    "settings",
+    "routing",
+    "transcript",
+    "conversations",
+    "providers",
+    "oauth_progress",
+];
+const noEffects = (state) => ({ state, effects: [] });
+function omit(map, key) {
+    if (!(key in map))
+        return map;
+    const next = { ...map };
+    delete next[key];
+    return next;
+}
+/**
+ * The pure SSE reducer. Given the current state and one parsed event, returns
+ * the next state plus any notices to surface. Never mutates its inputs.
+ */
+export function reduce(state, event) {
+    switch (event.name) {
+        case "roster":
+            return noEffects({ ...state, roster: event.data });
+        case "status": {
+            const data = event.data;
+            return noEffects({
+                ...state,
+                roster: state.roster.map((p) => {
+                    if (p.id !== data.id)
+                        return p;
+                    const base = { ...p, status: data.status };
+                    // Only update contextUsage when the payload explicitly carries it.
+                    // Mid-turn status events (e.g. "working") don't include it — preserving
+                    // the last known value prevents the progress bar from briefly clearing.
+                    if (data.contextUsage !== undefined)
+                        base.contextUsage = data.contextUsage;
+                    if (data.sessionStats !== undefined)
+                        base.sessionStats = data.sessionStats;
+                    if (data.retry !== undefined)
+                        base.retry = data.retry;
+                    return base;
+                }),
+            });
+        }
+        case "token": {
+            const { id, delta } = event.data;
+            return noEffects({ ...state, streaming: { ...state.streaming, [id]: (state.streaming[id] ?? "") + delta } });
+        }
+        case "activity": {
+            const { id, item } = event.data;
+            const list = state.liveActivity[id] ?? [];
+            const idx = list.findIndex((x) => x.toolCallId === item.toolCallId);
+            const next = idx >= 0 ? list.map((x, i) => (i === idx ? item : x)) : [...list, item];
+            return noEffects({ ...state, liveActivity: { ...state.liveActivity, [id]: next } });
+        }
+        case "reasoning": {
+            const { id, delta } = event.data;
+            return noEffects({ ...state, liveReasoning: { ...state.liveReasoning, [id]: (state.liveReasoning[id] ?? "") + delta } });
+        }
+        case "message": {
+            const msg = event.data;
+            const messages = [...state.messages, msg];
+            if (msg.author === "user")
+                return noEffects({ ...state, messages });
+            // The message now carries its final activity; drop the live buffers.
+            return noEffects({
+                ...state,
+                messages,
+                streaming: omit(state.streaming, msg.author),
+                liveActivity: omit(state.liveActivity, msg.author),
+                liveReasoning: omit(state.liveReasoning, msg.author),
+            });
+        }
+        case "receipt": {
+            const r = event.data;
+            const last = [...state.messages].reverse().find((m) => m.author === r.participantId);
+            if (!last)
+                return noEffects(state);
+            return noEffects({ ...state, receipts: { ...state.receipts, [last.index]: r } });
+        }
+        case "workspace":
+            return noEffects({ ...state, workspace: event.data });
+        case "notice": {
+            const { msg, level } = event.data;
+            return { state, effects: [{ type: "notice", msg, level: level ?? "info" }] };
+        }
+        case "turn": {
+            const data = event.data;
+            if (data.phase === "start") {
+                return noEffects({
+                    ...state,
+                    turnActive: true,
+                    runningAgentId: data.agentId ?? null,
+                    streaming: {},
+                    liveActivity: {},
+                    liveReasoning: {},
+                });
+            }
+            if (data.phase === "end") {
+                return noEffects({
+                    ...state,
+                    turnActive: false,
+                    runningAgentId: null,
+                    paused: false,
+                    pausedQuestion: null,
+                    pausedAskerId: null,
+                    pendingRoute: null,
+                });
+            }
+            if (data.phase === "pause") {
+                return {
+                    state: {
+                        ...state,
+                        turnActive: false,
+                        paused: true,
+                        pausedQuestion: data.question ?? null,
+                        pausedAskerId: data.askerId ?? null,
+                    },
+                    effects: [{ type: "notice", msg: `${data.askerId} is waiting for your answer.`, level: "info" }],
+                };
+            }
+            if (data.phase === "resume") {
+                return {
+                    state: {
+                        ...state,
+                        paused: false,
+                        pausedQuestion: null,
+                        pausedAskerId: null,
+                        turnActive: true,
+                    },
+                    effects: [{ type: "notice", msg: `Resuming — answering ${data.askerId}`, level: "info" }],
+                };
+            }
+            // chain
+            const to = (data.targets ?? []).map((t) => `@${t}`).join(" ");
+            return { state, effects: [{ type: "notice", msg: `@${data.from} → ${to}`, level: "info" }] };
+        }
+        case "settings": {
+            const d = event.data;
+            const next = { ...state, chaining: d.chaining };
+            if (d.routingMode !== undefined)
+                next.routingMode = d.routingMode;
+            if (d.defaultAgent !== undefined)
+                next.defaultAgent = d.defaultAgent;
+            if (d.fallbackAgent !== undefined)
+                next.fallbackAgent = d.fallbackAgent;
+            if (d.maxChainHops !== undefined)
+                next.maxChainHops = d.maxChainHops;
+            if (d.circuitBreaker !== undefined)
+                next.circuitBreaker = d.circuitBreaker;
+            if (d.defaultThinkingLevel !== undefined)
+                next.defaultThinkingLevel = d.defaultThinkingLevel;
+            if (d.allowCloud !== undefined)
+                next.allowCloud = d.allowCloud;
+            if (d.compactionReserveTokens !== undefined)
+                next.compactionReserveTokens = d.compactionReserveTokens;
+            return noEffects(next);
+        }
+        case "routing": {
+            const data = event.data;
+            if (data.type === "proposed") {
+                // paused for approval — not actively running
+                return noEffects({ ...state, pendingRoute: data.proposals ?? [], turnActive: false });
+            }
+            return noEffects({ ...state, pendingRoute: null });
+        }
+        case "transcript": {
+            const msgs = event.data;
+            return noEffects({
+                ...state,
+                messages: msgs,
+                streaming: {},
+                liveActivity: {},
+                liveReasoning: {},
+                receipts: {},
+            });
+        }
+        case "conversations": {
+            const { currentId, list } = event.data;
+            return noEffects({ ...state, conversations: list, currentConversationId: currentId });
+        }
+        case "providers": {
+            const data = event.data;
+            const next = { ...state };
+            if (data.providers)
+                next.providers = data.providers;
+            if (data.explicitlyEnabled)
+                next.explicitlyEnabled = data.explicitlyEnabled;
+            return noEffects(next);
+        }
+        case "oauth_progress": {
+            const data = event.data;
+            let effect;
+            if (data.type === "device_code") {
+                effect = { type: "notice", msg: `OAuth for ${data.provider}: visit ${data.verificationUri}, enter code ${data.userCode}`, level: "info" };
+            }
+            else if (data.type === "auth_url") {
+                effect = { type: "notice", msg: `OAuth for ${data.provider}: ${data.instructions || "visit " + data.url}`, level: "info" };
+            }
+            else if (data.type === "progress") {
+                effect = { type: "notice", msg: `OAuth ${data.provider}: ${data.message}`, level: "info" };
+            }
+            else if (data.type === "success") {
+                effect = { type: "notice", msg: data.message ?? "", level: "info" };
+            }
+            else {
+                effect = { type: "notice", msg: data.message ?? "", level: "error" };
+            }
+            const oauthProgress = {
+                provider: data.provider ?? state.oauthProgress?.provider ?? "",
+                status: data.type,
+                verificationUri: data.verificationUri,
+                userCode: data.userCode,
+                url: data.url,
+                instructions: data.instructions,
+                message: data.message,
+            };
+            return { state: { ...state, oauthProgress }, effects: [effect] };
+        }
+        default:
+            return noEffects(state);
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,88 @@
+import type { RoomApi } from "./api.js";
+import { type RoomState, type SseEventName, type ThinkingLevel } from "./state.js";
+import type { RouteDecision, RoutingMode } from "./types.js";
+export interface SseConnection {
+    close(): void;
+}
+export interface SseHandlers {
+    onOpen(): void;
+    onError(): void;
+    onEvent(name: SseEventName, data: string): void;
+}
+export type EventSourceFactory = (url: string, handlers: SseHandlers) => SseConnection;
+/** EventSource factory backed by the browser's global `EventSource`. */
+export declare const browserEventSourceFactory: EventSourceFactory;
+export interface RoomStoreOptions {
+    /** Server origin, e.g. "http://localhost:5300". */
+    apiBase: string;
+    /** Room to subscribe to. Defaults to "default". */
+    roomId?: string;
+    /** How events arrive. Defaults to the browser EventSource factory. */
+    eventSourceFactory?: EventSourceFactory;
+    /** Notice auto-dismiss delay in ms. Defaults to 5000. */
+    noticeTtlMs?: number;
+}
+export type RoomStore = ReturnType<typeof createRoomStore>;
+/**
+ * Create a room store bound to a server and room. Call {@link RoomStore.start}
+ * to load the snapshot and open the SSE stream, and {@link RoomStore.stop} to
+ * tear it down. Read state via `getSnapshot()` and react to changes via
+ * `subscribe()`.
+ */
+export declare function createRoomStore(opts: RoomStoreOptions): {
+    roomId: string;
+    getSnapshot: () => RoomState;
+    subscribe: (cb: () => void) => (() => void);
+    start: () => void;
+    stop: () => void;
+    actions: {
+        send: (text: string, images?: string[]) => void;
+        setActive: (id: string, active: boolean) => void;
+        setParallel: (id: string, parallel: boolean) => void;
+        kick: (id: string) => void;
+        createParticipant: (body: Parameters<RoomApi["create"]>[0]) => Promise<import("./types.js").RosterItem>;
+        addFromTemplate: (templateId: string) => Promise<import("./types.js").RosterItem>;
+        savePreset: (name: string) => Promise<import("./types.js").PresetFile>;
+        loadPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: import("./types.js").ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        applyPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: import("./types.js").ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        getParticipant: (id: string) => Promise<import("./types.js").PersonaDetail>;
+        updateParticipant: (id: string, patchBody: Parameters<RoomApi["updateAgent"]>[1]) => Promise<import("./types.js").RosterItem>;
+        reorderParticipants: (order: string[]) => void;
+        abort: () => void;
+        steer: (text: string, target: string) => void;
+        compactAgent: (id: string) => void;
+        setChaining: (value: boolean) => void;
+        setRoutingMode: (mode: RoutingMode) => void;
+        setCircuitBreaker: (value: boolean) => void;
+        setDefaultThinkingLevel: (level: ThinkingLevel) => void;
+        setAllowCloud: (value: boolean) => void;
+        setCompactionReserveTokens: (value: number) => void;
+        resolveRoute: (decision: RouteDecision) => void;
+        setDefaultAgent: (id: string | null) => void;
+        setFallbackAgent: (id: string | null) => void;
+        setMaxChainHops: (n: number) => void;
+        newConversation: (title?: string) => void;
+        loadConversation: (id: string) => void;
+        renameConversation: (id: string, title: string) => void;
+        deleteConversation: (id: string) => void;
+        addProvider: (name: string, key: string) => void;
+        removeProvider: (name: string) => void;
+        loginProvider: (name: string) => void;
+        dismissOAuth: () => void;
+    };
+    pushNotice: (msg: string, level?: "info" | "error") => void;
+};

package/dist/store.js

@@ -0,0 +1,279 @@
+// The room store: the single effectful owner of a room's live state.
+//
+// It wraps the pure reducer (state.ts) with everything that isn't pure — the
+// initial REST snapshot, the SSE subscription, notice expiry timers, and the
+// action methods that POST/PATCH/DELETE and map failures to notices. It is
+// framework-agnostic: it exposes a `subscribe`/`getSnapshot` contract that a
+// React `useSyncExternalStore` adapter or an Ink render loop can both consume.
+import { createApi } from "./api.js";
+import { initialRoomState, reduce, resetTransient, SSE_EVENT_NAMES, } from "./state.js";
+/** EventSource factory backed by the browser's global `EventSource`. */
+export const browserEventSourceFactory = (url, h) => {
+    const es = new EventSource(url);
+    es.onopen = () => h.onOpen();
+    es.onerror = () => h.onError();
+    for (const name of SSE_EVENT_NAMES) {
+        es.addEventListener(name, (e) => h.onEvent(name, e.data));
+    }
+    return { close: () => es.close() };
+};
+/**
+ * Create a room store bound to a server and room. Call {@link RoomStore.start}
+ * to load the snapshot and open the SSE stream, and {@link RoomStore.stop} to
+ * tear it down. Read state via `getSnapshot()` and react to changes via
+ * `subscribe()`.
+ */
+export function createRoomStore(opts) {
+    const roomId = opts.roomId || "default";
+    const noticeTtlMs = opts.noticeTtlMs ?? 5000;
+    const makeEventSource = opts.eventSourceFactory ?? browserEventSourceFactory;
+    // Route prefix: /api for the default room (backward compat), /api/rooms/:id
+    // otherwise. SSE is always the room-scoped endpoint — even "default" — so the
+    // default room doesn't inherit the unfiltered global stream.
+    const prefix = roomId !== "default" ? `/api/rooms/${roomId}` : "/api";
+    const { makeRoomApi, api } = createApi(opts.apiBase);
+    const rApi = makeRoomApi(prefix);
+    const sseUrl = `${opts.apiBase}/api/rooms/${roomId}/events`;
+    let state = initialRoomState;
+    const listeners = new Set();
+    let noticeSeq = 1;
+    const noticeTimers = new Set();
+    let conn = null;
+    const getSnapshot = () => state;
+    const subscribe = (cb) => {
+        listeners.add(cb);
+        return () => listeners.delete(cb);
+    };
+    const emit = () => {
+        for (const cb of listeners)
+            cb();
+    };
+    const set = (next) => {
+        if (next === state)
+            return;
+        state = next;
+        emit();
+    };
+    /** Merge a partial into state (used by actions doing optimistic / response writes). */
+    const patch = (partial) => set({ ...state, ...partial });
+    const pushNotice = (msg, level = "info") => {
+        const id = noticeSeq++;
+        set({ ...state, notices: [...state.notices, { id, msg, level }] });
+        const timer = setTimeout(() => {
+            noticeTimers.delete(timer);
+            set({ ...state, notices: state.notices.filter((n) => n.id !== id) });
+        }, noticeTtlMs);
+        noticeTimers.add(timer);
+    };
+    const applyEffects = (effects) => {
+        for (const e of effects)
+            pushNotice(e.msg, e.level);
+    };
+    const onEvent = (name, raw) => {
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const result = reduce(state, { name, data });
+        set(result.state);
+        applyEffects(result.effects);
+    };
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
+    /** Load the REST snapshot and open the SSE stream. Idempotent-safe to call once. */
+    const start = () => {
+        // Clear transient fields before (re)loading — a reused store must not show a
+        // prior room's in-flight turn. Fresh stores are already clean; this is cheap.
+        set(resetTransient(state));
+        rApi.transcript().then((m) => patch({ messages: m })).catch(() => { });
+        rApi.workspace().then((w) => patch({ workspace: w })).catch(() => { });
+        rApi.roster().then((r) => patch({ roster: r })).catch(() => { });
+        rApi.settings().then((s) => {
+            const next = {
+                chaining: s.chaining,
+                routingMode: s.routingMode,
+                defaultAgent: s.defaultAgent,
+            };
+            if (s.fallbackAgent !== undefined)
+                next.fallbackAgent = s.fallbackAgent;
+            if (s.maxChainHops !== undefined)
+                next.maxChainHops = s.maxChainHops;
+            if (s.circuitBreaker !== undefined)
+                next.circuitBreaker = s.circuitBreaker;
+            if (s.defaultThinkingLevel !== undefined)
+                next.defaultThinkingLevel = s.defaultThinkingLevel;
+            if (s.allowCloud !== undefined)
+                next.allowCloud = s.allowCloud;
+            if (s.compactionReserveTokens !== undefined)
+                next.compactionReserveTokens = s.compactionReserveTokens;
+            if (s.maxRooms !== undefined)
+                next.maxRooms = s.maxRooms;
+            next.pendingRoute = s.pendingRoute ? s.pendingRoute.proposals : null;
+            patch(next);
+        }).catch(() => { });
+        rApi.conversations().then((c) => patch({ conversations: c.list, currentConversationId: c.currentId })).catch(() => { });
+        api.providers().then((d) => patch({ providers: d.providers, explicitlyEnabled: d.explicitlyEnabled })).catch(() => { });
+        conn = makeEventSource(sseUrl, {
+            onOpen: () => patch({ connected: true }),
+            onError: () => patch({ connected: false }),
+            onEvent,
+        });
+    };
+    /** Close the SSE stream and cancel pending notice timers. */
+    const stop = () => {
+        conn?.close();
+        conn = null;
+        for (const t of noticeTimers)
+            clearTimeout(t);
+        noticeTimers.clear();
+    };
+    const fail = (err) => pushNotice(String(err?.message ?? err), "error");
+    // ── Actions ───────────────────────────────────────────────────────────────
+    // Thin wrappers over the REST surface. Optimistic writes and response-driven
+    // state updates are preserved exactly as the web hook had them.
+    const actions = {
+        send: (text, images) => {
+            rApi.sendMessage(text, images).catch(fail);
+        },
+        setActive: (id, active) => {
+            rApi.setActive(id, active).catch(fail);
+        },
+        setParallel: (id, parallel) => {
+            rApi.setParallel(id, parallel).catch(fail);
+        },
+        kick: (id) => {
+            rApi.kick(id).catch(fail);
+        },
+        createParticipant: (body) => rApi.create(body).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        addFromTemplate: (templateId) => rApi.addFromTemplate(templateId).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        savePreset: (name) => rApi.savePreset(name).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        loadPreset: (name) => rApi.loadPreset(name).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        applyPreset: (name) => rApi.applyPreset(name).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        getParticipant: (id) => rApi.participant(id),
+        updateParticipant: (id, patchBody) => rApi.updateAgent(id, patchBody).catch((err) => {
+            fail(err);
+            throw err;
+        }),
+        reorderParticipants: (order) => {
+            // Optimistic: reorder the local roster immediately so the drag feels
+            // instant; the server's "roster" broadcast then confirms it.
+            const byId = new Map(state.roster.map((p) => [p.id, p]));
+            const reordered = order.map((id) => byId.get(id)).filter(Boolean);
+            for (const p of state.roster)
+                if (!order.includes(p.id))
+                    reordered.push(p);
+            patch({ roster: reordered });
+            rApi.reorder(order).catch((err) => {
+                fail(err);
+                rApi.roster().then((r) => patch({ roster: r })).catch(() => { }); // revert to server truth
+            });
+        },
+        abort: () => {
+            rApi.abort().catch(() => { });
+        },
+        steer: (text, target) => {
+            rApi.steerMessage(text, target).catch((err) => {
+                const msg = String(err?.message ?? err);
+                if (msg.includes("not running") || msg.includes("cannot steer")) {
+                    pushNotice(`@${target} is not running — cannot steer`, "error");
+                }
+                else {
+                    pushNotice(msg, "error");
+                }
+            });
+        },
+        compactAgent: (id) => {
+            pushNotice(`Compacting @${id}…`);
+            rApi.compact(id)
+                .then((r) => pushNotice(`@${id} compacted: ${r.tokensBefore} tokens before → summary generated.`))
+                .catch(fail);
+        },
+        setChaining: (value) => {
+            rApi.setChaining(value).then((s) => patch({ chaining: s.chaining })).catch(fail);
+        },
+        setRoutingMode: (mode) => {
+            rApi.setRoutingMode(mode).then((s) => patch({ routingMode: s.routingMode })).catch(fail);
+        },
+        setCircuitBreaker: (value) => {
+            rApi.setCircuitBreaker(value).then((s) => patch({ circuitBreaker: s.circuitBreaker })).catch(fail);
+        },
+        setDefaultThinkingLevel: (level) => {
+            rApi.setDefaultThinkingLevel(level).then((s) => patch({ defaultThinkingLevel: s.defaultThinkingLevel })).catch(fail);
+        },
+        setAllowCloud: (value) => {
+            rApi.setAllowCloud(value).then((s) => patch({ allowCloud: s.allowCloud })).catch(fail);
+        },
+        setCompactionReserveTokens: (value) => {
+            rApi.setCompactionReserveTokens(value).then((s) => patch({ compactionReserveTokens: s.compactionReserveTokens })).catch(fail);
+        },
+        resolveRoute: (decision) => {
+            patch({ pendingRoute: null }); // optimistic — the card disappears immediately
+            rApi.resolveRoute(decision).catch(fail);
+        },
+        setDefaultAgent: (id) => {
+            rApi.setDefaultAgent(id).then((s) => patch({ defaultAgent: s.defaultAgent })).catch(fail);
+        },
+        setFallbackAgent: (id) => {
+            rApi.setFallbackAgent(id).then((s) => patch({ fallbackAgent: s.fallbackAgent ?? null })).catch(fail);
+        },
+        setMaxChainHops: (n) => {
+            rApi.setMaxChainHops(n).then((s) => patch({ maxChainHops: s.maxChainHops })).catch(fail);
+        },
+        newConversation: (title) => {
+            rApi.newConversation(title).catch(fail);
+        },
+        loadConversation: (id) => {
+            if (id === state.currentConversationId)
+                return;
+            rApi.loadConversation(id).catch(fail);
+        },
+        renameConversation: (id, title) => {
+            rApi.renameConversation(id, title).catch(fail);
+        },
+        deleteConversation: (id) => {
+            rApi.deleteConversation(id).catch(fail);
+        },
+        addProvider: (name, key) => {
+            api.addProvider(name, key).then(() => {
+                pushNotice(`Provider "${name}" configured.`);
+                // Refresh models so the dropdown picks up new models.
+                api.models().catch(() => { });
+            }).catch(fail);
+        },
+        removeProvider: (name) => {
+            api.removeProvider(name).then((r) => {
+                let msg = `Provider "${name}" removed.`;
+                if (r.agentsUsing && r.agentsUsing.length > 0) {
+                    msg += ` Note: ${r.agentsUsing.join(", ")} may need model reassigned.`;
+                }
+                pushNotice(msg);
+            }).catch(fail);
+        },
+        loginProvider: (name) => {
+            api.loginProvider(name).then(() => {
+                pushNotice(`OAuth login started for ${name} — follow the instructions in notifications.`);
+            }).catch(fail);
+        },
+        dismissOAuth: () => {
+            patch({ oauthProgress: null });
+        },
+    };
+    return { roomId, getSnapshot, subscribe, start, stop, actions, pushNotice };
+}