diff --git a/internal/agent/runtime.go b/internal/agent/runtime.go index 9fb4f75a3..71e942eda 100644 --- a/internal/agent/runtime.go +++ b/internal/agent/runtime.go @@ -182,7 +182,11 @@ func (r *Runtime) Run(c *echo.Context) error { } input.RunID = runID } - if err := r.store.StartRun(c.Request().Context(), ownerID, input); err != nil { + // The seed is the stored thread plus this request's new user turn, not the + // history the browser posted: the server owns the record, so earlier runs' + // attached views survive and a request cannot rewrite what came before. + seed, err := r.store.StartRun(c.Request().Context(), ownerID, input) + if err != nil { if errors.Is(err, ErrThreadNotFound) { return echo.NewHTTPError(http.StatusNotFound, "thread not found") } @@ -195,7 +199,7 @@ func (r *Runtime) Run(c *echo.Context) error { response.Header().Set(echo.HeaderConnection, "keep-alive") response.WriteHeader(http.StatusOK) emitter := &eventEmitter{ctx: c.Request().Context(), writer: response, sse: sse.NewSSEWriter()} - messages := append([]agtypes.Message(nil), input.Messages...) + messages := append([]agtypes.Message(nil), seed...) runCtx := dashboard.WithOwner(c.Request().Context(), ownerID) truncated, runErr := r.execute(runCtx, input.ThreadID, input.RunID, &messages, emitter) if runErr != nil { diff --git a/internal/agent/runtime_test.go b/internal/agent/runtime_test.go index 67ac8b942..e5d9a8db8 100644 --- a/internal/agent/runtime_test.go +++ b/internal/agent/runtime_test.go @@ -190,7 +190,7 @@ func TestRuntimeProviderErrorSanitizedAndPersisted(t *testing.T) { defer database.Close() store := NewStore(database.DB) input := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: messages} - if err := store.StartRun(context.Background(), "owner-1", input); err != nil { + if _, err := store.StartRun(context.Background(), "owner-1", input); err != nil { t.Fatal(err) } if err := store.FinishRun(context.Background(), "owner-1", "thread-1", "run-1", messages, emitter.events, truncated, runErr); err != nil { diff --git a/internal/agent/store.go b/internal/agent/store.go index 7e8c8e6ed..142100511 100644 --- a/internal/agent/store.go +++ b/internal/agent/store.go @@ -183,23 +183,18 @@ func threadTitle(messages []agtypes.Message) string { // running. The SELECT-then-INSERT runs under BEGIN IMMEDIATE on a pinned // connection so two concurrent first-runs on the same thread serialize // instead of racing into a unique-constraint error. -func (s *Store) StartRun(ctx context.Context, ownerID string, input agtypes.RunAgentInput) error { +func (s *Store) StartRun(ctx context.Context, ownerID string, input agtypes.RunAgentInput) ([]agtypes.Message, error) { inputJSON, err := json.Marshal(input) if err != nil { - return fmt.Errorf("encode run input: %w", err) + return nil, fmt.Errorf("encode run input: %w", err) } - messagesJSON, err := json.Marshal(input.Messages) - if err != nil { - return fmt.Errorf("encode messages: %w", err) - } - title := threadTitle(input.Messages) conn, err := s.db.Conn(ctx) if err != nil { - return fmt.Errorf("open run connection: %w", err) + return nil, fmt.Errorf("open run connection: %w", err) } defer conn.Close() if _, err := conn.ExecContext(ctx, "BEGIN IMMEDIATE"); err != nil { - return fmt.Errorf("begin run: %w", err) + return nil, fmt.Errorf("begin run: %w", err) } committed := false defer func() { @@ -208,26 +203,41 @@ func (s *Store) StartRun(ctx context.Context, ownerID string, input agtypes.RunA } }() - var existingOwner string - err = conn.QueryRowContext(ctx, `SELECT owner_id FROM agui_threads WHERE thread_id = ?`, input.ThreadID).Scan(&existingOwner) + var existingOwner, storedJSON string + err = conn.QueryRowContext(ctx, `SELECT owner_id, messages_json FROM agui_threads WHERE thread_id = ?`, input.ThreadID).Scan(&existingOwner, &storedJSON) + var messages []agtypes.Message switch { case errors.Is(err, sql.ErrNoRows): + messages = mergeThreadMessages(nil, input.Messages) + messagesJSON, err := json.Marshal(messages) + if err != nil { + return nil, fmt.Errorf("encode messages: %w", err) + } if _, err := conn.ExecContext(ctx, `INSERT INTO agui_threads (thread_id, owner_id, title_derived, messages_json) VALUES (?, ?, ?, ?)`, - input.ThreadID, ownerID, title, string(messagesJSON), + input.ThreadID, ownerID, threadTitle(messages), string(messagesJSON), ); err != nil { - return fmt.Errorf("create thread: %w", err) + return nil, fmt.Errorf("create thread: %w", err) } case err != nil: - return fmt.Errorf("check thread owner: %w", err) + return nil, fmt.Errorf("check thread owner: %w", err) case existingOwner != ownerID: - return ErrThreadNotFound + return nil, ErrThreadNotFound default: + var stored []agtypes.Message + if err := json.Unmarshal([]byte(storedJSON), &stored); err != nil { + return nil, fmt.Errorf("decode stored messages: %w", err) + } + messages = mergeThreadMessages(stored, input.Messages) + messagesJSON, err := json.Marshal(messages) + if err != nil { + return nil, fmt.Errorf("encode messages: %w", err) + } if _, err := conn.ExecContext(ctx, `UPDATE agui_threads SET title_derived = ?, messages_json = ?, updated_at = datetime('now') WHERE thread_id = ?`, - title, string(messagesJSON), input.ThreadID, + threadTitle(messages), string(messagesJSON), input.ThreadID, ); err != nil { - return fmt.Errorf("update thread input: %w", err) + return nil, fmt.Errorf("update thread input: %w", err) } } var parent any @@ -238,13 +248,94 @@ func (s *Store) StartRun(ctx context.Context, ownerID string, input agtypes.RunA `INSERT INTO agui_runs (run_id, thread_id, parent_run_id, input_json, status) VALUES (?, ?, ?, ?, 'running')`, input.RunID, input.ThreadID, parent, string(inputJSON), ); err != nil { - return fmt.Errorf("create run: %w", err) + return nil, fmt.Errorf("create run: %w", err) } if _, err := conn.ExecContext(ctx, "COMMIT"); err != nil { - return fmt.Errorf("commit run: %w", err) + return nil, fmt.Errorf("commit run: %w", err) } committed = true - return nil + return messages, nil +} + +// mergeThreadMessages returns the stored history with the request's new user +// turns appended. +// +// The server owns the record. A request may add to a thread but cannot rewrite +// or delete what is already stored, so the views the agent attached to earlier +// runs survive a browser that no longer carries them, and a caller cannot +// fabricate assistant or tool history by posting it. +// +// Turns are matched by the id the client mints, so re-posting a history the +// server has already seen adds nothing. That is deduplication, not replay +// protection: a client that mints a fresh id for the same question asks it +// twice, which is what a person clicking twice means anyway. +// +// The cost of dropping what the client authored is that a failed FinishRun — +// the loss runtime.Run already tolerates — is no longer healed by the next +// request carrying the browser's copy. The thread keeps the question and loses +// the answer, where before it might have been restored by accident. +func mergeThreadMessages(stored, incoming []agtypes.Message) []agtypes.Message { + stored = dropUnansweredToolCalls(stored) + known := make(map[string]struct{}, len(stored)) + for _, message := range stored { + if message.ID != "" { + known[message.ID] = struct{}{} + } + } + merged := append([]agtypes.Message(nil), stored...) + for _, message := range incoming { + if message.Role != agtypes.RoleUser { + continue + } + if message.ID != "" { + if _, seen := known[message.ID]; seen { + continue + } + known[message.ID] = struct{}{} + } + merged = append(merged, message) + } + return merged +} + +// dropUnansweredToolCalls removes tool calls that no result answers. +// +// A run can die between the model asking for a tool and the tool replying — +// the reader pressing Stop is the everyday case, since that cancels the +// request while the final write still goes through on an uncancelled context. +// What lands is an ask with no answer, and both providers reject a +// conversation carrying one. That used to be survivable because the next run +// rebuilt the thread from the browser's copy; now that the server seeds from +// its own record, an orphan left in it would fail every later run on the +// thread with no way for the reader to clear it. An assistant turn that said +// something keeps its words and loses the dangling call; one that only asked +// is dropped whole, because nothing of it remains to say. +func dropUnansweredToolCalls(messages []agtypes.Message) []agtypes.Message { + answered := make(map[string]struct{}) + for _, message := range messages { + if message.Role == agtypes.RoleTool && message.ToolCallID != "" { + answered[message.ToolCallID] = struct{}{} + } + } + repaired := make([]agtypes.Message, 0, len(messages)) + for _, message := range messages { + if message.Role != agtypes.RoleAssistant || len(message.ToolCalls) == 0 { + repaired = append(repaired, message) + continue + } + kept := make([]agtypes.ToolCall, 0, len(message.ToolCalls)) + for _, call := range message.ToolCalls { + if _, ok := answered[call.ID]; ok { + kept = append(kept, call) + } + } + if len(kept) == 0 && strings.TrimSpace(messageText(message.Content)) == "" { + continue + } + message.ToolCalls = kept + repaired = append(repaired, message) + } + return repaired } // FinishRun persists the final conversation and the run outcome. The thread's diff --git a/internal/agent/store_test.go b/internal/agent/store_test.go index 7ecf77aa3..82123ea58 100644 --- a/internal/agent/store_test.go +++ b/internal/agent/store_test.go @@ -30,7 +30,7 @@ func TestStorePersistsOwnerScopedThread(t *testing.T) { defer database.Close() store := NewStore(database.DB) input := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: []agtypes.Message{{ID: "user-1", Role: agtypes.RoleUser, Content: "hello"}}} - if err := store.StartRun(context.Background(), "owner-1", input); err != nil { + if _, err := store.StartRun(context.Background(), "owner-1", input); err != nil { t.Fatal(err) } final := append(input.Messages, agtypes.Message{ID: "assistant-1", Role: agtypes.RoleAssistant, Content: "hi"}) @@ -72,7 +72,7 @@ func TestStoreListsOwnerThreadsWithSearchAndCursor(t *testing.T) { RunID: "run-" + string(rune('a'+index)), Messages: []agtypes.Message{{ID: "message-" + item.id, Role: agtypes.RoleUser, Content: item.message}}, } - if err := store.StartRun(context.Background(), item.owner, input); err != nil { + if _, err := store.StartRun(context.Background(), item.owner, input); err != nil { t.Fatal(err) } if _, err := database.DB.Exec(`UPDATE agui_threads SET updated_at = ? WHERE thread_id = ?`, item.updated, item.id); err != nil { @@ -209,11 +209,11 @@ func TestStoreStartRunRejectsForeignThread(t *testing.T) { defer database.Close() store := NewStore(database.DB) input := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1"} - if err := store.StartRun(context.Background(), "owner-1", input); err != nil { + if _, err := store.StartRun(context.Background(), "owner-1", input); err != nil { t.Fatal(err) } input.RunID = "run-2" - if err := store.StartRun(context.Background(), "owner-2", input); !errors.Is(err, ErrThreadNotFound) { + if _, err := store.StartRun(context.Background(), "owner-2", input); !errors.Is(err, ErrThreadNotFound) { t.Fatalf("foreign owner error = %v, want ErrThreadNotFound", err) } } @@ -235,7 +235,7 @@ func TestStoreConcurrentFirstRunsSameThread(t *testing.T) { go func(i int) { defer wg.Done() input := agtypes.RunAgentInput{ThreadID: "thread-race", RunID: "run-" + string(rune('a'+i))} - results[i] = store.StartRun(context.Background(), "owner-1", input) + _, results[i] = store.StartRun(context.Background(), "owner-1", input) }(i) } wg.Wait() @@ -261,7 +261,7 @@ func TestStoreFinishRunRecordsTruncation(t *testing.T) { defer database.Close() store := NewStore(database.DB) input := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1"} - if err := store.StartRun(context.Background(), "owner-1", input); err != nil { + if _, err := store.StartRun(context.Background(), "owner-1", input); err != nil { t.Fatal(err) } if err := store.FinishRun(context.Background(), "owner-1", "thread-1", "run-1", nil, nil, true, nil); err != nil { @@ -293,7 +293,7 @@ func TestThreadRouteHidesOtherOwnersThread(t *testing.T) { } store := NewStore(database.DB) input := agtypes.RunAgentInput{ThreadID: "private-thread", RunID: "run-1"} - if err := store.StartRun(context.Background(), ownerA.ID, input); err != nil { + if _, err := store.StartRun(context.Background(), ownerA.ID, input); err != nil { t.Fatal(err) } ownInput := agtypes.RunAgentInput{ @@ -301,7 +301,7 @@ func TestThreadRouteHidesOtherOwnersThread(t *testing.T) { RunID: "run-2", Messages: []agtypes.Message{{ID: "message-1", Role: agtypes.RoleUser, Content: "Investigate owner B"}}, } - if err := store.StartRun(context.Background(), ownerB.ID, ownInput); err != nil { + if _, err := store.StartRun(context.Background(), ownerB.ID, ownInput); err != nil { t.Fatal(err) } @@ -376,3 +376,159 @@ func TestThreadRouteHidesOtherOwnersThread(t *testing.T) { t.Fatalf("deleted route thread load = %v, want ErrThreadNotFound", err) } } + +func TestStoreStartRunKeepsStoredHistory(t *testing.T) { + database, err := controlstore.NewSQLite(":memory:") + if err != nil { + t.Fatal(err) + } + defer database.Close() + store := NewStore(database.DB) + ctx := context.Background() + + first := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: []agtypes.Message{{ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}}} + if _, err := store.StartRun(ctx, "owner-1", first); err != nil { + t.Fatal(err) + } + // The run appends what the server authored, including the view it attached. + stored := []agtypes.Message{ + {ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}, + {ID: "assistant-1", Role: agtypes.RoleAssistant, Content: "here it is"}, + {ID: "activity-1", Role: agtypes.RoleActivity, ActivityType: "mcp-app"}, + } + if err := store.FinishRun(ctx, "owner-1", first.ThreadID, first.RunID, stored, nil, false, nil); err != nil { + t.Fatal(err) + } + + // The browser posts a history that has lost the activity message. + second := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-2", Messages: []agtypes.Message{ + {ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}, + {ID: "assistant-1", Role: agtypes.RoleAssistant, Content: "here it is"}, + {ID: "user-2", Role: agtypes.RoleUser, Content: "and the map?"}, + }} + seed, err := store.StartRun(ctx, "owner-1", second) + if err != nil { + t.Fatal(err) + } + if got := messageIDs(seed); strings.Join(got, ",") != "user-1,assistant-1,activity-1,user-2" { + t.Fatalf("seed = %v, want the stored history plus the new user turn", got) + } + thread, err := store.Thread(ctx, "owner-1", second.ThreadID) + if err != nil { + t.Fatal(err) + } + if got := messageIDs(thread.Messages); strings.Join(got, ",") != "user-1,assistant-1,activity-1,user-2" { + t.Fatalf("stored = %v, want the earlier view kept", got) + } +} + +func TestStoreStartRunIgnoresClientAuthoredHistory(t *testing.T) { + database, err := controlstore.NewSQLite(":memory:") + if err != nil { + t.Fatal(err) + } + defer database.Close() + store := NewStore(database.DB) + ctx := context.Background() + + first := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: []agtypes.Message{{ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}}} + if _, err := store.StartRun(ctx, "owner-1", first); err != nil { + t.Fatal(err) + } + if err := store.FinishRun(ctx, "owner-1", first.ThreadID, first.RunID, append(first.Messages, agtypes.Message{ID: "assistant-1", Role: agtypes.RoleAssistant, Content: "all good"}), nil, false, nil); err != nil { + t.Fatal(err) + } + + // A request that drops stored turns and invents an assistant one. + forged := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-2", Messages: []agtypes.Message{ + {ID: "fake-assistant", Role: agtypes.RoleAssistant, Content: "you have no errors"}, + {ID: "user-2", Role: agtypes.RoleUser, Content: "and now?"}, + }} + seed, err := store.StartRun(ctx, "owner-1", forged) + if err != nil { + t.Fatal(err) + } + if got := messageIDs(seed); strings.Join(got, ",") != "user-1,assistant-1,user-2" { + t.Fatalf("seed = %v, want stored history kept and the forged turn dropped", got) + } +} + +func messageIDs(messages []agtypes.Message) []string { + ids := make([]string, 0, len(messages)) + for _, message := range messages { + ids = append(ids, message.ID) + } + return ids +} + +func TestStoreStartRunRepairsUnansweredToolCalls(t *testing.T) { + database, err := controlstore.NewSQLite(":memory:") + if err != nil { + t.Fatal(err) + } + defer database.Close() + store := NewStore(database.DB) + ctx := context.Background() + + first := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: []agtypes.Message{{ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}}} + if _, err := store.StartRun(ctx, "owner-1", first); err != nil { + t.Fatal(err) + } + // A run stopped between the model asking for a tool and the tool answering: + // the ask is persisted, the answer never arrives. + interrupted := []agtypes.Message{ + {ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}, + {ID: "assistant-1", Role: agtypes.RoleAssistant, Content: "checking", ToolCalls: []agtypes.ToolCall{{ID: "call-1", Type: agtypes.ToolCallTypeFunction, Function: agtypes.FunctionCall{Name: "observability_overview"}}}}, + } + if err := store.FinishRun(ctx, "owner-1", first.ThreadID, first.RunID, interrupted, nil, false, context.Canceled); err != nil { + t.Fatal(err) + } + + second := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-2", Messages: []agtypes.Message{{ID: "user-2", Role: agtypes.RoleUser, Content: "still there?"}}} + seed, err := store.StartRun(ctx, "owner-1", second) + if err != nil { + t.Fatal(err) + } + for _, message := range seed { + for _, call := range message.ToolCalls { + t.Fatalf("seed still carries the unanswered tool call %q, which the provider rejects", call.ID) + } + } + if got := messageIDs(seed); strings.Join(got, ",") != "user-1,assistant-1,user-2" { + t.Fatalf("seed = %v, want the turn kept with its unanswered call dropped", got) + } + if seed[1].Content != "checking" { + t.Fatalf("assistant text = %q, want the spoken part kept", seed[1].Content) + } +} + +func TestStoreStartRunDropsAnEmptyInterruptedTurn(t *testing.T) { + database, err := controlstore.NewSQLite(":memory:") + if err != nil { + t.Fatal(err) + } + defer database.Close() + store := NewStore(database.DB) + ctx := context.Background() + + first := agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-1", Messages: []agtypes.Message{{ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}}} + if _, err := store.StartRun(ctx, "owner-1", first); err != nil { + t.Fatal(err) + } + // The model asked for a tool and said nothing else before the run died. + interrupted := []agtypes.Message{ + {ID: "user-1", Role: agtypes.RoleUser, Content: "health?"}, + {ID: "assistant-1", Role: agtypes.RoleAssistant, ToolCalls: []agtypes.ToolCall{{ID: "call-1", Type: agtypes.ToolCallTypeFunction, Function: agtypes.FunctionCall{Name: "observability_overview"}}}}, + } + if err := store.FinishRun(ctx, "owner-1", first.ThreadID, first.RunID, interrupted, nil, false, context.Canceled); err != nil { + t.Fatal(err) + } + + seed, err := store.StartRun(ctx, "owner-1", agtypes.RunAgentInput{ThreadID: "thread-1", RunID: "run-2", Messages: []agtypes.Message{{ID: "user-2", Role: agtypes.RoleUser, Content: "still there?"}}}) + if err != nil { + t.Fatal(err) + } + if got := messageIDs(seed); strings.Join(got, ",") != "user-1,user-2" { + t.Fatalf("seed = %v, want the empty interrupted turn dropped entirely", got) + } +}