@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/apps/client/src/components/knowledge-base/components/TabContent.d.ts

@@ -0,0 +1,8 @@
+import './TabContent.scss';
+import type { ReactNode } from 'react';
+interface TabContentProps {
+    children: ReactNode;
+    className?: string;
+}
+export declare function TabContent({ children, className }: TabContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/knowledge-base/components/TabContent.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './TabContent.scss';
+export function TabContent({ children, className }) {
+    const mergedClassName = ['knowledge-base-view__content', className].filter(Boolean).join(' ');
+    return (_jsx("div", { className: mergedClassName, children: children }));
+}

package/dist/apps/client/src/components/knowledge-base/components/TabLabel.d.ts

@@ -0,0 +1,7 @@
+import './TabLabel.scss';
+interface TabLabelProps {
+    icon: string;
+    label: string;
+}
+export declare function TabLabel({ icon, label }: TabLabelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/knowledge-base/components/TabLabel.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './TabLabel.scss';
+export function TabLabel({ icon, label }) {
+    return (_jsxs("span", { className: 'knowledge-base-view__tab-label', children: [_jsx("span", { className: 'material-symbols-rounded knowledge-base-view__tab-icon', children: icon }), _jsx("span", { children: label })] }));
+}

package/dist/apps/client/src/components/knowledge-base/index.d.ts

@@ -0,0 +1 @@
+export { KnowledgeBaseView } from './KnowledgeBaseView.js';

package/dist/apps/client/src/components/knowledge-base/index.js

@@ -0,0 +1 @@
+export { KnowledgeBaseView } from './KnowledgeBaseView.js';

package/dist/apps/client/src/components/layout/AppShell.d.ts

@@ -0,0 +1,13 @@
+import './AppShell.scss';
+import type { PropsWithChildren } from 'react';
+import type { Session } from '@vibe-forge/core';
+type AppShellProps = PropsWithChildren<{
+    activeSessionId?: string;
+    isDarkMode: boolean;
+    onDeletedSession: (deletedId: string, nextId?: string) => void;
+    onSelectSession: (session: Session, isNew?: boolean) => void;
+    showSidebar: boolean;
+    sidebarWidth: number;
+}>;
+export declare function AppShell({ activeSessionId, children, isDarkMode, onDeletedSession, onSelectSession, showSidebar, sidebarWidth }: AppShellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/layout/AppShell.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './AppShell.scss';
+import { Layout } from 'antd';
+import { NavRail } from '#~/components/NavRail';
+import { Sidebar } from '#~/components/Sidebar';
+export function AppShell({ activeSessionId, children, isDarkMode, onDeletedSession, onSelectSession, showSidebar, sidebarWidth }) {
+    return (_jsxs(Layout, { className: `app-shell ${isDarkMode ? 'app-shell--dark' : ''}`, children: [_jsx(NavRail, {}), showSidebar && (_jsx(Sidebar, { width: sidebarWidth, activeId: activeSessionId, onSelectSession: onSelectSession, onDeletedSession: onDeletedSession })), _jsx(Layout.Content, { className: 'app-shell__content', children: children })] }));
+}

package/dist/apps/client/src/components/sidebar/SessionItem.d.ts

@@ -0,0 +1,17 @@
+import './SessionItem.scss';
+import type { Session } from '@vibe-forge/core';
+import 'dayjs/locale/zh-cn';
+interface SessionItemProps {
+    session: Session;
+    isActive: boolean;
+    isBatchMode: boolean;
+    isSelected: boolean;
+    onSelect: (session: Session) => void;
+    onArchive: (id: string) => void | Promise<void>;
+    onDelete: (id: string) => void | Promise<void>;
+    onStar: (id: string, isStarred: boolean) => void | Promise<void>;
+    onUpdateTags: (id: string, tags: string[]) => void | Promise<void>;
+    onToggleSelect: (id: string) => void;
+}
+export declare function SessionItem({ session, isActive, isBatchMode, isSelected, onSelect, onArchive, onDelete, onStar, onUpdateTags, onToggleSelect }: SessionItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/sidebar/SessionItem.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './SessionItem.scss';
+import { Badge, Button, Checkbox, List, Tag, Tooltip } from 'antd';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import React, { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import 'dayjs/locale/zh-cn';
+dayjs.extend(relativeTime);
+export function SessionItem({ session, isActive, isBatchMode, isSelected, onSelect, onArchive, onDelete, onStar, onUpdateTags, onToggleSelect }) {
+    const { t, i18n } = useTranslation();
+    const [isAddingTag, setIsAddingTag] = React.useState(false);
+    const [newTag, setNewTag] = React.useState('');
+    const automationPrefix = 'automation:';
+    const timeDisplay = useMemo(() => {
+        const d = dayjs(session.createdAt);
+        if (i18n.language === 'zh') {
+            d.locale('zh-cn');
+        }
+        else {
+            d.locale('en');
+        }
+        return {
+            relative: d.fromNow(),
+            full: d.format('YYYY-MM-DD HH:mm:ss')
+        };
+    }, [session.createdAt, i18n.language]);
+    const displayTitle = (session.title != null && session.title !== '')
+        ? session.title
+        : (session.lastUserMessage != null && session.lastUserMessage !== '')
+            ? session.lastUserMessage
+            : t('common.newChat');
+    const messageCount = session.messageCount ?? 0;
+    const lastMessageSnippet = useMemo(() => {
+        if (session.lastMessage == null || session.lastMessage === '')
+            return null;
+        return session.lastMessage.length > 60 ? `${session.lastMessage.slice(0, 60)}...` : session.lastMessage;
+    }, [session.lastMessage]);
+    const parseAutomationTag = useMemo(() => {
+        return (tag) => {
+            if (!tag.startsWith(automationPrefix))
+                return null;
+            const parts = tag.split(':');
+            if (parts.length < 3)
+                return null;
+            return {
+                ruleId: parts[1],
+                ruleTitle: parts.slice(2).join(':')
+            };
+        };
+    }, [automationPrefix]);
+    const getStatusIcon = (status) => {
+        if (!status) {
+            return _jsx("div", { className: `status-dot ${isActive ? 'active' : ''}` });
+        }
+        let icon = '';
+        let color = '';
+        const title = t(`common.status.${status}`);
+        switch (status) {
+            case 'completed':
+                icon = 'check_circle';
+                color = '#52c41a'; // Green
+                break;
+            case 'terminated':
+                icon = 'remove_circle';
+                color = '#bfbfbf'; // Grey
+                break;
+            case 'failed':
+                icon = 'cancel';
+                color = '#ff4d4f'; // Red
+                break;
+            case 'running':
+                icon = 'sync';
+                color = '#1890ff'; // Blue
+                break;
+            case 'waiting_input':
+                return (_jsx(Tooltip, { title: title, children: _jsx("div", { className: 'waiting-input-indicator' }) }));
+            default:
+                return _jsx("div", { className: `status-dot ${isActive ? 'active' : ''}` });
+        }
+        return (_jsx(Tooltip, { title: title, children: _jsx("span", { className: `material-symbols-rounded status-icon ${status === 'running' ? 'spin' : ''}`, style: {
+                    color,
+                    fontSize: '16px',
+                    lineHeight: '16px',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center'
+                }, children: icon }) }));
+    };
+    return (_jsxs(List.Item, { onClick: () => isBatchMode ? onToggleSelect(session.id) : onSelect(session), onDoubleClick: () => {
+            // eslint-disable-next-line no-console
+            console.log('Session Details:', session);
+        }, className: `session-item ${isActive ? 'active' : ''} ${isSelected ? 'selected' : ''} ${session.isStarred ? 'starred' : ''}`, children: [_jsxs("div", { className: 'session-item-content', children: [!isBatchMode && (_jsx("div", { className: 'status-indicator', children: getStatusIcon(session.status) })), isBatchMode && (_jsx("div", { className: 'batch-checkbox-wrapper', children: _jsx(Checkbox, { checked: isSelected, onChange: () => onToggleSelect(session.id), onClick: (e) => e.stopPropagation() }) })), _jsxs("div", { className: `session-info ${isBatchMode ? '' : 'with-actions'}`, children: [_jsxs("div", { className: 'session-header', children: [_jsx("div", { className: 'session-title', children: _jsx("span", { className: 'session-title-text', children: displayTitle }) }), !isBatchMode && (_jsxs("div", { className: 'session-item-actions', children: [_jsx(Tooltip, { title: session.isStarred ? t('common.unstar') : t('common.star'), children: _jsx(Button, { type: 'text', size: 'small', className: `action-btn ${session.isStarred ? 'starred' : ''}`, onClick: (e) => {
+                                                        e.stopPropagation();
+                                                        void onStar(session.id, !session.isStarred);
+                                                    }, icon: _jsx("span", { className: `material-symbols-rounded ${session.isStarred ? 'filled' : ''}`, children: "star" }) }) }), _jsx(Tooltip, { title: t('common.archive'), children: _jsx(Button, { type: 'text', size: 'small', className: 'action-btn archive-btn', onClick: (e) => {
+                                                        e.stopPropagation();
+                                                        void onArchive(session.id);
+                                                    }, icon: _jsx("span", { className: 'material-symbols-rounded', children: "archive" }) }) })] }))] }), lastMessageSnippet != null && (_jsx("div", { className: 'last-message', children: lastMessageSnippet })), _jsxs("div", { className: 'session-meta', children: [session.status && (_jsx("span", { className: 'status-text', style: { fontSize: '11px', color: 'var(--sub-text-color)', marginRight: '8px' }, children: t(`common.status.${session.status}`) })), _jsx(Tooltip, { title: timeDisplay.full, children: _jsx("span", { className: 'time-display', children: timeDisplay.relative }) })] }), _jsx("div", { className: 'tags-container', children: session.tags?.map((tag) => {
+                                    const automationTag = parseAutomationTag(tag);
+                                    if (automationTag) {
+                                        const href = `/automation?rule=${encodeURIComponent(automationTag.ruleId)}`;
+                                        return (_jsx(Tooltip, { title: automationTag.ruleTitle, children: _jsx(Tag, { className: 'session-tag session-tag--automation', onClick: (event) => event.stopPropagation(), children: _jsx("a", { className: 'session-tag__link', href: href, onClick: (event) => event.stopPropagation(), children: automationTag.ruleTitle }) }) }, tag));
+                                    }
+                                    return (_jsx(Tooltip, { title: tag, children: _jsx(Tag, { className: 'session-tag', children: _jsx("span", { className: 'session-tag__text', children: tag }) }) }, tag));
+                                }) })] })] }), messageCount > 0 && (_jsx(Badge, { count: messageCount > 99 ? '99+' : messageCount, className: 'session-item-badge' }))] }));
+}

package/dist/apps/client/src/components/sidebar/SessionList.d.ts

@@ -0,0 +1,17 @@
+import './SessionList.scss';
+import type { Session } from '@vibe-forge/core';
+interface SessionListProps {
+    sessions: Session[];
+    activeId?: string;
+    isBatchMode: boolean;
+    selectedIds: Set<string>;
+    searchQuery?: string;
+    onSelectSession: (session: Session) => void;
+    onArchiveSession: (id: string) => void | Promise<void>;
+    onDeleteSession: (id: string) => void | Promise<void>;
+    onStarSession: (id: string, isStarred: boolean) => void | Promise<void>;
+    onUpdateTags: (id: string, tags: string[]) => void | Promise<void>;
+    onToggleSelect: (id: string) => void;
+}
+export declare function SessionList({ sessions, activeId, isBatchMode, selectedIds, searchQuery, onSelectSession, onArchiveSession, onDeleteSession, onStarSession, onUpdateTags, onToggleSelect }: SessionListProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/sidebar/SessionList.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './SessionList.scss';
+import { Button, List } from 'antd';
+import { useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { SessionItem } from './SessionItem';
+export function SessionList({ sessions, activeId, isBatchMode, selectedIds, searchQuery, onSelectSession, onArchiveSession, onDeleteSession, onStarSession, onUpdateTags, onToggleSelect }) {
+    const { t } = useTranslation();
+    const [collapsedIds, setCollapsedIds] = useState(new Set());
+    const { flattenedSessions, childSummaryMap } = useMemo(() => {
+        const sessionMap = new Map(sessions.map((s) => [s.id, s]));
+        const childrenMap = new Map();
+        for (const session of sessions) {
+            if (session.parentSessionId) {
+                const list = childrenMap.get(session.parentSessionId) ?? [];
+                list.push(session);
+                childrenMap.set(session.parentSessionId, list);
+            }
+        }
+        const roots = sessions.filter((s) => {
+            if (!s.parentSessionId)
+                return true;
+            return !sessionMap.has(s.parentSessionId);
+        });
+        const childSummary = new Map();
+        for (const [parentId, children] of childrenMap.entries()) {
+            const total = children.length;
+            const statusCount = new Map();
+            for (const child of children) {
+                const status = child.status ?? 'running';
+                statusCount.set(status, (statusCount.get(status) ?? 0) + 1);
+            }
+            const parts = [t('common.childSummary', { count: total })];
+            for (const [status, count] of statusCount.entries()) {
+                parts.push(t('common.childStatusItem', { count, status: t(`common.status.${status}`) }));
+            }
+            childSummary.set(parentId, parts.join(' · '));
+        }
+        const result = [];
+        const visited = new Set();
+        const walk = (session, depth) => {
+            if (visited.has(session.id))
+                return;
+            visited.add(session.id);
+            const children = childrenMap.get(session.id) ?? [];
+            result.push({
+                session,
+                depth,
+                hasChildren: children.length > 0
+            });
+            if (collapsedIds.has(session.id))
+                return;
+            for (const child of children) {
+                walk(child, depth + 1);
+            }
+        };
+        for (const root of roots) {
+            walk(root, 0);
+        }
+        return {
+            flattenedSessions: result,
+            childSummaryMap: childSummary
+        };
+    }, [sessions, collapsedIds, t]);
+    const toggleCollapse = (id) => {
+        setCollapsedIds((prev) => {
+            const next = new Set(prev);
+            if (next.has(id)) {
+                next.delete(id);
+            }
+            else {
+                next.add(id);
+            }
+            return next;
+        });
+    };
+    return (_jsx("div", { className: 'session-list-container', children: _jsx("div", { className: 'session-list-scroll', children: _jsx(List, { className: 'session-list', size: 'small', locale: {
+                    emptyText: _jsx("div", { className: 'empty-text', children: searchQuery ? t('common.noSessions') : t('common.startNewChat') })
+                }, dataSource: flattenedSessions, renderItem: ({ session: s, depth, hasChildren }) => (_jsxs("div", { className: `session-row ${depth > 0 ? 'has-parent' : ''}`, style: { '--session-depth': depth }, children: [_jsx(SessionItem, { session: s, isActive: activeId === s.id, isBatchMode: isBatchMode, isSelected: selectedIds.has(s.id), onSelect: onSelectSession, onArchive: onArchiveSession, onDelete: onDeleteSession, onStar: onStarSession, onUpdateTags: onUpdateTags, onToggleSelect: onToggleSelect }), hasChildren && !isBatchMode && (_jsxs("div", { className: 'session-collapse-row', style: { '--session-depth': depth }, onClick: (e) => e.stopPropagation(), children: [_jsx(Button, { type: 'text', size: 'small', className: `session-tree-toggle ${collapsedIds.has(s.id) ? 'collapsed' : ''}`, onClick: () => toggleCollapse(s.id), icon: _jsx("span", { className: 'material-symbols-rounded', children: "chevron_right" }) }), _jsx("span", { className: 'session-collapse-label', children: collapsedIds.has(s.id) ? t('common.expandChildren') : t('common.collapseChildren') }), _jsx("span", { className: 'session-collapse-summary', children: childSummaryMap.get(s.id) ?? t('common.childSummary', { count: 0 }) })] }))] })) }) }) }));
+}

package/dist/apps/client/src/components/sidebar/SidebarHeader.d.ts

@@ -0,0 +1,15 @@
+import './SidebarHeader.scss';
+interface SidebarHeaderProps {
+    searchQuery: string;
+    onSearchChange: (query: string) => void;
+    isBatchMode: boolean;
+    onToggleBatchMode: () => void;
+    selectedCount: number;
+    totalCount: number;
+    onSelectAll: (selected: boolean) => void;
+    onBatchArchive: () => void;
+    isCreatingSession: boolean;
+    onCreateSession: () => void;
+}
+export declare function SidebarHeader({ searchQuery, onSearchChange, isBatchMode, onToggleBatchMode, selectedCount, totalCount, onSelectAll, onBatchArchive, isCreatingSession, onCreateSession }: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/apps/client/src/components/sidebar/SidebarHeader.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import './SidebarHeader.scss';
+import { Button, Checkbox, Input, Popconfirm, Tooltip } from 'antd';
+import { useAtom } from 'jotai';
+import { useTranslation } from 'react-i18next';
+import { isSidebarCollapsedAtom } from '#~/store/index.js';
+export function SidebarHeader({ searchQuery, onSearchChange, isBatchMode, onToggleBatchMode, selectedCount, totalCount, onSelectAll, onBatchArchive, isCreatingSession, onCreateSession }) {
+    const { t } = useTranslation();
+    const [isSidebarCollapsed, setIsSidebarCollapsed] = useAtom(isSidebarCollapsedAtom);
+    const isAllSelected = totalCount > 0 && selectedCount === totalCount;
+    return (_jsx("div", { className: 'sidebar-header', children: _jsxs("div", { className: 'header-bottom', children: [isBatchMode && (_jsx("div", { className: 'batch-select-wrapper', children: _jsx(Tooltip, { title: isAllSelected ? t('common.deselectAll') : t('common.selectAll'), children: _jsx(Checkbox, { checked: isAllSelected, indeterminate: selectedCount > 0 && selectedCount < totalCount, onChange: (e) => onSelectAll(e.target.checked) }) }) })), _jsx(Input, { className: 'search-input', placeholder: t('common.search'), value: searchQuery, onChange: (e) => onSearchChange(e.target.value), prefix: _jsx("span", { className: 'material-symbols-rounded search-icon', children: "search" }), allowClear: true }), _jsxs("div", { className: 'batch-actions', children: [_jsx(Tooltip, { title: isBatchMode ? t('common.cancelBatch') : t('common.batchMode'), children: _jsx(Button, { className: `action-btn ${isBatchMode ? 'active' : ''}`, type: isBatchMode ? 'primary' : 'text', onClick: onToggleBatchMode, children: _jsx("span", { className: 'material-symbols-rounded', children: isBatchMode ? 'close' : 'checklist' }) }) }), isBatchMode && (_jsx(Popconfirm, { title: t('common.archiveConfirm', { count: selectedCount }), onConfirm: onBatchArchive, okText: t('common.confirm'), cancelText: t('common.cancel'), okButtonProps: { danger: false }, disabled: selectedCount === 0, children: _jsx(Tooltip, { title: t('common.batchArchive'), children: _jsx(Button, { className: 'action-btn', type: 'text', disabled: selectedCount === 0, children: _jsx("span", { className: 'material-symbols-rounded', children: "archive" }) }) }) }))] }), _jsx(Tooltip, { title: isSidebarCollapsed ? t('common.expand') : t('common.collapse'), children: _jsx(Button, { className: 'sidebar-collapse-btn', type: 'text', onClick: () => setIsSidebarCollapsed(!isSidebarCollapsed), children: _jsx("span", { className: 'material-symbols-rounded', children: isSidebarCollapsed ? 'dock_to_right' : 'left_panel_close' }) }) }), isSidebarCollapsed && (_jsx(Tooltip, { title: isCreatingSession ? t('common.alreadyInNewChat') : t('common.newChat'), placement: 'right', children: _jsx(Button, { className: `sidebar-new-chat-btn ${isCreatingSession ? 'active' : ''}`, type: 'text', disabled: !!isCreatingSession, onClick: onCreateSession, children: _jsx("span", { className: `material-symbols-rounded ${isCreatingSession ? 'filled' : ''}`, children: isCreatingSession ? 'chat_bubble' : 'send' }) }) }))] }) }));
+}

package/dist/apps/client/src/connectionManager.d.ts

@@ -0,0 +1,30 @@
+import type { WSHandlers } from './ws';
+declare class ConnectionManager {
+    private sockets;
+    private subscribers;
+    private disconnectTimers;
+    private connectionParams;
+    private readonly DISCONNECT_DELAY;
+    /**
+     * Connect to a session or reuse existing connection
+     * @param sessionId The session ID to connect to
+     * @param handlers Event handlers for this subscription
+     * @returns A cleanup function to unsubscribe
+     */
+    connect(sessionId: string, handlers: WSHandlers, params?: Record<string, string>): () => void;
+    private createConnection;
+    private disconnect;
+    private broadcast;
+    /**
+     * Manually close a connection if needed
+     */
+    close(sessionId: string): void;
+    /**
+     * Send a message to the session
+     */
+    send(sessionId: string, data: any): void;
+    private normalizeParams;
+    private buildParamsKey;
+}
+export declare const connectionManager: ConnectionManager;
+export {};

package/dist/apps/client/src/connectionManager.js

@@ -0,0 +1,154 @@
+import { createSocket } from './ws';
+class ConnectionManager {
+    sockets = new Map();
+    subscribers = new Map();
+    disconnectTimers = new Map();
+    connectionParams = new Map();
+    // Keep connection alive for 60 seconds after last subscriber leaves
+    // This allows for quick navigation between sessions without reconnecting
+    // and basic background task updates if the user quickly checks back
+    DISCONNECT_DELAY = 60000;
+    /**
+     * Connect to a session or reuse existing connection
+     * @param sessionId The session ID to connect to
+     * @param handlers Event handlers for this subscription
+     * @returns A cleanup function to unsubscribe
+     */
+    connect(sessionId, handlers, params) {
+        // 1. Cancel any pending disconnect timer
+        if (this.disconnectTimers.has(sessionId)) {
+            clearTimeout(this.disconnectTimers.get(sessionId));
+            this.disconnectTimers.delete(sessionId);
+        }
+        // 2. Add subscriber
+        if (!this.subscribers.has(sessionId)) {
+            this.subscribers.set(sessionId, new Set());
+        }
+        this.subscribers.get(sessionId).add(handlers);
+        // 3. Ensure WebSocket is open
+        const nextParams = this.normalizeParams({ sessionId, ...(params ?? {}) });
+        const paramsKey = this.buildParamsKey(nextParams);
+        const prevParamsKey = this.connectionParams.get(sessionId);
+        let ws = this.sockets.get(sessionId);
+        if (prevParamsKey != null && prevParamsKey !== paramsKey && ws) {
+            ws.close();
+            this.sockets.delete(sessionId);
+            ws = undefined;
+        }
+        // If socket doesn't exist or is closed/closing, create a new one
+        if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
+            this.createConnection(sessionId, nextParams);
+        }
+        else if (ws.readyState === WebSocket.OPEN) {
+            // If already open, trigger onOpen immediately for this new subscriber
+            handlers.onOpen?.();
+        }
+        this.connectionParams.set(sessionId, paramsKey);
+        // 4. Return unsubscribe function
+        return () => this.disconnect(sessionId, handlers);
+    }
+    createConnection(sessionId, params) {
+        const ws = createSocket({
+            onOpen: () => {
+                this.broadcast(sessionId, 'onOpen');
+            },
+            onMessage: (data) => {
+                this.broadcast(sessionId, 'onMessage', data);
+            },
+            onError: (err) => {
+                this.broadcast(sessionId, 'onError', err);
+            },
+            onClose: () => {
+                this.broadcast(sessionId, 'onClose');
+                // Clean up if closed from server side
+                if (this.sockets.get(sessionId) === ws) {
+                    this.sockets.delete(sessionId);
+                }
+            }
+        }, params);
+        this.sockets.set(sessionId, ws);
+    }
+    disconnect(sessionId, handlers) {
+        const subs = this.subscribers.get(sessionId);
+        if (subs) {
+            subs.delete(handlers);
+            // If no more subscribers, schedule disconnect
+            if (subs.size === 0) {
+                this.disconnectTimers.set(sessionId, setTimeout(() => {
+                    const ws = this.sockets.get(sessionId);
+                    if (ws) {
+                        ws.close();
+                        this.sockets.delete(sessionId);
+                    }
+                    this.disconnectTimers.delete(sessionId);
+                    this.subscribers.delete(sessionId);
+                    this.connectionParams.delete(sessionId);
+                }, this.DISCONNECT_DELAY));
+            }
+        }
+    }
+    broadcast(sessionId, method, data) {
+        const subs = this.subscribers.get(sessionId);
+        if (subs) {
+            // Create a copy to avoid issues if handlers unsubscribe during execution
+            const handlers = Array.from(subs);
+            handlers.forEach(h => {
+                if (h[method]) {
+                    try {
+                        // @ts-ignore - Dynamic dispatch
+                        h[method](data);
+                    }
+                    catch (e) {
+                        console.error(`Error in ${method} handler for session ${sessionId}:`, e);
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Manually close a connection if needed
+     */
+    close(sessionId) {
+        const ws = this.sockets.get(sessionId);
+        if (ws) {
+            ws.close();
+            this.sockets.delete(sessionId);
+        }
+        if (this.disconnectTimers.has(sessionId)) {
+            clearTimeout(this.disconnectTimers.get(sessionId));
+            this.disconnectTimers.delete(sessionId);
+        }
+        this.subscribers.delete(sessionId);
+        this.connectionParams.delete(sessionId);
+    }
+    /**
+     * Send a message to the session
+     */
+    send(sessionId, data) {
+        const ws = this.sockets.get(sessionId);
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(typeof data === 'string' ? data : JSON.stringify(data));
+        }
+        else {
+            console.warn(`Cannot send message: Session ${sessionId} not connected or ready`);
+        }
+    }
+    normalizeParams(params) {
+        return Object.entries(params).reduce((acc, [key, value]) => {
+            if (value == null)
+                return acc;
+            const trimmed = String(value).trim();
+            if (trimmed === '')
+                return acc;
+            acc[key] = trimmed;
+            return acc;
+        }, {});
+    }
+    buildParamsKey(params) {
+        return Object.entries(params)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    }
+}
+export const connectionManager = new ConnectionManager();

package/dist/apps/client/src/hooks/chat/model-selector.d.ts

@@ -0,0 +1,40 @@
+import type { AdapterBuiltinModel, ModelMetadataConfig, ServiceModelEntry } from '@vibe-forge/types';
+import { buildServiceModelSelector, listServiceModels, mergeAdapterConfigs, normalizeNonEmptyString, parseServiceModelSelector, resolveAdapterModelCompatibility, resolveServiceModelSelector } from '@vibe-forge/utils/model-selection';
+export type { ServiceModelEntry };
+export { buildServiceModelSelector, listServiceModels, mergeAdapterConfigs, normalizeNonEmptyString, parseServiceModelSelector, resolveAdapterModelCompatibility, resolveServiceModelSelector };
+export declare const resolveChatModelSelection: (params: {
+    value?: string;
+    builtinModels?: Iterable<string>;
+    serviceModels: ServiceModelEntry[];
+    defaultModelService?: string;
+    preserveUnknown?: boolean;
+}) => string | undefined;
+export declare const resolveDefaultChatModelSelection: (params: {
+    defaultModel?: string;
+    defaultModelService?: string;
+    builtinModels?: Iterable<string>;
+    serviceModels: ServiceModelEntry[];
+    preserveUnknownDefaultModel?: boolean;
+}) => string;
+export declare const resolveChatAdapterSelection: (params: {
+    value?: string;
+    availableAdapters: Iterable<string>;
+    defaultAdapter?: string;
+    preserveUnknown?: boolean;
+}) => string;
+export declare const resolveAdapterForChatModelSelection: (params: {
+    model?: string;
+    availableAdapters: Iterable<string>;
+    defaultAdapter?: string;
+    adapterBuiltinModels?: Record<string, AdapterBuiltinModel[]>;
+    modelMetadata?: Record<string, ModelMetadataConfig>;
+}) => string;
+export declare const resolveModelForChatAdapterSelection: (params: {
+    adapter?: string;
+    adapters?: Record<string, unknown>;
+    defaultModel?: string;
+    defaultModelService?: string;
+    builtinModels?: Iterable<string>;
+    fallbackBuiltinModels?: Iterable<string>;
+    serviceModels: ServiceModelEntry[];
+}) => string;

package/dist/apps/client/src/hooks/chat/model-selector.js

@@ -0,0 +1,81 @@
+import { buildServiceModelSelector, listServiceModels, mergeAdapterConfigs, normalizeNonEmptyString, parseServiceModelSelector, resolveAdapterConfiguredDefaultModel, resolveAdapterModelCompatibility, resolveDefaultModelSelection, resolveModelDefaultAdapter, resolveModelSelection, resolveServiceModelSelector } from '@vibe-forge/utils/model-selection';
+export { buildServiceModelSelector, listServiceModels, mergeAdapterConfigs, normalizeNonEmptyString, parseServiceModelSelector, resolveAdapterModelCompatibility, resolveServiceModelSelector };
+export const resolveChatModelSelection = (params) => {
+    return resolveModelSelection({
+        value: params.value,
+        builtinModels: params.builtinModels,
+        serviceModels: params.serviceModels,
+        preferredServiceKey: params.defaultModelService,
+        preserveUnknown: params.preserveUnknown
+    });
+};
+export const resolveDefaultChatModelSelection = (params) => {
+    return resolveDefaultModelSelection({
+        defaultModel: params.defaultModel,
+        defaultModelService: params.defaultModelService,
+        builtinModels: params.builtinModels,
+        serviceModels: params.serviceModels,
+        preserveUnknownDefaultModel: params.preserveUnknownDefaultModel
+    });
+};
+export const resolveChatAdapterSelection = (params) => {
+    const normalizedValue = normalizeNonEmptyString(params.value);
+    const adapterKeys = Array.from(params.availableAdapters);
+    const adapterSet = new Set(adapterKeys);
+    const normalizedDefaultAdapter = normalizeNonEmptyString(params.defaultAdapter);
+    if (normalizedValue) {
+        if (adapterSet.has(normalizedValue))
+            return normalizedValue;
+        if (params.preserveUnknown === true)
+            return normalizedValue;
+    }
+    if (normalizedDefaultAdapter && adapterSet.has(normalizedDefaultAdapter))
+        return normalizedDefaultAdapter;
+    return adapterKeys[0];
+};
+const findBuiltinModelAdapters = (model, adapterBuiltinModels) => {
+    const normalizedModel = normalizeNonEmptyString(model);
+    if (!normalizedModel)
+        return [];
+    return Object.entries(adapterBuiltinModels)
+        .filter(([, models]) => Array.isArray(models) && models.some(item => item?.value === normalizedModel))
+        .map(([adapterKey]) => adapterKey);
+};
+export const resolveAdapterForChatModelSelection = (params) => {
+    const adapterKeys = Array.from(params.availableAdapters);
+    const adapterSet = new Set(adapterKeys);
+    const metadataAdapter = resolveModelDefaultAdapter({
+        model: params.model,
+        models: params.modelMetadata
+    });
+    if (metadataAdapter && adapterSet.has(metadataAdapter))
+        return metadataAdapter;
+    const builtinAdapters = findBuiltinModelAdapters(params.model, params.adapterBuiltinModels ?? {});
+    const normalizedDefaultAdapter = normalizeNonEmptyString(params.defaultAdapter);
+    if (normalizedDefaultAdapter && builtinAdapters.includes(normalizedDefaultAdapter))
+        return normalizedDefaultAdapter;
+    if (builtinAdapters.length > 0)
+        return builtinAdapters[0];
+    return resolveChatAdapterSelection({
+        availableAdapters: adapterKeys,
+        defaultAdapter: params.defaultAdapter
+    });
+};
+export const resolveModelForChatAdapterSelection = (params) => {
+    const adapterConfiguredModel = resolveAdapterConfiguredDefaultModel({
+        adapterConfig: params.adapter != null ? params.adapters?.[params.adapter] : undefined,
+        builtinModels: params.builtinModels,
+        serviceModels: params.serviceModels,
+        preferredServiceKey: params.defaultModelService,
+        preserveUnknown: false
+    });
+    if (adapterConfiguredModel)
+        return adapterConfiguredModel;
+    return resolveDefaultChatModelSelection({
+        defaultModel: params.defaultModel,
+        defaultModelService: params.defaultModelService,
+        builtinModels: params.builtinModels ?? params.fallbackBuiltinModels,
+        serviceModels: params.serviceModels,
+        preserveUnknownDefaultModel: false
+    });
+};

package/dist/apps/client/src/hooks/chat/use-chat-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export declare function useChatAdapter(): {
+    selectedAdapter: string | undefined;
+    setSelectedAdapter: (value?: string) => void;
+    adapterOptions: {
+        value: string;
+        label: ReactNode;
+    }[];
+};