@pipeline-moe/client-core 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,238 @@
+import type { ConversationMeta, Message, ModelInfo, PersonaDetail, PersonaTemplate, PresetFile, ProviderInfo, ResumableRoom, RoomSettings, RoomSummary, RouteDecision, RoutingMode, RosterItem, WorkspaceFile } from "./types.js";
+/**
+ * Build the API surface bound to a given server base URL.
+ *
+ * This is the single place the client talks HTTP to a pipeline-moe server.
+ * It is framework- and host-agnostic: the base URL is injected rather than
+ * read from `import.meta.env`, so the same module serves the web frontend
+ * (passing `import.meta.env.VITE_API_BASE`) and a terminal client (passing
+ * `process.env`). `fetch`/`Response` are assumed to exist in the host (browser,
+ * or Node ≥18).
+ *
+ * @param API_BASE  Server origin, e.g. "http://localhost:5300".
+ * @returns `{ API_BASE, makeRoomApi, api }` — the same shape the web app
+ *          previously imported from its local `api.ts`.
+ */
+export declare function createApi(API_BASE: string): {
+    API_BASE: string;
+    makeRoomApi: (prefix: string) => {
+        roster: () => Promise<RosterItem[]>;
+        savePreset: (name: string) => Promise<PresetFile>;
+        loadPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        applyPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        transcript: () => Promise<Message[]>;
+        workspace: () => Promise<WorkspaceFile[]>;
+        sendMessage: (text: string, images?: string[]) => Promise<{
+            accepted: boolean;
+        }>;
+        setActive: (id: string, active: boolean) => Promise<RosterItem>;
+        setParallel: (id: string, parallel: boolean) => Promise<RosterItem>;
+        kick: (id: string) => Promise<void>;
+        participant: (id: string) => Promise<PersonaDetail>;
+        updateAgent: (id: string, patch: {
+            name?: string;
+            systemPrompt?: string;
+            tools?: string[];
+            color?: string;
+            icon?: string;
+            model?: string | null;
+            thinkingLevel?: string | null;
+            compactionInstructions?: string | null;
+        }) => Promise<RosterItem>;
+        reorder: (order: string[]) => Promise<RosterItem[]>;
+        create: (body: {
+            name: string;
+            systemPrompt: string;
+            tools?: string[];
+            color?: string;
+            icon?: string;
+            id?: string;
+        }) => Promise<RosterItem>;
+        addFromTemplate: (templateId: string) => Promise<RosterItem>;
+        abort: () => Promise<unknown>;
+        steerMessage: (text: string, target: string) => Promise<{
+            ok: boolean;
+            target: string;
+            text: string;
+        }>;
+        compact: (id: string) => Promise<{
+            summary: string;
+            tokensBefore: number;
+        }>;
+        exportAgent: (id: string) => Promise<Blob>;
+        exportAgentJsonl: (id: string) => Promise<Blob>;
+        settings: () => Promise<RoomSettings>;
+        setChaining: (chaining: boolean) => Promise<RoomSettings>;
+        setDefaultAgent: (defaultAgent: string | null) => Promise<RoomSettings>;
+        setFallbackAgent: (fallbackAgent: string | null) => Promise<RoomSettings>;
+        setMaxChainHops: (maxChainHops: number) => Promise<RoomSettings>;
+        setRoutingMode: (routingMode: RoutingMode) => Promise<RoomSettings>;
+        setCircuitBreaker: (circuitBreaker: boolean) => Promise<RoomSettings>;
+        setDefaultThinkingLevel: (defaultThinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh") => Promise<RoomSettings>;
+        setAllowCloud: (allowCloud: boolean) => Promise<RoomSettings>;
+        setCompactionReserveTokens: (compactionReserveTokens: number) => Promise<RoomSettings>;
+        resolveRoute: (decision: RouteDecision) => Promise<unknown>;
+        conversations: () => Promise<{
+            currentId: string;
+            list: ConversationMeta[];
+        }>;
+        newConversation: (title?: string) => Promise<ConversationMeta>;
+        loadConversation: (id: string) => Promise<{
+            ok: boolean;
+        }>;
+        renameConversation: (id: string, title: string) => Promise<{
+            ok: boolean;
+        }>;
+        deleteConversation: (id: string) => Promise<void>;
+    };
+    api: {
+        models: () => Promise<{
+            models: ModelInfo[];
+            allowCloud: boolean;
+        }>;
+        presets: () => Promise<PresetFile[]>;
+        deletePreset: (name: string) => Promise<void>;
+        providers: () => Promise<{
+            providers: ProviderInfo[];
+            explicitlyEnabled: string[];
+        }>;
+        addProvider: (name: string, key: string) => Promise<{
+            name: string;
+            configured: boolean;
+            source?: string;
+            label?: string;
+        }>;
+        removeProvider: (name: string) => Promise<{
+            name: string;
+            configured: boolean;
+            agentsUsing?: string[];
+        }>;
+        loginProvider: (name: string) => Promise<{
+            accepted: boolean;
+            provider: string;
+        }>;
+        personaTemplates: () => Promise<PersonaTemplate[]>;
+        listRooms: () => Promise<RoomSummary[]>;
+        resumableRooms: () => Promise<ResumableRoom[]>;
+        resumeRoom: (roomId: string) => Promise<RoomSummary>;
+        /** Stop a specific room's in-flight pipeline (cancels a running goal). */
+        abortRoom: (roomId: string) => Promise<{
+            aborted: boolean;
+        }>;
+        createRoom: (body: {
+            name: string;
+            roomId?: string;
+            preset?: string;
+            goal?: string;
+            workspaceDir?: string;
+        }) => Promise<RoomSummary>;
+        getRoomDetails: (roomId: string) => Promise<RoomSummary>;
+        destroyRoom: (roomId: string) => Promise<void>;
+        renameRoom: (roomId: string, name: string) => Promise<{
+            roomId: string;
+            name: string;
+        }>;
+        roster: () => Promise<RosterItem[]>;
+        savePreset: (name: string) => Promise<PresetFile>;
+        loadPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        applyPreset: (name: string) => Promise<{
+            ok: boolean;
+            conversation: ConversationMeta;
+            downgraded?: Array<{
+                agent: string;
+                model: string;
+            }>;
+        }>;
+        transcript: () => Promise<Message[]>;
+        workspace: () => Promise<WorkspaceFile[]>;
+        sendMessage: (text: string, images?: string[]) => Promise<{
+            accepted: boolean;
+        }>;
+        setActive: (id: string, active: boolean) => Promise<RosterItem>;
+        setParallel: (id: string, parallel: boolean) => Promise<RosterItem>;
+        kick: (id: string) => Promise<void>;
+        participant: (id: string) => Promise<PersonaDetail>;
+        updateAgent: (id: string, patch: {
+            name?: string;
+            systemPrompt?: string;
+            tools?: string[];
+            color?: string;
+            icon?: string;
+            model?: string | null;
+            thinkingLevel?: string | null;
+            compactionInstructions?: string | null;
+        }) => Promise<RosterItem>;
+        reorder: (order: string[]) => Promise<RosterItem[]>;
+        create: (body: {
+            name: string;
+            systemPrompt: string;
+            tools?: string[];
+            color?: string;
+            icon?: string;
+            id?: string;
+        }) => Promise<RosterItem>;
+        addFromTemplate: (templateId: string) => Promise<RosterItem>;
+        abort: () => Promise<unknown>;
+        steerMessage: (text: string, target: string) => Promise<{
+            ok: boolean;
+            target: string;
+            text: string;
+        }>;
+        compact: (id: string) => Promise<{
+            summary: string;
+            tokensBefore: number;
+        }>;
+        exportAgent: (id: string) => Promise<Blob>;
+        exportAgentJsonl: (id: string) => Promise<Blob>;
+        settings: () => Promise<RoomSettings>;
+        setChaining: (chaining: boolean) => Promise<RoomSettings>;
+        setDefaultAgent: (defaultAgent: string | null) => Promise<RoomSettings>;
+        setFallbackAgent: (fallbackAgent: string | null) => Promise<RoomSettings>;
+        setMaxChainHops: (maxChainHops: number) => Promise<RoomSettings>;
+        setRoutingMode: (routingMode: RoutingMode) => Promise<RoomSettings>;
+        setCircuitBreaker: (circuitBreaker: boolean) => Promise<RoomSettings>;
+        setDefaultThinkingLevel: (defaultThinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh") => Promise<RoomSettings>;
+        setAllowCloud: (allowCloud: boolean) => Promise<RoomSettings>;
+        setCompactionReserveTokens: (compactionReserveTokens: number) => Promise<RoomSettings>;
+        resolveRoute: (decision: RouteDecision) => Promise<unknown>;
+        conversations: () => Promise<{
+            currentId: string;
+            list: ConversationMeta[];
+        }>;
+        newConversation: (title?: string) => Promise<ConversationMeta>;
+        loadConversation: (id: string) => Promise<{
+            ok: boolean;
+        }>;
+        renameConversation: (id: string, title: string) => Promise<{
+            ok: boolean;
+        }>;
+        deleteConversation: (id: string) => Promise<void>;
+    };
+};
+/** The shape returned by {@link createApi} — useful for typing consumers. */
+export type ClientApi = ReturnType<typeof createApi>;
+/** The room-scoped API object (per-room operations). */
+export type RoomApi = ReturnType<ClientApi["makeRoomApi"]>;
+/** The full API object (room-scoped default + process-global operations). */
+export type Api = ClientApi["api"];

package/dist/api.js

@@ -0,0 +1,216 @@
+async function json(res) {
+    if (!res.ok) {
+        let detail = "";
+        try {
+            const body = (await res.json());
+            detail = body.error ?? "";
+        }
+        catch {
+            /* ignore */
+        }
+        throw new Error(detail || `${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+/**
+ * Build the API surface bound to a given server base URL.
+ *
+ * This is the single place the client talks HTTP to a pipeline-moe server.
+ * It is framework- and host-agnostic: the base URL is injected rather than
+ * read from `import.meta.env`, so the same module serves the web frontend
+ * (passing `import.meta.env.VITE_API_BASE`) and a terminal client (passing
+ * `process.env`). `fetch`/`Response` are assumed to exist in the host (browser,
+ * or Node ≥18).
+ *
+ * @param API_BASE  Server origin, e.g. "http://localhost:5300".
+ * @returns `{ API_BASE, makeRoomApi, api }` — the same shape the web app
+ *          previously imported from its local `api.ts`.
+ */
+export function createApi(API_BASE) {
+    /**
+     * Create a room-scoped API object for the given route prefix.
+     * Use prefix "/api" for the default room (backward compat).
+     * Use "/api/rooms/:roomId" for non-default rooms.
+     */
+    function makeRoomApi(prefix) {
+        const base = `${API_BASE}${prefix}`;
+        return {
+            roster: () => fetch(`${base}/participants`).then((r) => json(r)),
+            // Preset save/load/apply target THIS room (the prefix), so loading from the
+            // second room's view doesn't clobber the default room.
+            savePreset: (name) => fetch(`${base}/presets`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name }),
+            }).then((r) => json(r)),
+            loadPreset: (name) => fetch(`${base}/presets/${name}/load`, { method: "POST" }).then((r) => json(r)),
+            applyPreset: (name) => fetch(`${base}/presets/${name}/apply`, { method: "POST" }).then((r) => json(r)),
+            transcript: () => fetch(`${base}/transcript`).then((r) => json(r)),
+            workspace: () => fetch(`${base}/workspace`).then((r) => json(r)),
+            sendMessage: (text, images) => fetch(`${base}/messages`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ text, ...(images && images.length > 0 ? { images } : {}) }),
+            }).then((r) => json(r)),
+            setActive: (id, active) => fetch(`${base}/participants/${id}`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ active }),
+            }).then((r) => json(r)),
+            setParallel: (id, parallel) => fetch(`${base}/participants/${id}`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ parallel }),
+            }).then((r) => json(r)),
+            kick: (id) => fetch(`${base}/participants/${id}`, { method: "DELETE" }).then((r) => {
+                if (!r.ok && r.status !== 204)
+                    throw new Error(`${r.status}`);
+            }),
+            participant: (id) => fetch(`${base}/participants/${id}`).then((r) => json(r)),
+            updateAgent: (id, patch) => fetch(`${base}/participants/${id}`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(patch),
+            }).then((r) => json(r)),
+            reorder: (order) => fetch(`${base}/participants/reorder`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ order }),
+            }).then((r) => json(r)),
+            create: (body) => fetch(`${base}/participants`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            }).then((r) => json(r)),
+            addFromTemplate: (templateId) => fetch(`${base}/participants/from-template`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ templateId }),
+            }).then((r) => json(r)),
+            abort: () => fetch(`${base}/abort`, { method: "POST" }).then((r) => json(r)),
+            steerMessage: (text, target) => fetch(`${base}/messages/steer`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ text, target }),
+            }).then((r) => json(r)),
+            compact: (id) => fetch(`${base}/participants/${id}/compact`, { method: "POST" }).then((r) => json(r)),
+            exportAgent: (id) => fetch(`${base}/participants/${id}/export`).then((r) => r.blob()),
+            exportAgentJsonl: (id) => fetch(`${base}/participants/${id}/export-jsonl`).then((r) => r.blob()),
+            settings: () => fetch(`${base}/settings`).then((r) => json(r)),
+            setChaining: (chaining) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ chaining }),
+            }).then((r) => json(r)),
+            setDefaultAgent: (defaultAgent) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ defaultAgent }),
+            }).then((r) => json(r)),
+            setFallbackAgent: (fallbackAgent) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ fallbackAgent }),
+            }).then((r) => json(r)),
+            setMaxChainHops: (maxChainHops) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ maxChainHops }),
+            }).then((r) => json(r)),
+            setRoutingMode: (routingMode) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ routingMode }),
+            }).then((r) => json(r)),
+            setCircuitBreaker: (circuitBreaker) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ circuitBreaker }),
+            }).then((r) => json(r)),
+            setDefaultThinkingLevel: (defaultThinkingLevel) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ defaultThinkingLevel }),
+            }).then((r) => json(r)),
+            setAllowCloud: (allowCloud) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ allowCloud }),
+            }).then((r) => json(r)),
+            setCompactionReserveTokens: (compactionReserveTokens) => fetch(`${base}/settings`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ compactionReserveTokens }),
+            }).then((r) => json(r)),
+            resolveRoute: (decision) => fetch(`${base}/route`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(decision),
+            }).then((r) => json(r)),
+            conversations: () => fetch(`${base}/conversations`).then((r) => json(r)),
+            newConversation: (title) => fetch(`${base}/conversations`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(title ? { title } : {}),
+            }).then((r) => json(r)),
+            loadConversation: (id) => fetch(`${base}/conversations/${id}/load`, { method: "POST" }).then((r) => json(r)),
+            renameConversation: (id, title) => fetch(`${base}/conversations/${id}`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ title }),
+            }).then((r) => json(r)),
+            deleteConversation: (id) => fetch(`${base}/conversations/${id}`, { method: "DELETE" }).then((r) => {
+                if (!r.ok && r.status !== 204)
+                    throw new Error(`${r.status}`);
+            }),
+        };
+    }
+    const api = {
+        // Room-scoped operations via the default /api prefix (backward compat).
+        ...makeRoomApi("/api"),
+        // ── Models (process-global) ─────────────────────────────────────────────
+        models: () => fetch(`${API_BASE}/api/models`).then((r) => json(r)),
+        // ── Presets (process-global) ────────────────────────────────────────────
+        presets: () => fetch(`${API_BASE}/api/presets`).then((r) => json(r)),
+        deletePreset: (name) => fetch(`${API_BASE}/api/presets/${name}`, { method: "DELETE" }).then((r) => {
+            if (!r.ok && r.status !== 204)
+                throw new Error(`${r.status}`);
+        }),
+        // ── Providers (process-global) ──────────────────────────────────────────
+        providers: () => fetch(`${API_BASE}/api/providers`).then((r) => json(r)),
+        addProvider: (name, key) => fetch(`${API_BASE}/api/providers/${name}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key }),
+        }).then((r) => json(r)),
+        removeProvider: (name) => fetch(`${API_BASE}/api/providers/${name}`, { method: "DELETE" }).then((r) => json(r)),
+        loginProvider: (name) => fetch(`${API_BASE}/api/providers/${name}/login`, { method: "POST" }).then((r) => json(r)),
+        // ── Room CRUD (process-global) ──────────────────────────────────────────
+        personaTemplates: () => fetch(`${API_BASE}/api/persona-templates`).then((r) => json(r)),
+        listRooms: () => fetch(`${API_BASE}/api/rooms`).then((r) => json(r)),
+        resumableRooms: () => fetch(`${API_BASE}/api/rooms/resumable`).then((r) => json(r)),
+        resumeRoom: (roomId) => fetch(`${API_BASE}/api/rooms/${roomId}/resume`, { method: "POST" }).then((r) => json(r)),
+        /** Stop a specific room's in-flight pipeline (cancels a running goal). */
+        abortRoom: (roomId) => fetch(`${API_BASE}/api/rooms/${roomId}/abort`, { method: "POST" }).then((r) => json(r)),
+        createRoom: (body) => fetch(`${API_BASE}/api/rooms`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        }).then((r) => json(r)),
+        getRoomDetails: (roomId) => fetch(`${API_BASE}/api/rooms/${roomId}`).then((r) => json(r)),
+        destroyRoom: (roomId) => fetch(`${API_BASE}/api/rooms/${roomId}`, { method: "DELETE" }).then((r) => {
+            if (!r.ok && r.status !== 204)
+                throw new Error(`${r.status}`);
+        }),
+        renameRoom: (roomId, name) => fetch(`${API_BASE}/api/rooms/${roomId}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name }),
+        }).then((r) => {
+            if (!r.ok)
+                throw new Error(`${r.status}`);
+            return json(r);
+        }),
+    };
+    return { API_BASE, makeRoomApi, api };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export { createApi } from "./api.js";
+export type { ClientApi, RoomApi, Api } from "./api.js";
+export { initialRoomState, resetTransient, reduce, SSE_EVENT_NAMES, } from "./state.js";
+export type { RoomState, Notice, ThinkingLevel, SseEvent, SseEventName, Effect, ReduceResult, } from "./state.js";
+export { createRoomStore, browserEventSourceFactory } from "./store.js";
+export type { RoomStore, RoomStoreOptions, EventSourceFactory, SseConnection, SseHandlers, } from "./store.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+// @pipeline-moe/client-core — framework-agnostic client for a pipeline-moe
+// server: the typed REST surface, the shared domain types, the pure SSE
+// reducer, and the effectful room store. Both the web frontend and a terminal
+// client consume this one protocol implementation.
+export * from "./types.js";
+export { createApi } from "./api.js";
+export { initialRoomState, resetTransient, reduce, SSE_EVENT_NAMES, } from "./state.js";
+export { createRoomStore, browserEventSourceFactory } from "./store.js";

package/dist/state.d.ts

@@ -0,0 +1,78 @@
+import type { ConversationMeta, Message, OAuthProgress, ProviderInfo, Receipt, RosterItem, RouteProposal, RoutingMode, ToolActivity, WorkspaceFile } from "./types.js";
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+/** A transient toast. `id` is assigned by the store, not the reducer. */
+export interface Notice {
+    id: number;
+    msg: string;
+    level: "info" | "error";
+}
+/** The complete observable state of one room. */
+export interface RoomState {
+    roster: RosterItem[];
+    messages: Message[];
+    /** In-flight text deltas, keyed by agent id (cleared when the message lands). */
+    streaming: Record<string, string>;
+    /** In-flight tool calls of running agents, keyed by agent id. */
+    liveActivity: Record<string, ToolActivity[]>;
+    /** In-flight reasoning deltas, keyed by agent id. */
+    liveReasoning: Record<string, string>;
+    /** Filesystem receipts, keyed by the transcript index of the owning message. */
+    receipts: Record<number, Receipt>;
+    workspace: WorkspaceFile[];
+    notices: Notice[];
+    connected: boolean;
+    turnActive: boolean;
+    runningAgentId: string | null;
+    paused: boolean;
+    pausedQuestion: string | null;
+    pausedAskerId: string | null;
+    chaining: boolean;
+    routingMode: RoutingMode;
+    defaultAgent: string | null;
+    fallbackAgent: string | null;
+    maxChainHops: number;
+    circuitBreaker: boolean;
+    defaultThinkingLevel: ThinkingLevel;
+    allowCloud: boolean;
+    compactionReserveTokens: number;
+    pendingRoute: RouteProposal[] | null;
+    maxRooms: number;
+    conversations: ConversationMeta[];
+    currentConversationId: string;
+    providers: ProviderInfo[];
+    explicitlyEnabled: string[];
+    /** In-flight OAuth login flow, or null. Persists until success/error/dismiss. */
+    oauthProgress: OAuthProgress | null;
+}
+/** The initial state of a freshly-opened room, before any snapshot or SSE. */
+export declare const initialRoomState: RoomState;
+/**
+ * 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 declare function resetTransient(state: RoomState): RoomState;
+/** The named SSE events a room client subscribes to. */
+export declare const SSE_EVENT_NAMES: readonly ["roster", "status", "token", "activity", "reasoning", "message", "receipt", "workspace", "notice", "turn", "settings", "routing", "transcript", "conversations", "providers", "oauth_progress"];
+export type SseEventName = (typeof SSE_EVENT_NAMES)[number];
+/** A parsed SSE event: its name plus the JSON-decoded payload. */
+export interface SseEvent {
+    name: SseEventName;
+    data: unknown;
+}
+/** A side effect the store must apply (currently only transient notices). */
+export type Effect = {
+    type: "notice";
+    msg: string;
+    level: "info" | "error";
+};
+export interface ReduceResult {
+    state: RoomState;
+    effects: Effect[];
+}
+/**
+ * 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 declare function reduce(state: RoomState, event: SseEvent): ReduceResult;