Download frontend/src/stores/appStore.js from Rixhot/ZARAI: direct link, hf CLI and curl.
- Browser
- Download file 10.4 kB
-
https://huggingface.co/spaces/Rixhot/ZARAI/resolve/main/frontend/src/stores/appStore.js
- Command line
-
hf download hf://spaces/Rixhot/ZARAI/frontend/src/stores/appStore.js
-
curl -L -o appStore.js https://huggingface.co/spaces/Rixhot/ZARAI/resolve/main/frontend/src/stores/appStore.js
10.4 kB
| /** | |
| * JARVIS β Global State Store (Zustand) | |
| * Manages: sessions, messages, UI state, model status | |
| */ | |
| import { create } from 'zustand' | |
| import { persist } from 'zustand/middleware' | |
| import { v4 as uuidv4 } from 'uuid' | |
| import { chatAPI, sessionsAPI, healthAPI } from '../services/api' | |
| // ββ Helpers βββββββββββββββββββββββββββββββββββββββββ | |
| const uuid = () => uuidv4() | |
| const createMessage = (role, content, modality = 'text', extra = {}) => ({ | |
| id: uuid(), | |
| role, | |
| content, | |
| modality, | |
| timestamp: new Date().toISOString(), | |
| ...extra, | |
| }) | |
| // ββ Store ββββββββββββββββββββββββββββββββββββββββββββ | |
| const useAppStore = create( | |
| persist( | |
| (set, get) => ({ | |
| // ββ Sessions βββββββββββββββββββββββββββββββββββ | |
| sessions: [], // [{id, title, updated_at}] | |
| activeSessionId: null, | |
| messages: {}, // { [sessionId]: [message, ...] } | |
| // ββ UI state βββββββββββββββββββββββββββββββββββ | |
| isLoading: false, | |
| inputMode: 'text', // 'text' | 'image' | 'voice' | |
| sidebarOpen: true, | |
| agentSteps: [], // last agent reasoning trace | |
| modelStatus: null, // health check result | |
| pendingImage: null, // { file, preview, caption } | |
| // ββ Init βββββββββββββββββββββββββββββββββββββββ | |
| initializeSession: async () => { | |
| const state = get() | |
| if (!state.activeSessionId) { | |
| const sessionId = uuid() | |
| set((s) => ({ | |
| activeSessionId: sessionId, | |
| sessions: [ | |
| { id: sessionId, title: 'New Chat', updated_at: new Date().toISOString() }, | |
| ...s.sessions, | |
| ], | |
| messages: { ...s.messages, [sessionId]: [] }, | |
| })) | |
| } | |
| // Fetch health status | |
| try { | |
| const health = await healthAPI.check() | |
| set({ modelStatus: health }) | |
| } catch { | |
| set({ modelStatus: { status: 'offline' } }) | |
| } | |
| // Fetch existing sessions from server | |
| try { | |
| const data = await sessionsAPI.listSessions() | |
| if (data.sessions?.length) { | |
| set((s) => { | |
| const serverIds = new Set(data.sessions.map((x) => x.id)) | |
| const localOnly = s.sessions.filter((x) => !serverIds.has(x.id)) | |
| return { sessions: [...data.sessions, ...localOnly].slice(0, 100) } | |
| }) | |
| } | |
| } catch { | |
| // Offline β use local sessions | |
| } | |
| }, | |
| // ββ Create new session βββββββββββββββββββββββββ | |
| newSession: () => { | |
| const sessionId = uuid() | |
| set((s) => ({ | |
| activeSessionId: sessionId, | |
| sessions: [ | |
| { id: sessionId, title: 'New Chat', updated_at: new Date().toISOString() }, | |
| ...s.sessions, | |
| ], | |
| messages: { ...s.messages, [sessionId]: [] }, | |
| agentSteps: [], | |
| pendingImage: null, | |
| })) | |
| return sessionId | |
| }, | |
| // ββ Switch session βββββββββββββββββββββββββββββ | |
| switchSession: async (sessionId) => { | |
| set({ activeSessionId: sessionId, agentSteps: [], pendingImage: null }) | |
| // Lazy-load messages if not cached | |
| const messages = get().messages[sessionId] | |
| if (!messages?.length) { | |
| try { | |
| const data = await chatAPI.getHistory(sessionId) | |
| set((s) => ({ | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: data.messages.map((m) => ({ | |
| id: String(m.id), | |
| role: m.role, | |
| content: m.content, | |
| modality: m.modality, | |
| timestamp: m.created_at, | |
| })), | |
| }, | |
| })) | |
| } catch { | |
| // Session may be local-only | |
| } | |
| } | |
| }, | |
| // ββ Delete session βββββββββββββββββββββββββββββ | |
| deleteSession: async (sessionId) => { | |
| try { await sessionsAPI.deleteSession(sessionId) } catch { /* local only */ } | |
| const { sessions, messages, activeSessionId } = get() | |
| const newSessions = sessions.filter((s) => s.id !== sessionId) | |
| const newMessages = { ...messages } | |
| delete newMessages[sessionId] | |
| let newActive = activeSessionId | |
| if (activeSessionId === sessionId) { | |
| newActive = newSessions[0]?.id || null | |
| } | |
| set({ sessions: newSessions, messages: newMessages, activeSessionId: newActive }) | |
| if (!newActive) { | |
| get().newSession() | |
| } | |
| }, | |
| // ββ Send message βββββββββββββββββββββββββββββββ | |
| sendMessage: async (text) => { | |
| const { activeSessionId, pendingImage } = get() | |
| if (!text.trim() || get().isLoading) return | |
| const sessionId = activeSessionId || get().newSession() | |
| // Add user message to local state immediately | |
| const userMsg = createMessage('user', text, pendingImage ? 'image' : 'text') | |
| set((s) => ({ | |
| isLoading: true, | |
| agentSteps: [], | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: [...(s.messages[sessionId] || []), userMsg], | |
| }, | |
| pendingImage: null, | |
| })) | |
| // Add typing indicator | |
| const typingId = uuid() | |
| set((s) => ({ | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: [ | |
| ...(s.messages[sessionId] || []), | |
| { id: typingId, role: 'assistant', content: '__typing__', modality: 'text' }, | |
| ], | |
| }, | |
| })) | |
| try { | |
| const imageCaption = pendingImage?.caption || null | |
| const data = await chatAPI.sendMessage(text, sessionId, imageCaption) | |
| // Remove typing indicator, add real response | |
| const assistantMsg = createMessage('assistant', data.response, 'text', { | |
| used_tools: data.used_tools, | |
| memory_hits: data.memory_hits, | |
| }) | |
| set((s) => ({ | |
| isLoading: false, | |
| agentSteps: data.steps || [], | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: s.messages[sessionId] | |
| .filter((m) => m.id !== typingId) | |
| .concat(assistantMsg), | |
| }, | |
| sessions: s.sessions.map((sess) => | |
| sess.id === sessionId | |
| ? { ...sess, updated_at: new Date().toISOString() } | |
| : sess, | |
| ), | |
| })) | |
| // Update session title on first exchange | |
| const msgs = get().messages[sessionId] | |
| if (msgs.filter((m) => m.role === 'assistant').length === 1) { | |
| const shortTitle = text.slice(0, 45) + (text.length > 45 ? 'β¦' : '') | |
| set((s) => ({ | |
| sessions: s.sessions.map((sess) => | |
| sess.id === sessionId ? { ...sess, title: shortTitle } : sess, | |
| ), | |
| })) | |
| } | |
| } catch (error) { | |
| // Remove typing indicator, add error message | |
| set((s) => ({ | |
| isLoading: false, | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: s.messages[sessionId] | |
| .filter((m) => m.id !== typingId) | |
| .concat( | |
| createMessage('assistant', `β οΈ Error: ${error.message}`, 'text'), | |
| ), | |
| }, | |
| })) | |
| } | |
| }, | |
| // ββ Image handling βββββββββββββββββββββββββββββ | |
| setPendingImage: (imageData) => set({ pendingImage: imageData }), | |
| clearPendingImage: () => set({ pendingImage: null }), | |
| // ββ Add image result as messages βββββββββββββββ | |
| addImageResult: (sessionId, userText, result) => { | |
| const userMsg = createMessage('user', userText || '[Image uploaded]', 'image', { | |
| imageCaption: result.caption, | |
| }) | |
| const assistantMsg = createMessage( | |
| 'assistant', | |
| result.llm_response, | |
| 'image', | |
| { | |
| caption: result.caption, | |
| categories: result.top_categories, | |
| }, | |
| ) | |
| set((s) => ({ | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: [ | |
| ...(s.messages[sessionId] || []), | |
| userMsg, | |
| assistantMsg, | |
| ], | |
| }, | |
| })) | |
| }, | |
| // ββ Add voice result as messages βββββββββββββββ | |
| addVoiceResult: (sessionId, transcribed, response) => { | |
| const userMsg = createMessage('user', transcribed, 'voice') | |
| const assistantMsg = createMessage('assistant', response, 'voice') | |
| set((s) => ({ | |
| messages: { | |
| ...s.messages, | |
| [sessionId]: [ | |
| ...(s.messages[sessionId] || []), | |
| userMsg, | |
| assistantMsg, | |
| ], | |
| }, | |
| })) | |
| }, | |
| // ββ UI toggles βββββββββββββββββββββββββββββββββ | |
| setInputMode: (mode) => set({ inputMode: mode }), | |
| toggleSidebar: () => set((s) => ({ sidebarOpen: !s.sidebarOpen })), | |
| // ββ Get active messages ββββββββββββββββββββββββ | |
| getActiveMessages: () => { | |
| const { activeSessionId, messages } = get() | |
| return activeSessionId ? (messages[activeSessionId] || []) : [] | |
| }, | |
| }), | |
| { | |
| name: 'jarvis-store', | |
| partialize: (state) => ({ | |
| sessions: state.sessions, | |
| activeSessionId: state.activeSessionId, | |
| messages: state.messages, | |
| sidebarOpen: state.sidebarOpen, | |
| }), | |
| }, | |
| ), | |
| ) | |
| export default useAppStore | |