Files
archie/internal/webui/api_chat.go
T
sam 0d73f2fa5a feat(chat): show tool calls inline and stream replies into one message
Chat returned only the final answer, so a wrong tool choice, a
hallucinated action, or a footgun like `systemctl stop` against
`restart` was invisible from the conversation. Only text deltas were
threaded through the turn, and tool calls executed inside Generate with
nowhere to report.

Replace the delta callback with gateway.TurnStream, which carries text
fragments and completed tool calls on one ordered path from the model
loop to the channel. The sequence is the point: a tool line that
overtakes the sentence it interrupted describes a turn that never
happened. Text-only callers use gateway.DeltaFunc and are unaffected.

A tool is reported on its result, never on its call  --  the call part
carries no outcome yet, so reporting both would list every tool twice,
once with nothing to say.

Telegram renders it behind [chat.telegram] show_tool_calls, off by
default: this is debugging visibility, and it narrates every internal
step to provide it. The dashboard always shows it, being the operator's
own observability surface; its tool lines are live-only and are not
persisted with the conversation.

The Telegram live reply changes mechanism, and with it what a frame
MEANS. It used to stream through sendMessageDraft: drafts are ephemeral
30-second previews, so a tool call longer than that outlived the
preview, and successive frames were observed concatenated with their
cursors intact. It now sends one real message and edits it. An update
used to be "the next preview of the answer"; it is now "the whole
answer as it currently stands, replacing what is there". The cursor is
appended at render time and never stored, so exactly one exists and
always at the end, and a frame too long for one message is cut to its
tail rather than rejected outright.

A stopped or failed turn now edits the cursor away instead of leaving
it blinking on a message nothing will finish. That cleanup runs on a
live context because turnCtx is already dead, and it runs on both
failure branches: ai-sdk raises an aborted stream as ErrAborted with
ctx.Err() formatted in rather than wrapped, so errors.Is cannot be
trusted to tell a /stop from a fault.

Closes #467
2026-08-14 02:36:12 +10:00

594 lines
17 KiB
Go

package webui
import (
"context"
"encoding/json"
"fmt"
"net/http"
"reflect"
"strings"
"sync"
"github.com/google/uuid"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
// ChatService is the shared conversational surface exposed to the dashboard.
// It deliberately contains the gateway Router rather than duplicating command
// dispatch in the HTTP layer.
type ChatService struct {
Router *gateway.Router
Sessions gateway.SessionStore
Turns *gateway.Turns
Models gateway.ModelManager
Personas *gateway.PersonaRegistry
Updates ChatUpdateService
Dangerous *DangerousService
updateMu sync.Mutex
updateInProgress bool
}
// ChatUpdateService is the shared release workflow used by chat gateways.
// The web adapter uses recipient zero for the locally authenticated operator.
type ChatUpdateService interface {
Check(context.Context, int64) (releaseupdate.Snapshot, error)
Defer(context.Context, int64, releaseupdate.Snapshot) error
Install(context.Context, func(string)) error
CanInstall() bool
}
type chatMessageRequest struct {
ChannelID string `json:"channel_id"`
SourceID string `json:"source_id"`
Text string `json:"text"`
}
type chatPersonaRequest struct {
SessionID string `json:"session_id"`
Name string `json:"name"`
}
type chatCancelRequest struct {
SessionID string `json:"session_id"`
}
type chatUpdateRequest struct {
Snapshot releaseupdate.Snapshot `json:"snapshot"`
}
type dangerousRequest struct {
Spec string `json:"spec"`
}
type dangerousDecisionRequest struct {
Decision string `json:"decision"`
}
func (s *Server) chatReady(w http.ResponseWriter) (*ChatService, bool) {
if s.Chat == nil || s.Chat.Router == nil || s.Chat.Sessions == nil {
http.Error(w, "chat is not configured", http.StatusNotImplemented)
return nil, false
}
if !chatUpdateServiceConfigured(s.Chat.Router.Updates) && chatUpdateServiceConfigured(s.Chat.Updates) {
s.Chat.Router.Updates = s.Chat.Updates
}
if s.Chat.Router.Dangerous == nil && s.Chat.Dangerous != nil {
s.Chat.Router.Dangerous = s.Chat.Dangerous
}
return s.Chat, true
}
func chatUpdateServiceConfigured(updates ChatUpdateService) bool {
if updates == nil {
return false
}
value := reflect.ValueOf(updates)
switch value.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
return !value.IsNil()
default:
return true
}
}
func (s *Server) handleChatSessions(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
sessions, err := chat.Sessions.List(r.Context())
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
out := make([]gateway.SessionContext, 0, len(sessions))
for _, session := range sessions {
if session.Source.Platform == "web" {
out = append(out, session)
}
}
writeJSON(w, map[string]any{
"sessions": out,
"models": modelNames(chat.Models),
"models_by_provider": modelsByProvider(chat.Models),
"providers": modelProviders(chat.Models),
"active_model": activeModel(chat.Models),
"active_provider": activeProvider(chat.Models),
"personas": personaNames(chat.Personas),
"active_personas": activePersonas(chat.Personas, out),
"commands": chatCommandSpecs(chat),
"restart_available": chat.Router.Restart != nil,
"dangerous_available": chat.Dangerous != nil,
})
}
func chatCommandSpecs(chat *ChatService) []gateway.CommandSpec {
specs := gateway.LocalCommandSpecs()
if chat.Dangerous != nil {
specs = append(specs,
gateway.CommandSpec{Command: "/rollback", Description: "Request approval to restore a filesystem checkpoint", Usage: "/rollback [number]"},
gateway.CommandSpec{Command: "/stop", Description: "Request approval to terminate a background process", Usage: "/stop <process-name>"},
gateway.CommandSpec{Command: "/deny", Description: "Deny a pending dangerous action", Usage: "/deny <action-id>"},
)
}
return specs
}
func (s *Server) handleChatMessages(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
sessionID := r.PathValue("id")
session, err := chat.Sessions.Get(r.Context(), sessionID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if session == nil || session.Source.Platform != "web" {
http.Error(w, "session not found", http.StatusNotFound)
return
}
messages, err := chat.Sessions.RecentMessages(r.Context(), sessionID, 200)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
writeJSON(w, messages)
}
func (s *Server) decodeChatMessage(w http.ResponseWriter, r *http.Request) (gateway.Message, bool) {
var req chatMessageRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid chat message", http.StatusBadRequest)
return gateway.Message{}, false
}
req.Text = strings.TrimSpace(req.Text)
if req.Text == "" || req.ChannelID == "" {
http.Error(w, "text and channel_id are required", http.StatusBadRequest)
return gateway.Message{}, false
}
if req.SourceID == "" {
req.SourceID = newChatSourceID()
}
return gateway.Message{
SourceID: req.SourceID, ChannelID: req.ChannelID,
ThreadID: "", From: "web", Text: req.Text,
}, true
}
func (s *Server) handleChatMessage(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
msg, ok := s.decodeChatMessage(w, r)
if !ok {
return
}
reply, err := chat.Router.Route(r.Context(), msg)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
sessionID, err := chat.Router.ResolveSessionKey(r.Context(), msg)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
writeJSON(w, map[string]string{"reply": reply, "session_id": sessionID})
}
// chatStreamEvent is one `data: {...}` frame of the chat stream. A tool frame
// names the tool in Tool and carries its one-line outcome in Text, so the
// browser can style the two apart instead of parsing a rendered string.
//
// Text is always emitted, empty or not: the browser concatenates it and
// assigns it, so a missing key would put the string "undefined" into the
// transcript on a turn whose reply is empty.
type chatStreamEvent struct {
Type string `json:"type"`
Text string `json:"text"`
Tool string `json:"tool,omitempty"`
SessionID string `json:"session_id,omitempty"`
}
// chatStreamSink adapts the stream writer to gateway.TurnStream so text and
// tool activity reach the browser through one ordered path.
type chatStreamSink func(chatStreamEvent)
func (f chatStreamSink) Delta(text string) {
f(chatStreamEvent{Type: "delta", Text: text})
}
func (f chatStreamSink) ToolCall(event gateway.ToolCallEvent) {
f(chatStreamEvent{Type: "tool", Tool: event.Name, Text: event.Summary()})
}
func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
msg, ok := s.decodeChatMessage(w, r)
if !ok {
return
}
flusher, ok := w.(http.Flusher)
if !ok {
http.Error(w, "streaming unsupported", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("X-Accel-Buffering", "no")
writeChatEvent := func(event chatStreamEvent, sessionID string) {
event.SessionID = sessionID
payload, _ := json.Marshal(event)
_, _ = fmt.Fprintf(w, "data: %s\n\n", payload)
flusher.Flush()
}
sessionID, err := chat.Router.ResolveSessionKey(r.Context(), msg)
if err != nil {
writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, "")
return
}
writeChatEvent(chatStreamEvent{Type: "started"}, sessionID)
var reply string
if chat.Turns == nil {
reply, err = chat.Router.RouteStream(r.Context(), msg, chatStreamSink(func(event chatStreamEvent) {
writeChatEvent(event, sessionID)
}))
} else {
type turnResult struct {
reply string
err error
}
// One channel carries both text and tool events, because the
// order between them is the point: a tool line that overtakes
// the sentence it interrupted describes a turn that never
// happened.
events := make(chan chatStreamEvent, 32)
result := make(chan turnResult, 1)
chat.Turns.Submit(r.Context(), sessionID, func(turnCtx context.Context) {
turnReply, turnErr := chat.Router.RouteStream(turnCtx, msg, chatStreamSink(func(event chatStreamEvent) {
select {
case events <- event:
case <-r.Context().Done():
}
}))
result <- turnResult{reply: turnReply, err: turnErr}
})
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
case turn := <-result:
for {
select {
case event := <-events:
writeChatEvent(event, sessionID)
default:
goto drained
}
}
drained:
reply, err = turn.reply, turn.err
goto turnDone
case <-r.Context().Done():
chat.Turns.Stop(sessionID)
return
}
}
turnDone:
}
if err != nil {
writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, sessionID)
return
}
if resolved, resolveErr := chat.Router.ResolveSessionKey(r.Context(), msg); resolveErr == nil {
sessionID = resolved
}
writeChatEvent(chatStreamEvent{Type: "done", Text: reply}, sessionID)
}
func (s *Server) handleChatCancel(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if chat.Turns == nil {
http.Error(w, "chat cancellation is not configured", http.StatusNotImplemented)
return
}
var req chatCancelRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SessionID == "" {
http.Error(w, "session_id is required", http.StatusBadRequest)
return
}
session, err := chat.Sessions.Get(r.Context(), req.SessionID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if session == nil || session.Source.Platform != "web" {
http.Error(w, "session not found", http.StatusNotFound)
return
}
cancelled, dropped := chat.Turns.Stop(req.SessionID)
writeJSON(w, map[string]any{"cancelled": cancelled, "dropped": dropped})
}
func (s *Server) handleChatPersona(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if chat.Personas == nil {
http.Error(w, "personality switching is not configured", http.StatusNotImplemented)
return
}
var req chatPersonaRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.SessionID == "" || req.Name == "" {
http.Error(w, "session_id and name are required", http.StatusBadRequest)
return
}
if session, err := chat.Sessions.Get(r.Context(), req.SessionID); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
} else if session == nil || session.Source.Platform != "web" {
http.Error(w, "session not found", http.StatusNotFound)
return
}
if !chat.Personas.SetActive(req.SessionID, strings.ToLower(req.Name)) {
http.Error(w, fmt.Sprintf("unknown personality %q", req.Name), http.StatusBadRequest)
return
}
writeJSON(w, map[string]any{"ok": true, "name": strings.ToLower(req.Name)})
}
func (s *Server) handleChatUpdate(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if !chatUpdateServiceConfigured(chat.Updates) {
http.Error(w, "updates are not configured", http.StatusNotImplemented)
return
}
snapshot, err := chat.Updates.Check(r.Context(), 0)
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
writeJSON(w, map[string]any{
"snapshot": snapshot,
"available": snapshot.Available(),
"can_install": chat.Updates.CanInstall(),
})
}
func (s *Server) handleChatUpdateDefer(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if !chatUpdateServiceConfigured(chat.Updates) {
http.Error(w, "updates are not configured", http.StatusNotImplemented)
return
}
var req chatUpdateRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid update snapshot", http.StatusBadRequest)
return
}
if err := chat.Updates.Defer(r.Context(), 0, req.Snapshot); err != nil {
http.Error(w, err.Error(), http.StatusConflict)
return
}
writeJSON(w, map[string]bool{"ok": true})
}
func (s *Server) handleChatUpdateInstall(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if !chatUpdateServiceConfigured(chat.Updates) || !chat.Updates.CanInstall() {
http.Error(w, "update installation is not configured", http.StatusNotImplemented)
return
}
var req chatUpdateRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || len(req.Snapshot.Available()) == 0 {
http.Error(w, "the displayed update snapshot is required", http.StatusBadRequest)
return
}
fresh, err := chat.Updates.Check(r.Context(), 0)
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
if !releaseupdate.SameAvailable(fresh, req.Snapshot) {
http.Error(w, "available releases changed; check again", http.StatusConflict)
return
}
chat.updateMu.Lock()
if chat.updateInProgress {
chat.updateMu.Unlock()
http.Error(w, "an update is already in progress", http.StatusConflict)
return
}
chat.updateInProgress = true
chat.updateMu.Unlock()
defer func() {
chat.updateMu.Lock()
chat.updateInProgress = false
chat.updateMu.Unlock()
}()
progress := make([]string, 0, 4)
err = chat.Updates.Install(r.Context(), func(message string) { progress = append(progress, message) })
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
writeJSON(w, map[string]any{"ok": true, "progress": progress})
}
func (s *Server) handleChatDangerousState(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if chat.Dangerous == nil {
http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented)
return
}
checkpoints, err := chat.Dangerous.Checkpoints(r.Context())
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
writeJSON(w, map[string]any{"checkpoints": checkpoints, "pending": chat.Dangerous.Pending()})
}
func (s *Server) handleChatDangerousRequest(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if chat.Dangerous == nil {
http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented)
return
}
var req dangerousRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.Spec) == "" {
http.Error(w, "spec is required", http.StatusBadRequest)
return
}
action, result, executed, err := chat.Dangerous.Request(r.Context(), r.PathValue("kind"), req.Spec)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
writeJSON(w, map[string]any{"action": action, "result": result, "executed": executed})
}
func (s *Server) handleChatDangerousDecision(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
return
}
if chat.Dangerous == nil {
http.Error(w, "dangerous sandbox actions are not configured", http.StatusNotImplemented)
return
}
var req dangerousDecisionRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || strings.TrimSpace(req.Decision) == "" {
http.Error(w, "decision is required", http.StatusBadRequest)
return
}
result, err := chat.Dangerous.Decide(r.Context(), r.PathValue("id"), req.Decision)
if err != nil {
http.Error(w, err.Error(), http.StatusConflict)
return
}
writeJSON(w, map[string]any{"ok": true, "result": result})
}
func modelNames(models gateway.ModelManager) []string {
if models == nil {
return []string{}
}
return models.Models()
}
func activeModel(models gateway.ModelManager) string {
if models == nil {
return ""
}
return models.ActiveModel()
}
func activeProvider(models gateway.ModelManager) string {
manager, ok := models.(gateway.ProviderModelManager)
if !ok {
return ""
}
return manager.ActiveProvider()
}
func modelProviders(models gateway.ModelManager) []string {
manager, ok := models.(gateway.ProviderModelManager)
if !ok {
return []string{}
}
return manager.Providers()
}
func modelsByProvider(models gateway.ModelManager) map[string][]string {
if models == nil {
return map[string][]string{}
}
if manager, ok := models.(gateway.ProviderModelManager); ok {
groups := make(map[string][]string, len(manager.Providers()))
for _, provider := range manager.Providers() {
groups[provider] = manager.ModelsForProvider(provider)
}
return groups
}
groups := make(map[string][]string)
for _, model := range models.Models() {
provider, _, ok := strings.Cut(model, "/")
if !ok {
provider = ""
}
groups[provider] = append(groups[provider], model)
}
return groups
}
func activePersonas(personas *gateway.PersonaRegistry, sessions []gateway.SessionContext) map[string]string {
active := make(map[string]string, len(sessions))
if personas == nil {
return active
}
for _, session := range sessions {
active[session.SessionID] = personas.ActiveName(session.SessionID)
}
return active
}
func personaNames(personas *gateway.PersonaRegistry) []string {
if personas == nil {
return []string{}
}
return personas.List()
}
func newChatSourceID() string {
return "web-" + uuid.NewString()
}