| ```mermaid |
| sequenceDiagram |
| participant UI as 🧩 ChatForm / ChatMessage |
| participant chatStore as 🗄️ chatStore |
| participant agenticStore as 🗄️ agenticStore |
| participant convStore as 🗄️ conversationsStore |
| participant settingsStore as 🗄️ settingsStore |
| participant mcpStore as 🗄️ mcpStore |
| participant ChatSvc as ⚙️ ChatService |
| participant DbSvc as ⚙️ DatabaseService |
| participant API as 🌐 /v1/chat/completions |
| |
| Note over chatStore: State:<br/>isLoading, currentResponse<br/>errorDialogState, activeProcessingState<br/>chatLoadingStates (Map)<br/>chatStreamingStates (Map)<br/>abortControllers (Map)<br/>processingStates (Map) |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: 💬 SEND MESSAGE |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| UI->>chatStore: sendMessage(content, extras) |
| activate chatStore |
| |
| chatStore->>chatStore: setChatLoading(convId, true) |
| chatStore->>chatStore: clearChatStreaming(convId) |
| |
| alt no active conversation |
| chatStore->>convStore: createConversation() |
| Note over convStore: → see conversations-flow.mmd |
| end |
| |
| chatStore->>mcpStore: consumeResourceAttachmentsAsExtras() |
| Note right of mcpStore: Converts pending MCP resource<br/>attachments into message extras |
| |
| chatStore->>chatStore: addMessage("user", content, extras) |
| chatStore->>DbSvc: createMessageBranch(userMsg, parentId) |
| chatStore->>convStore: addMessageToActive(userMsg) |
| chatStore->>convStore: updateCurrentNode(userMsg.id) |
| |
| chatStore->>chatStore: createAssistantMessage(userMsg.id) |
| chatStore->>DbSvc: createMessageBranch(assistantMsg, userMsg.id) |
| chatStore->>convStore: addMessageToActive(assistantMsg) |
| |
| chatStore->>chatStore: streamChatCompletion(messages, assistantMsg) |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: 🌊 STREAMING (with agentic flow detection) |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| activate chatStore |
| chatStore->>chatStore: startStreaming() |
| Note right of chatStore: isStreamingActive = true |
| |
| chatStore->>chatStore: setActiveProcessingConversation(convId) |
| chatStore->>chatStore: getOrCreateAbortController(convId) |
| Note right of chatStore: abortControllers.set(convId, new AbortController()) |
| |
| chatStore->>chatStore: getApiOptions() |
| Note right of chatStore: Merge from settingsStore.config:<br/>temperature, max_tokens, top_p, etc. |
| |
| alt agenticConfig.enabled && mcpStore has connected servers |
| chatStore->>agenticStore: runAgenticFlow(convId, messages, assistantMsg, options, signal) |
| Note over agenticStore: Multi-turn agentic loop:<br/>1. Call ChatService.sendMessage()<br/>2. If response has tool_calls → execute via mcpStore<br/>3. Append tool results as messages<br/>4. Loop until no more tool_calls or maxTurns<br/>→ see agentic flow details below |
| agenticStore-->>chatStore: final response with timings |
| else standard (non-agentic) flow |
| chatStore->>ChatSvc: sendMessage(messages, options, signal) |
| end |
| |
| activate ChatSvc |
| |
| ChatSvc->>ChatSvc: convertDbMessageToApiChatMessageData(messages) |
| Note right of ChatSvc: DatabaseMessage[] → ApiChatMessageData[]<br/>Process attachments (images, PDFs, audio) |
| |
| ChatSvc->>API: POST /v1/chat/completions |
| Note right of API: {messages, model?, stream: true, ...params} |
| |
| loop SSE chunks |
| API-->>ChatSvc: data: {"choices":[{"delta":{...}}]} |
| ChatSvc->>ChatSvc: handleStreamResponse(response) |
| |
| alt content chunk |
| ChatSvc-->>chatStore: onChunk(content) |
| chatStore->>chatStore: setChatStreaming(convId, response, msgId) |
| Note right of chatStore: currentResponse = $state(accumulated) |
| chatStore->>convStore: updateMessageAtIndex(idx, {content}) |
| end |
| |
| alt reasoning chunk |
| ChatSvc-->>chatStore: onReasoningChunk(reasoning) |
| chatStore->>convStore: updateMessageAtIndex(idx, {thinking}) |
| end |
| |
| alt tool_calls chunk |
| ChatSvc-->>chatStore: onToolCallChunk(toolCalls) |
| chatStore->>convStore: updateMessageAtIndex(idx, {toolCalls}) |
| end |
| |
| alt model info |
| ChatSvc-->>chatStore: onModel(modelName) |
| chatStore->>chatStore: recordModel(modelName) |
| chatStore->>DbSvc: updateMessage(msgId, {model}) |
| end |
| |
| alt timings (during stream) |
| ChatSvc-->>chatStore: onTimings(timings, promptProgress) |
| chatStore->>chatStore: updateProcessingStateFromTimings() |
| end |
| |
| chatStore-->>UI: reactive $state update |
| end |
| |
| API-->>ChatSvc: data: [DONE] |
| ChatSvc-->>chatStore: onComplete(content, reasoning, timings, toolCalls) |
| deactivate ChatSvc |
| |
| chatStore->>chatStore: stopStreaming() |
| chatStore->>DbSvc: updateMessage(msgId, {content, timings, model}) |
| chatStore->>convStore: updateCurrentNode(msgId) |
| chatStore->>chatStore: setChatLoading(convId, false) |
| chatStore->>chatStore: clearChatStreaming(convId) |
| chatStore->>chatStore: clearProcessingState(convId) |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: ⏹️ STOP GENERATION |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| UI->>chatStore: stopGeneration() |
| activate chatStore |
| chatStore->>chatStore: savePartialResponseIfNeeded(convId) |
| Note right of chatStore: Save currentResponse to DB if non-empty |
| chatStore->>chatStore: abortControllers.get(convId).abort() |
| Note right of chatStore: fetch throws AbortError → caught by isAbortError() |
| chatStore->>chatStore: stopStreaming() |
| chatStore->>chatStore: setChatLoading(convId, false) |
| chatStore->>chatStore: clearChatStreaming(convId) |
| chatStore->>chatStore: clearProcessingState(convId) |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: 🔁 REGENERATE |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| UI->>chatStore: regenerateMessageWithBranching(msgId, model?) |
| activate chatStore |
| chatStore->>convStore: findMessageIndex(msgId) |
| chatStore->>chatStore: Get parent of target message |
| chatStore->>chatStore: createAssistantMessage(parentId) |
| chatStore->>DbSvc: createMessageBranch(newAssistantMsg, parentId) |
| chatStore->>convStore: refreshActiveMessages() |
| Note right of chatStore: Same streaming flow |
| chatStore->>chatStore: streamChatCompletion(...) |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: ➡️ CONTINUE |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| UI->>chatStore: continueAssistantMessage(msgId) |
| activate chatStore |
| chatStore->>chatStore: Get existing content from message |
| chatStore->>chatStore: streamChatCompletion(..., existingContent) |
| Note right of chatStore: Appends to existing message content |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: ✏️ EDIT USER MESSAGE |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| UI->>chatStore: editMessageWithBranching(msgId, newContent, extras) |
| activate chatStore |
| chatStore->>chatStore: Get parent of target message |
| chatStore->>DbSvc: createMessageBranch(editedMsg, parentId) |
| chatStore->>convStore: refreshActiveMessages() |
| Note right of chatStore: Creates new branch, original preserved |
| chatStore->>chatStore: createAssistantMessage(editedMsg.id) |
| chatStore->>chatStore: streamChatCompletion(...) |
| Note right of chatStore: Automatically regenerates response |
| deactivate chatStore |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: ❌ ERROR HANDLING |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| Note over chatStore: On stream error (non-abort): |
| chatStore->>chatStore: showErrorDialog(type, message) |
| Note right of chatStore: errorDialogState = {type: 'timeout'|'server', message} |
| chatStore->>convStore: removeMessageAtIndex(failedMsgIdx) |
| chatStore->>DbSvc: deleteMessage(failedMsgId) |
| |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| Note over UI,API: 🤖 AGENTIC LOOP (when agenticConfig.enabled) |
| %% ═══════════════════════════════════════════════════════════════════════════ |
| |
| Note over agenticStore: agenticStore.runAgenticFlow(convId, messages, assistantMsg, options, signal) |
| activate agenticStore |
| agenticStore->>agenticStore: getSession(convId) or create new |
| agenticStore->>agenticStore: updateSession(turn: 0, running: true) |
| |
| loop executeAgenticLoop (until no tool_calls or maxTurns) |
| agenticStore->>agenticStore: turn++ |
| agenticStore->>ChatSvc: sendMessage(messages, options, signal) |
| ChatSvc->>API: POST /v1/chat/completions |
| API-->>ChatSvc: response with potential tool_calls |
| ChatSvc-->>agenticStore: onComplete(content, reasoning, timings, toolCalls) |
| |
| alt response has tool_calls |
| agenticStore->>agenticStore: normalizeToolCalls(toolCalls) |
| loop for each tool_call |
| agenticStore->>agenticStore: updateSession(streamingToolCall) |
| agenticStore->>mcpStore: executeTool(mcpCall, signal) |
| mcpStore-->>agenticStore: tool result |
| agenticStore->>agenticStore: extractBase64Attachments(result) |
| agenticStore->>agenticStore: emitToolCallResult(convId, ...) |
| agenticStore->>convStore: addMessageToActive(toolResultMsg) |
| agenticStore->>DbSvc: createMessageBranch(toolResultMsg) |
| end |
| agenticStore->>agenticStore: Create new assistantMsg for next turn |
| Note right of agenticStore: Continue loop with updated messages |
| else no tool_calls (final response) |
| agenticStore->>agenticStore: buildFinalTimings(allTurns) |
| Note right of agenticStore: Break loop, return final response |
| end |
| end |
| |
| agenticStore->>agenticStore: updateSession(running: false) |
| agenticStore-->>chatStore: final content, timings, model |
| deactivate agenticStore |
| ``` |
|
|
