@@ -1,6 +1,7 @@
11 package tui
22
33 import (
4+ "context"
45 "encoding/json"
56 "fmt"
67 "os"
@@ -58,6 +59,15 @@ type storeBatch struct {
5859 type llmHistoryMsg struct{ msg provider.Message }
5960 type llmErrorMsg struct{ err error }
6061
62+type userMsgSavedMsg struct {
63+ convIdx int
64+ dbMsgID int64
65+ userMsg provider.Message
66+ err error
67+}
68+
69+type undoResultMsg struct{ err error }
70+
6171 // Streaming delta messages
6272 type llmContentDeltaMsg struct{ content string }
6373 type llmReasoningDeltaMsg struct{ content string }
@@ -179,102 +189,168 @@ func (m Model) waitForLLMUpdate() tea.Cmd {
179189 }
180190 }
181191
182-func (m Model) processLLM() tea.Cmd {
183- prov := m.provider
184- proxy := m.mcpProxy
192+func (m Model) processLLMWithExtra(extra []provider.Message) tea.Cmd {
193+ deps := m.llmTurnDeps()
194+ return func() tea.Msg {
195+ go m.runLLMTurn(deps, extra)
196+ return nil
197+ }
198+}
199+
200+type llmTurnDeps struct {
201+ provider provider.Provider
202+ proxy *mcp.Proxy
203+ tools []mcp.Tool
204+ store *store.Cache
205+ sessionID string
206+ ch chan tea.Msg
207+ ctx context.Context
208+ dt *delta.Tracker
209+ pad llm.ScratchpadReader
210+ systemMsg *provider.Message
211+}
212+
213+type usageTracker struct {
214+ turnIn int
215+ turnOut int
216+ contextIn int
217+}
218+
219+func (m Model) llmTurnDeps() llmTurnDeps {
185220 tools := make([]mcp.Tool, len(m.mcpTools))
186221 copy(tools, m.mcpTools)
187- db := m.store
188- sid := m.sessionID
189- ch := m.updateChan
190- ctx := m.turnCtx
191- dt := m.deltaTracker
192- pad := m.scratchpad
222+ return llmTurnDeps{
223+ provider: m.provider,
224+ proxy: m.mcpProxy,
225+ tools: tools,
226+ store: m.store,
227+ sessionID: m.sessionID,
228+ ch: m.updateChan,
229+ ctx: m.turnCtx,
230+ dt: m.deltaTracker,
231+ pad: m.scratchpad,
232+ systemMsg: m.initialSystemMsg,
233+ }
234+}
193235
194- return func() tea.Msg {
195- go func() {
196- // Load history from DB — the single source of truth.
197- var history []provider.Message
198- if db != nil {
199- stored, err := db.LoadMessages(sid)
200- if err != nil {
201- ch <- llmErrorMsg{err: fmt.Errorf("load history: %w", err)}
202- return
203- }
204- history = store.ToProviderMessages(stored)
205- }
206- // Snapshot the project directory before the turn for undo.
207- // Capture cwd once so both pre/post snapshots use the same root.
208- var preSnap map[string]delta.FileSnapshot
209- var snapRoot string
210- if dt != nil && dt.TurnID() > 0 {
211- if cwd, err := os.Getwd(); err == nil {
212- snapRoot = cwd
213- preSnap = delta.SnapshotDir(snapRoot)
214- }
215- }
236+func (m Model) runLLMTurn(deps llmTurnDeps, extra []provider.Message) {
237+ history, err := loadHistory(deps.store, deps.sessionID)
238+ if err != nil {
239+ deps.ch <- llmErrorMsg{err: fmt.Errorf("load history: %w", err)}
240+ return
241+ }
242+ history = ensureSystemMessage(history, deps.systemMsg)
243+ if len(extra) > 0 {
244+ history = append(history, extra...)
245+ }
216246
217- start := time.Now()
218- var turnIn, turnOut, contextIn int
219- err := llm.ProcessTurn(ctx, llm.ProcessTurnOptions{
220- Provider: prov,
221- Proxy: proxy,
222- Tools: tools,
223- History: history,
224- Scratchpad: pad,
225- // Uses the default from ProcessTurn.
226- OnDelta: func(evt provider.StreamEvent) {
227- switch evt.Type {
228- case provider.EventContentDelta:
229- ch <- llmContentDeltaMsg{content: evt.Content}
230- case provider.EventReasoningDelta:
231- ch <- llmReasoningDeltaMsg{content: evt.Content}
232- }
233- },
234- OnUsage: func(inputTokens, outputTokens int) {
235- turnIn += inputTokens
236- turnOut += outputTokens
237- contextIn = inputTokens
238- ch <- llmUsageMsg{inputTokens: inputTokens, outputTokens: outputTokens}
239- },
240- OnMessage: func(msg provider.Message) {
241- ch <- llmHistoryMsg{msg: msg}
242- switch msg.Role {
243- case roleAssistant:
244- ch <- llmAssistantMsg{
245- reasoning: msg.Reasoning,
246- content: msg.Content,
247- toolCalls: msg.ToolCalls,
248- }
249- case "tool":
250- ch <- llmToolResultMsg{
251- toolCallID: msg.ToolCallID,
252- content: msg.Content,
253- }
254- }
255- },
256- })
257-
258- // Post-turn snapshot: diff against pre to record deltas for undo.
259- // Skip on cancellation — partial work has no turnBoundary.
260- if preSnap != nil && err == nil {
261- postSnap := delta.SnapshotDir(snapRoot)
262- delta.RecordDeltas(dt, snapRoot, preSnap, postSnap)
263- }
247+ preSnap, snapRoot := snapshotBeforeTurn(deps.dt)
248+
249+ start := time.Now()
250+ usage := &usageTracker{}
251+ err = llm.ProcessTurn(deps.ctx, llm.ProcessTurnOptions{
252+ Provider: deps.provider,
253+ Proxy: deps.proxy,
254+ Tools: deps.tools,
255+ History: history,
256+ Scratchpad: deps.pad,
257+ OnDelta: func(evt provider.StreamEvent) {
258+ dispatchStreamEvent(deps.ch, evt)
259+ },
260+ OnUsage: usage.onUsage(deps.ch),
261+ OnMessage: func(msg provider.Message) {
262+ dispatchHistoryMessage(deps.ch, msg)
263+ },
264+ })
264265
265- if err != nil {
266- ch <- llmErrorMsg{err: err}
267- return
268- }
269- ch <- llmDoneMsg{
270- duration: time.Since(start),
271- timestamp: start.Format("15:04"),
272- inputTokens: turnIn,
273- outputTokens: turnOut,
274- contextTokens: contextIn,
275- }
276- }()
277- return nil
266+ recordTurnDeltas(deps.dt, snapRoot, preSnap, err)
267+ if err != nil {
268+ deps.ch <- llmErrorMsg{err: err}
269+ return
270+ }
271+ deps.ch <- llmDoneMsg{
272+ duration: time.Since(start),
273+ timestamp: start.Format("15:04"),
274+ inputTokens: usage.turnIn,
275+ outputTokens: usage.turnOut,
276+ contextTokens: usage.contextIn,
277+ }
278+}
279+
280+func loadHistory(db *store.Cache, sessionID string) ([]provider.Message, error) {
281+ if db == nil {
282+ return nil, nil
283+ }
284+ stored, err := db.LoadMessages(sessionID)
285+ if err != nil {
286+ return nil, err
287+ }
288+ return store.ToProviderMessages(stored), nil
289+}
290+
291+func ensureSystemMessage(history []provider.Message, systemMsg *provider.Message) []provider.Message {
292+ if systemMsg == nil {
293+ return history
294+ }
295+ for _, msg := range history {
296+ if msg.Role == "system" {
297+ return history
298+ }
299+ }
300+ return append([]provider.Message{*systemMsg}, history...)
301+}
302+
303+func snapshotBeforeTurn(dt *delta.Tracker) (map[string]delta.FileSnapshot, string) {
304+ if dt == nil || dt.TurnID() == 0 {
305+ return nil, ""
306+ }
307+ cwd, err := os.Getwd()
308+ if err != nil {
309+ return nil, ""
310+ }
311+ return delta.SnapshotDir(cwd), cwd
312+}
313+
314+func recordTurnDeltas(dt *delta.Tracker, snapRoot string, preSnap map[string]delta.FileSnapshot, err error) {
315+ if preSnap == nil || err != nil {
316+ return
317+ }
318+ postSnap := delta.SnapshotDir(snapRoot)
319+ delta.RecordDeltas(dt, snapRoot, preSnap, postSnap)
320+}
321+
322+func dispatchStreamEvent(ch chan tea.Msg, evt provider.StreamEvent) {
323+ switch evt.Type {
324+ case provider.EventContentDelta:
325+ ch <- llmContentDeltaMsg{content: evt.Content}
326+ case provider.EventReasoningDelta:
327+ ch <- llmReasoningDeltaMsg{content: evt.Content}
328+ }
329+}
330+
331+func dispatchHistoryMessage(ch chan tea.Msg, msg provider.Message) {
332+ ch <- llmHistoryMsg{msg: msg}
333+ switch msg.Role {
334+ case roleAssistant:
335+ ch <- llmAssistantMsg{
336+ reasoning: msg.Reasoning,
337+ content: msg.Content,
338+ toolCalls: msg.ToolCalls,
339+ }
340+ case "tool":
341+ ch <- llmToolResultMsg{
342+ toolCallID: msg.ToolCallID,
343+ content: msg.Content,
344+ }
345+ }
346+}
347+
348+func (u *usageTracker) onUsage(ch chan tea.Msg) func(int, int) {
349+ return func(inputTokens, outputTokens int) {
350+ u.turnIn += inputTokens
351+ u.turnOut += outputTokens
352+ u.contextIn = inputTokens
353+ ch <- llmUsageMsg{inputTokens: inputTokens, outputTokens: outputTokens}
278354 }
279355 }
280356
@@ -301,44 +377,47 @@ func messageToStore(msg provider.Message) store.SessionMessage {
301377 }
302378 }
303379
304-// saveMessage persists a message to the session store (no-op if store is nil).
305-func (m *Model) saveMessage(msg provider.Message) {
306- if m.store == nil {
380+func (m *Model) saveMessages(msgs []provider.Message) {
381+ if m.store == nil || len(msgs) == 0 {
307382 return
308383 }
309- stored := []store.SessionMessage{messageToStore(msg)}
310- if m.storeQueue != nil {
311- select {
312- case m.storeQueue <- storeBatch{sessionID: m.sessionID, msgs: stored}:
313- return
314- default:
315- log.Warn().Msg("store queue full; falling back to sync save")
316- }
384+ stored := make([]store.SessionMessage, 0, len(msgs))
385+ for _, msg := range msgs {
386+ stored = append(stored, messageToStore(msg))
387+ }
388+ if enqueueStoreBatch(m.storeQueue, storeBatch{sessionID: m.sessionID, msgs: stored}) {
389+ return
317390 }
318391 if err := m.store.SaveMessages(m.sessionID, stored); err != nil {
319392 log.Warn().Err(err).Msg("failed to save message batch")
320393 }
321394 }
322395
323-func (m *Model) saveMessages(msgs []provider.Message) {
396+func (m Model) saveMessagesCmd(msgs []provider.Message) tea.Cmd {
324397 if m.store == nil || len(msgs) == 0 {
325- return
398+ return nil
326399 }
327- stored := make([]store.SessionMessage, 0, len(msgs))
328- for _, msg := range msgs {
329- stored = append(stored, messageToStore(msg))
400+ return func() tea.Msg {
401+ m.saveMessages(msgs)
402+ return nil
330403 }
331- if m.storeQueue != nil {
332- select {
333- case m.storeQueue <- storeBatch{sessionID: m.sessionID, msgs: stored}:
334- return
335- default:
336- log.Warn().Msg("store queue full; dropping message batch")
337- return
338- }
404+}
405+
406+func enqueueStoreBatch(queue chan storeBatch, batch storeBatch) (ok bool) {
407+ if queue == nil {
408+ return false
339409 }
340- if err := m.store.SaveMessages(m.sessionID, stored); err != nil {
341- log.Warn().Err(err).Msg("failed to save message batch")
410+ defer func() {
411+ if recover() != nil {
412+ ok = false
413+ }
414+ }()
415+ select {
416+ case queue <- batch:
417+ return true
418+ default:
419+ log.Warn().Msg("store queue full; dropping message batch")
420+ return false
342421 }
343422 }
344423