@wrongstack/webui 1.0.19 → 1.0.26

package/dist/components/use-office-map-canvas.d.ts

@@ -0,0 +1,42 @@
+import { type Connection, type Edge, type Node } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import type { OfficeNodeData } from './OfficeMapCanvas/utils.js';
+export declare function useOfficeMapCanvas(): {
+    canvasRef: import("react").RefObject<HTMLDivElement | null>;
+    showHud: boolean;
+    t: import("i18next").TFunction<"translation", undefined>;
+    showLegend: boolean;
+    nodes: Node<OfficeNodeData>[];
+    edges: Edge[];
+    onNodesChange: import("@xyflow/react").OnNodesChange<Node<OfficeNodeData>>;
+    onEdgesChange: import("@xyflow/react").OnEdgesChange<Edge>;
+    onConnect: (params: Connection) => void;
+    onNodeClick: (_: React.MouseEvent, node: Node) => void;
+    onPaneClick: () => void;
+    broadcastOpen: boolean;
+    onArrange: () => void;
+    setBroadcastOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setShowFeed: (v: boolean) => void;
+    showFeed: boolean;
+    background: import("@/stores").BackgroundStyle;
+    showControls: boolean;
+    showMinimap: boolean;
+    vizEvents: import("@/stores").VizEvent[];
+    broadcastDraft: string;
+    broadcasting: boolean;
+    broadcastResult: string | null;
+    setBroadcastDraft: import("react").Dispatch<import("react").SetStateAction<string>>;
+    sendBroadcast: () => Promise<void>;
+    selectedNode: Node<OfficeNodeData> | null;
+    selectedAgentTranscript: import("@/stores").AgentTranscriptEntry[];
+    mailboxMessages: import("@/stores").MailboxMessage[];
+    setWatch: import("react").Dispatch<import("react").SetStateAction<{
+        sessionId: string;
+        label: string;
+    } | null>>;
+    watch: {
+        sessionId: string;
+        label: string;
+    } | null;
+};
+//# sourceMappingURL=use-office-map-canvas.d.ts.map

package/dist/components/use-office-map-topology.d.ts

@@ -0,0 +1,31 @@
+import type { TFunction } from 'i18next';
+import '@xyflow/react/dist/style.css';
+export declare function useOfficeMapTopology({ clients, canvasSize, mailboxMessages, t, leaderId, fleetAgents, prevAgentStatsRef, activeNodesRef, ACTIVE_MS, vizActivityRef, edgeIntensitiesRef, layoutPosRef, setNodes, setEdges, prevNodeSigRef, fitView, session, }: {
+    clients: import('./OfficeMapCanvas/resolve.js').ResolvedClient[];
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    mailboxMessages: import('../stores/mailbox-store.js').MailboxMessage[];
+    t: TFunction<'translation', undefined>;
+    leaderId: string | undefined;
+    fleetAgents: Map<string, import('../stores/types.js').SubagentView>;
+    prevAgentStatsRef: React.RefObject<Map<string, {
+        toolCalls: number;
+        iteration: number;
+    }>>;
+    activeNodesRef: React.RefObject<Map<string, number>>;
+    ACTIVE_MS: 4000;
+    vizActivityRef: React.RefObject<Map<string, number>>;
+    edgeIntensitiesRef: React.RefObject<Map<string, number>>;
+    layoutPosRef: React.RefObject<Map<string, {
+        x: number;
+        y: number;
+    }>>;
+    setNodes: React.Dispatch<React.SetStateAction<import('@xyflow/react').Node<import('./OfficeMapCanvas/utils.js').OfficeNodeData>[]>>;
+    setEdges: React.Dispatch<React.SetStateAction<import('@xyflow/react').Edge[]>>;
+    prevNodeSigRef: React.RefObject<string>;
+    fitView: import('@xyflow/react').FitView<import('@xyflow/react').Node>;
+    session: import('../stores/types.js').SessionInfo | null;
+}): void;
+//# sourceMappingURL=use-office-map-topology.d.ts.map

package/dist/components/use-skill-detail.d.ts

@@ -0,0 +1,177 @@
+export declare function useSkillDetail({ className }: {
+    className?: string;
+}): {
+    selectedSkill: {
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    } | null;
+    t: import("i18next").TFunction<"translation", undefined>;
+    handleClose: () => void;
+    className: string | undefined;
+    handleCopySourceUrl: () => void;
+    copiedSourceUrl: boolean;
+    updateResult: {
+        updated: Array<{
+            name: string;
+            oldRef: string;
+            newRef: string;
+        }>;
+        unchanged: string[];
+        errors: Array<{
+            name: string;
+            error: string;
+        }>;
+    } | null;
+    handleCheckForUpdates: () => void;
+    checkingForUpdates: boolean;
+    editMode: boolean;
+    handleExportSkill: () => void;
+    handleStartEdit: () => void;
+    setUninstallConfirmSkill: import("react").Dispatch<import("react").SetStateAction<{
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    } | null>>;
+    navHistory: {
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    }[];
+    handleBreadcrumbBack: () => void;
+    historyIndex: number;
+    handleBreadcrumbForward: () => void;
+    isNavigatingBack: import("react").RefObject<boolean>;
+    setSkillsState: (state: import("@/stores/ui-store").UIState['skillsState']) => void;
+    skillsStateRef: import("react").RefObject<{
+        selectedSkill: {
+            name: string;
+            description: string;
+            version: string;
+            source: string;
+            sourceUrl: string;
+            ref: string;
+            path: string;
+            trigger: string;
+            scope: string[];
+        } | null;
+        navHistory: {
+            name: string;
+            description: string;
+            version: string;
+            source: string;
+            sourceUrl: string;
+            ref: string;
+            path: string;
+            trigger: string;
+            scope: string[];
+        }[];
+        historyIndex: number;
+        detailOpen: boolean;
+        knownRefs: Record<string, string>;
+        updateAvailableCount: number;
+    }>;
+    setEditMode: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setEditContent: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setUpdateResult: import("react").Dispatch<import("react").SetStateAction<{
+        updated: Array<{
+            name: string;
+            oldRef: string;
+            newRef: string;
+        }>;
+        unchanged: string[];
+        errors: Array<{
+            name: string;
+            error: string;
+        }>;
+    } | null>>;
+    skillContent: SkillContent | null;
+    findSkillByName: (name: string) => {
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    } | undefined;
+    handleNavigateToSkill: (name: string) => void;
+    contentLoading: boolean;
+    editStats: {
+        lines: number;
+        words: number;
+        chars: number;
+    };
+    charsWarning: {
+        level: 'warn' | 'critical';
+        used: number;
+        limit: number;
+    } | null;
+    draftSavedAt: number | null;
+    draftRestored: boolean;
+    editError: string | null;
+    handleDiscardDraft: () => void;
+    handleCancelEdit: () => void;
+    setSplitPreview: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    splitPreview: boolean;
+    handleSaveEdit: () => void;
+    editSaving: boolean;
+    editContent: string;
+    skillScrollRef: import("react").RefObject<HTMLDivElement | null>;
+    contentError: string | null;
+    client: import("../lib").WrongStackWebSocketClient;
+    setContentLoading: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setContentError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    uninstallConfirmSkill: {
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    } | null;
+    uninstalling: boolean;
+    handleUninstallSkill: (skill: {
+        name: string;
+        description: string;
+        version: string;
+        source: string;
+        sourceUrl: string;
+        ref: string;
+        path: string;
+        trigger: string;
+        scope: string[];
+    } | null) => Promise<void>;
+};
+export interface SkillContent {
+    name: string;
+    body: string;
+    path: string;
+    source: string;
+    relatedFiles: string[];
+    references: string[];
+}
+//# sourceMappingURL=use-skill-detail.d.ts.map

package/dist/components/vector-memory-panel/model.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Vector Memory panel — minimal visibility surface for the WebUI.
+ *
+ * Fetches `/api/vector-memory/status` and `/api/vector-memory/search` to
+ * show the active store/provider, model cache location, entry counts, and
+ * a search UI with ranked results. When the route is disabled (the
+ * webui-server host doesn't wire a vector store), the panel renders a
+ * disabled placeholder.
+ */
 interface VectorMemoryCacheStats {
     entries: number;
     providers: number;

package/dist/hooks/use-live-browser.d.ts

@@ -0,0 +1,7 @@
+export interface LiveBrowserSession {
+    id: string;
+    url: string;
+    title: string;
+}
+export declare function useLiveBrowserSessions(): LiveBrowserSession[];
+//# sourceMappingURL=use-live-browser.d.ts.map

package/dist/hooks/useProviderModels.d.ts

@@ -1,5 +1,7 @@
 export interface ModelCandidate {
     provider: string;
+    /** Catalog provider type; `provider` remains the auth profile alias. */
+    providerType?: string | undefined;
     model: string;
     label: string;
     description?: string | undefined;

package/dist/hooks/useWebSocket.d.ts

@@ -21,17 +21,17 @@ export declare function useWebSocketBootstrap(): void;
 export declare function useWebSocket(): {
     client: WrongStackWebSocketClient;
     sendMessage: (content: string, images?: import('@/types').WSUserMessageImage[], freshContext?: boolean) => string | null;
-    adviseTopic: (prompt: string) => Promise<import("@/types").SessionScopedPayload & {
+    adviseTopic: (prompt: string) => Promise<import("@wrongstack/webui-protocol").SessionScopedPayload & {
         requestId: string;
         suggestNewContext: boolean;
         confidence: number;
         reason: string;
         nextTopic?: string | undefined;
-        source: 'explicit' | 'model' | 'cache' | 'local';
+        source: 'explicit' | 'model' | 'system-one' | 'cache' | 'local';
     }>;
     sendAbort: () => void;
     sendMailboxMessage: (opts: Parameters<(opts: import("@/lib/ws-client").WSMailboxSendOptions, sessionId?: string | undefined) => string>[0]) => string;
-    sendConfirm: (id: string, decision: 'yes' | 'no' | 'always' | 'deny') => void;
+    sendConfirm: (id: string, decision: 'yes' | 'no' | 'always' | 'always-exact' | 'always-command' | 'always-tool' | 'deny') => void;
     switchModel: (provider: string, model: string) => Promise<{
         requestId?: string | undefined;
         success: boolean;
@@ -49,7 +49,7 @@ export declare function useWebSocket(): {
     updateKey: (providerId: string, label: string, apiKey: string) => void;
     deleteKey: (providerId: string, label: string) => void;
     setActiveKey: (providerId: string, label: string) => void;
-    addProvider: (id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, ProviderCustomModelWire> | undefined) => void;
+    addProvider: (id: string, family: string, baseUrl?: string | undefined, apiKey?: string, models?: string[] | undefined, customModels?: Record<string, ProviderCustomModelWire> | undefined, providerType?: string | undefined) => void;
     removeProvider: (providerId: string) => void;
     listSessions: (limit?: number) => void;
     deleteSession: (id: string) => void;
@@ -131,7 +131,6 @@ export declare function useWebSocket(): {
     }) => void;
     deleteContextMode: (id: string) => void;
     repairContext: () => void;
-    toggleGoalAutonomous: (autonomous: boolean) => void;
     startGoal: (title: string, phases?: unknown[] | undefined, autonomous?: boolean) => void;
     pauseGoal: () => void;
     resumeGoal: () => void;

package/dist/hooks/ws-handlers/brain-handlers.d.ts

@@ -0,0 +1,18 @@
+import type { WSServerMessage } from '@/types';
+export declare function handleBrainStatus(msg: WSServerMessage): void;
+export declare function handleBrainAnswer(msg: WSServerMessage): void;
+/**
+ * Council seat votes are NOT buffered here: the council log store already
+ * tracks each panel's seats per request id (deduped by seat id, retained as
+ * whole panels in its ring buffer). `brain.council_vote` fires once per seat
+ * and `brain.council_resolved` once per panel, both from inside
+ * `council.decide()`. Both reached the browser and were dropped on the
+ * floor, so the most expensive Brain tier — one provider call per seat — was
+ * completely invisible in the UI. The resolved handler reads the panel's
+ * seats back from the store, so vote eviction is per-panel (per-request): a
+ * live panel's seats can never be dropped by other requests' vote traffic
+ * (the old global 50-vote buffer could). Whole panels still age out of the
+ * store's ring buffer, which is the intended log retention.
+ */
+export declare function handleBrainEvent(msg: WSServerMessage): void;
+//# sourceMappingURL=brain-handlers.d.ts.map

package/dist/hooks/ws-handlers/goal-handlers.d.ts

@@ -0,0 +1,9 @@
+import type { WSServerMessage } from '@/types';
+export declare function handleGoalState(msg: WSServerMessage): void;
+export declare function handleGoalProgress(msg: WSServerMessage): void;
+export declare function handleGoalLifecycle(msg: WSServerMessage): void;
+export declare function handleGoalList(msg: WSServerMessage): void;
+export declare function handleGoalUpdated(msg: WSServerMessage): void;
+export declare function handleGoalRefining(msg: WSServerMessage): void;
+export declare function handleGoalStateError(msg: WSServerMessage): void;
+//# sourceMappingURL=goal-handlers.d.ts.map

package/dist/hooks/ws-handlers/misc-handlers.d.ts

@@ -1,27 +1,6 @@
 import type { WSServerMessage } from '@/types';
-export declare function handleGoalState(msg: WSServerMessage): void;
-export declare function handleGoalProgress(msg: WSServerMessage): void;
-export declare function handleGoalLifecycle(msg: WSServerMessage): void;
-export declare function handleGoalList(msg: WSServerMessage): void;
-export declare function handleGoalUpdated(msg: WSServerMessage): void;
 export declare function handlePrefsUpdated(msg: WSServerMessage): void;
 export declare function handleSystemPromptInfo(msg: WSServerMessage): void;
-export declare function handleBrainStatus(msg: WSServerMessage): void;
-export declare function handleBrainAnswer(msg: WSServerMessage): void;
-/**
- * Council seat votes are NOT buffered here: the council log store already
- * tracks each panel's seats per request id (deduped by seat id, retained as
- * whole panels in its ring buffer). `brain.council_vote` fires once per seat
- * and `brain.council_resolved` once per panel, both from inside
- * `council.decide()`. Both reached the browser and were dropped on the
- * floor, so the most expensive Brain tier — one provider call per seat — was
- * completely invisible in the UI. The resolved handler reads the panel's
- * seats back from the store, so vote eviction is per-panel (per-request): a
- * live panel's seats can never be dropped by other requests' vote traffic
- * (the old global 50-vote buffer could). Whole panels still age out of the
- * store's ring buffer, which is the intended log retention.
- */
-export declare function handleBrainEvent(msg: WSServerMessage): void;
 export declare function handleMemoryEvent(msg: WSServerMessage): void;
 export declare function handleCollabEvent(msg: WSServerMessage): void;
 export declare function handleCollabInjectionGranted(msg: WSServerMessage): void;
@@ -56,4 +35,6 @@ export declare function handleChimeraReportAvailable(msg: WSServerMessage): void
  */
 export declare function handleChimeraReports(msg: WSServerMessage): void;
 export declare const miscHandlerMap: Partial<Record<string, (msg: WSServerMessage) => void>>;
+export { handleBrainAnswer, handleBrainEvent, handleBrainStatus } from './brain-handlers.js';
+export { handleGoalLifecycle, handleGoalList, handleGoalProgress, handleGoalState, handleGoalUpdated, } from './goal-handlers.js';
 //# sourceMappingURL=misc-handlers.d.ts.map

package/dist/hooks/ws-handlers/prompt-queue-handlers.d.ts

@@ -0,0 +1,18 @@
+import type { WSServerMessage } from '@/types';
+export declare function removeServerQueuedPrompt(sessionId: string, id: string): void;
+export declare function clearServerQueue(sessionId: string): void;
+/**
+ * Ask for a session's queue when the session starts on this connection — the
+ * moment the capability is known. Opening the session is also the server's cue
+ * to run whatever a previous host left queued.
+ */
+export declare function requestPromptQueue(msg: WSServerMessage): void;
+declare function handleQueueState(msg: WSServerMessage): void;
+/** A queued prompt started its turn: it becomes the user's message in the transcript. */
+declare function handleQueueDrained(msg: WSServerMessage): void;
+export declare const promptQueueHandlerMap: {
+    'queue.state': typeof handleQueueState;
+    'queue.drained': typeof handleQueueDrained;
+};
+export {};
+//# sourceMappingURL=prompt-queue-handlers.d.ts.map