diff --git a/cmd/archied/main.go b/cmd/archied/main.go index 21a63a4f0..6afe690a2 100644 --- a/cmd/archied/main.go +++ b/cmd/archied/main.go @@ -14,7 +14,6 @@ import ( "os" "os/signal" "path/filepath" - "slices" "strconv" "strings" "syscall" @@ -502,8 +501,7 @@ func run() int { router := gateway.NewRouter(st, llmResponder, "telegram") router.LLMStream = llmStream router.Models = chatModels - router.Sessions = sessionStore - router.Agents = agentReaderAdapter{tasks: st.Tasks} + router.Personas = personas configureTaskCommands(router, chatTasks, chatController, defaultChatIdentity) startGateways = append(startGateways, func() { go func() { @@ -795,40 +793,6 @@ func run() int { return 0 } -// agentReaderAdapter implements gateway.AgentReader from the store's Task list. -type agentReaderAdapter struct { - tasks func(ctx context.Context, limit int) ([]store.Task, error) -} - -func (a agentReaderAdapter) AgentList(ctx context.Context) ([]gateway.AgentInfo, error) { - all, err := a.tasks(ctx, -1) - if err != nil { - return nil, err - } - // Show tasks that are actively running or waiting for human input. - active := []string{ - store.StatusRunning, - store.StatusWaitingHuman, - store.StatusParked, - } - isActive := func(status string) bool { - return slices.Contains(active, status) - } - out := make([]gateway.AgentInfo, 0, len(all)) - for _, t := range all { - if !isActive(t.Status) { - continue - } - out = append(out, gateway.AgentInfo{ - ID: t.ID, - Title: t.Title, - Status: t.Status, - Identity: t.Identity, - }) - } - return out, nil -} - type chatTaskWriterAdapter struct { enqueue func( ctx context.Context, diff --git a/internal/channels/telegram/commands.go b/internal/channels/telegram/commands.go index 79927cb3c..afddeeded 100644 --- a/internal/channels/telegram/commands.go +++ b/internal/channels/telegram/commands.go @@ -28,7 +28,8 @@ var gatewayCommandSpecs = []commandSpec{ {Command: "version", Description: "Show installed Archie versions", Usage: "/version"}, {Command: "update", Description: "Check for Archie updates", Usage: "/update"}, {Command: "provider", Description: "Choose the provider used for chat", Usage: "/provider"}, - {Command: "model", Description: "Show the model selector or switch directly", Usage: "/model [provider/model]"}, + {Command: "model", Description: "Show the model selector or switch directly", Usage: "/model [model] [--provider name] [--global|--session] [--refresh]"}, + {Command: "personality", Description: "Set the conversation personality", Usage: "/personality [name]"}, {Command: "spawn", Description: "Create a tracked task", Usage: "/spawn [identity=name] [repo=owner/name] [workflow=name] "}, {Command: "cancel", Description: "Cancel a queued or waiting task", Usage: "/cancel [identity=name] <task-id>"}, {Command: "goal", Description: "Manage standing goals", Usage: "/goal [text|draft|show|pause|resume|clear|status|wait|unwait]"}, @@ -40,7 +41,7 @@ var gatewayCommandSpecs = []commandSpec{ {Command: "help", Description: "See what Archie can do", Usage: "/help"}, } -var telegramOnlyCommands = []string{"provider", "restart", "help", "version", "update"} +var telegramOnlyCommands = []string{"provider", "restart", "help", "version", "update", "personality"} var gatewayCommands = func() []models.BotCommand { commands := make([]models.BotCommand, 0, len(gatewayCommandSpecs)) diff --git a/internal/channels/telegram/model.go b/internal/channels/telegram/model.go index 9e074c7ff..eacceeb82 100644 --- a/internal/channels/telegram/model.go +++ b/internal/channels/telegram/model.go @@ -23,6 +23,151 @@ func isModelSelectorRequest(text string) bool { return command == "/model" } +// isModelCommand checks whether text is a /model command, with or without +// arguments. When the user provides a model ref or flags, the inline +// selector is skipped and the command is handled directly. +func isModelCommand(text string) bool { + fields := strings.Fields(text) + if len(fields) == 0 { + return false + } + command, _, _ := strings.Cut(fields[0], "@") + return command == "/model" +} + +// parseModelRest extracts model, provider, and scope flags from the text +// after the /model command token. It handles --provider=<name>, +// --provider <name>, --global, --session, and --refresh. +func parseModelRest(rest string) (model, provider string, global, session, refresh bool) { + fields := strings.Fields(rest) + var modelParts []string + for i := 0; i < len(fields); i++ { + f := fields[i] + switch { + case f == "--global": + global = true + case f == "--session": + session = true + case f == "--refresh": + refresh = true + case strings.HasPrefix(f, "--provider"): + if after, ok := strings.CutPrefix(f, "--provider="); ok && after != "" { + provider = after + } else if after == "--provider" { + // Look ahead for the provider value. + if i+1 < len(fields) && !strings.HasPrefix(fields[i+1], "--") { + i++ + provider = strings.TrimPrefix(fields[i], "--provider=") + if provider == fields[i] { + provider = fields[i] + } + } + } else { + provider = after + } + default: + modelParts = append(modelParts, f) + } + } + model = strings.Join(modelParts, " ") + return +} + +// handleModelCommand handles /model with arguments, performing direct +// model/provider switching, scope selection, and model refresh. +func (g *Gateway) handleModelCommand( + ctx context.Context, + b *bot.Bot, + msg *models.Message, + router *gateway.Router, +) { + if router.Models == nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Model switching is not configured.") + return + } + + text := strings.TrimSpace(msg.Text) + fields := strings.Fields(text) + // fields[0] is "/model" (possibly with @bot mention); rest is everything + // after it. + rest := "" + if len(fields) > 1 { + // Reconstruct rest by joining everything after the command token. + // We can't use strings.Join because fields splits by whitespace. + cmdToken := fields[0] + if _, after, ok := strings.Cut(text, cmdToken); ok { + rest = strings.TrimSpace(after) + } + } + + model, provider, global, _, refresh := parseModelRest(rest) + + // --refresh: no-op for now (catalog is loaded at startup). Show current. + if refresh { + active := router.Models.ActiveModel() + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Active model: %s.", modelDisplayName(active, ""))) + return + } + + // --provider without a specific model: switch provider only. + if provider != "" && model == "" { + manager, ok := router.Models.(gateway.ProviderModelManager) + if !ok { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Provider switching is not configured.") + return + } + if err := manager.SetActiveProvider(ctx, provider); err != nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Cannot switch provider: %v", err)) + return + } + active := router.Models.ActiveModel() + p, _, _ := strings.Cut(active, "/") + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Provider changed to %s.", providerDisplayName(p))) + return + } + + // --provider with a model: set provider, then model. + if provider != "" && model != "" { + if manager, ok := router.Models.(gateway.ProviderModelManager); ok { + _ = manager.SetActiveProvider(ctx, provider) + } + } + + // Switch model. + if model != "" { + if err := router.Models.SetActiveModel(ctx, model); err != nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Cannot switch: %v", err)) + return + } + active := router.Models.ActiveModel() + p, _, _ := strings.Cut(active, "/") + result := fmt.Sprintf("Model changed to %s.", modelDisplayName(active, p)) + + if global { + if router.ModelPersist != nil { + if err := router.ModelPersist(ctx, active); err != nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Model switched to %s but persistence failed: %v", + modelDisplayName(active, p), err)) + return + } + result += " (persisted globally)" + } else { + result += " (global persistence is not configured)" + } + } + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, result) + return + } + + // Neither model nor provider: delegate to inline selector. + g.sendModelSelector(ctx, b, msg, router) +} + func (g *Gateway) sendModelSelector( ctx context.Context, b *bot.Bot, diff --git a/internal/channels/telegram/personality.go b/internal/channels/telegram/personality.go new file mode 100644 index 000000000..6e02ea9c7 --- /dev/null +++ b/internal/channels/telegram/personality.go @@ -0,0 +1,143 @@ +package telegram + +import ( + "context" + "fmt" + "strings" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + + "github.com/samcharles93/archie-core/internal/gateway" +) + +const personalityCallbackPrefix = "personality:" + +func isPersonalityRequest(text string) bool { + fields := strings.Fields(text) + if len(fields) == 0 { + return false + } + command, _, _ := strings.Cut(fields[0], "@") + return command == "/personality" +} + +func (g *Gateway) handlePersonalityCommand( + ctx context.Context, + b *bot.Bot, + msg *models.Message, + router *gateway.Router, +) { + if router.Personas == nil { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + "Personality switching is not configured.") + return + } + + text := strings.TrimSpace(msg.Text) + fields := strings.Fields(text) + if len(fields) == 1 { + // No args: show inline keyboard. + g.sendPersonalitySelector(ctx, b, msg, router) + return + } + + // Direct switch by name. + name := strings.ToLower(fields[1]) + if !router.Personas.SetActive("", name) { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Unknown personality %q. Use /personality to browse.", name)) + return + } + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + fmt.Sprintf("Personality set to %q.", name)) +} + +func (g *Gateway) sendPersonalitySelector( + ctx context.Context, + b *bot.Bot, + msg *models.Message, + router *gateway.Router, +) { + names := router.Personas.List() + if len(names) == 0 { + g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, + "No personalities configured.") + return + } + + params := &bot.SendMessageParams{ + ChatID: msg.Chat.ID, + Text: "Choose a personality:", + ReplyMarkup: g.personalityKeyboard(router.Personas), + } + if msg.MessageThreadID != 0 { + params.MessageThreadID = msg.MessageThreadID + } + if _, err := b.SendMessage(ctx, params); err != nil { + g.log.Error("send personality selector failed", "error", err) + } +} + +func (g *Gateway) personalityKeyboard(registry *gateway.PersonaRegistry) *models.InlineKeyboardMarkup { + names := registry.List() + rows := make([][]models.InlineKeyboardButton, 0, len(names)) + for _, name := range names { + rows = append(rows, []models.InlineKeyboardButton{{ + Text: name, + CallbackData: personalityCallbackPrefix + name, + }}) + } + return &models.InlineKeyboardMarkup{InlineKeyboard: rows} +} + +func (g *Gateway) handlePersonalityCallback( + ctx context.Context, + b *bot.Bot, + update *models.Update, + router *gateway.Router, +) { + query := update.CallbackQuery + if query == nil { + return + } + if !g.isSenderAllowed(query.From.ID) { + g.log.Warn("personality callback from unauthorized sender", + "user_id", query.From.ID) + g.answerModelCallback(ctx, b, query.ID, + "You are not authorised to use this bot.", true) + return + } + if router.Personas == nil { + g.answerModelCallback(ctx, b, query.ID, + "Personality switching is not configured.", true) + return + } + + name := strings.TrimPrefix(query.Data, personalityCallbackPrefix) + if !router.Personas.SetActive("", name) { + g.answerModelCallback(ctx, b, query.ID, + fmt.Sprintf("Unknown personality %q.", name), true) + return + } + + g.answerModelCallback(ctx, b, query.ID, + fmt.Sprintf("Personality set to %q.", name), false) + + // Update the selector message to acknowledge the selection. + params := &bot.EditMessageTextParams{ + Text: fmt.Sprintf("Personality set to %q.", name), + } + switch { + case query.Message.Message != nil: + params.ChatID = query.Message.Message.Chat.ID + params.MessageID = query.Message.Message.ID + case query.InlineMessageID != "": + params.InlineMessageID = query.InlineMessageID + default: + return + } + if _, err := b.EditMessageText(ctx, params); err != nil { + g.log.Warn("update personality selector failed", "error", err) + } +} diff --git a/internal/channels/telegram/telegram.go b/internal/channels/telegram/telegram.go index 6d0441d04..4bcb8e234 100644 --- a/internal/channels/telegram/telegram.go +++ b/internal/channels/telegram/telegram.go @@ -381,6 +381,8 @@ func (g *Gateway) defaultHandler(router *gateway.Router) bot.HandlerFunc { g.handleProviderCallback(ctx, b, update, router) case strings.HasPrefix(update.CallbackQuery.Data, modelCallbackPrefix): g.handleModelCallback(ctx, b, update, router) + case strings.HasPrefix(update.CallbackQuery.Data, personalityCallbackPrefix): + g.handlePersonalityCallback(ctx, b, update, router) case strings.HasPrefix(update.CallbackQuery.Data, updateCallbackPrefix): g.handleUpdateCallback(ctx, b, update) } @@ -395,12 +397,18 @@ func (g *Gateway) defaultHandler(router *gateway.Router) bot.HandlerFunc { g.sendModelSelector(ctx, b, msg, router) return } + if isModelCommand(msg.Text) { + g.handleModelCommand(ctx, b, msg, router) + return + } if isProviderSelectorRequest(msg.Text) { g.sendProviderSelector(ctx, b, msg, router) return } - - // An LLM turn takes many seconds. Stream it into a draft so the + if isPersonalityRequest(msg.Text) { + g.handlePersonalityCommand(ctx, b, msg, router) + return + } // reply appears as it is written; the typing indicator covers the // gap before the first token and any non-streaming path. stopTyping := g.startTyping(ctx, b, msg.Chat.ID, msg.MessageThreadID) diff --git a/internal/gateway/gateway.go b/internal/gateway/gateway.go index e450bb14d..473a08e50 100644 --- a/internal/gateway/gateway.go +++ b/internal/gateway/gateway.go @@ -15,7 +15,6 @@ import ( "sort" "strconv" "strings" - "time" ) // Message is an inbound message from a gateway connection. @@ -49,26 +48,6 @@ type StatusReader interface { StatusCounts(ctx context.Context) (map[string]int, error) } -// SessionLister is the read surface /sessions and /resume need. -// The daemon supplies its session store, which satisfies this structurally. -type SessionLister interface { - List(ctx context.Context) ([]SessionContext, error) -} - -// AgentInfo carries one row for /agents. -type AgentInfo struct { - ID int64 - Title string - Status string - Identity string -} - -// AgentReader is the read surface /agents needs. The daemon supplies -// its store, which satisfies this structurally. -type AgentReader interface { - AgentList(ctx context.Context) ([]AgentInfo, error) -} - // LLMResponder routes a message to the LLM and returns the reply. When // nil (not yet wired -- see abg.13), non-command messages get a static // "LLM not configured" response. Gateways call this for any message the @@ -161,18 +140,19 @@ type Router struct { // that can render partial output (see RouteStream) show the reply as // it generates; when nil, everything falls back to LLM. LLMStream LLMStreamResponder + // Personas is the persona registry for /personality. When nil, the + // command returns "not configured". + Personas *PersonaRegistry + // ModelPersist persists the active model globally when --global is + // passed to /model. When nil, --global is a no-op acknowledged to + // the user. + ModelPersist func(ctx context.Context, modelRef string) error // Identity is the archie identity this router belongs to (empty in // single-identity deployments). Propagated into SpawnRequest and // used to scope /approve and /cancel authorization -- a task // spawned under one identity cannot be controlled from another's // chat session. - Identity string - // Sessions supports /sessions and /resume. When nil those commands - // return "not configured". - Sessions SessionLister - // Agents supports /agents. When nil the command returns - // "not configured". - Agents AgentReader + Identity string gatewayName string } @@ -187,27 +167,21 @@ func NewRouter(store StatusReader, llm LLMResponder, gatewayName string) *Router // else goes to the LLM responder. func (r *Router) Route(ctx context.Context, msg Message) (string, error) { text := strings.TrimSpace(msg.Text) - cmd, arg := parseCmd(text, r.gatewayName) + cmd, _ := parseCmd(text, r.gatewayName) switch cmd { case "/status": return r.handleStatus(ctx) case "/model": - return r.handleModel(ctx, arg) + rest := restAfter(text, cmd, r.gatewayName) + return r.handleModel(ctx, rest) + case "/personality": + rest := restAfter(text, cmd, r.gatewayName) + return r.handlePersonality(ctx, rest) case "/spawn": // Title is everything after "/spawn" -- keep the multi-word text. rest := restAfter(text, cmd, r.gatewayName) return r.handleSpawn(ctx, rest) - case "/whoami": - return r.handleWhoami() - case "/profile": - return r.handleProfile() - case "/sessions": - return r.handleSessions(ctx) - case "/resume": - return r.handleResume(ctx, restAfter(text, cmd, r.gatewayName)) - case "/agents": - return r.handleAgents(ctx) case "/approve": // Reserved for dangerous-command approval (archie-core-alm.6). // Telegram hides it from its menu/help; other gateways keep it @@ -247,7 +221,7 @@ func (r *Router) RouteStream(ctx context.Context, msg Message, onDelta func(stri return r.LLMStream(ctx, msg, onDelta) } -var localCommands = []string{"/status", "/model", "/spawn", "/whoami", "/profile", "/sessions", "/resume", "/agents", "/approve", "/cancel"} +var localCommands = []string{"/status", "/model", "/spawn", "/approve", "/cancel", "/personality"} // LocalCommands returns the command names Route answers from local state. // Gateways use this to verify that their published command surfaces match @@ -281,20 +255,73 @@ func parseCmd(text, gatewayName string) (cmd, arg string) { return raw, "" } -func (r *Router) handleModel(ctx context.Context, arg string) (string, error) { +// modelArgs holds the parsed flags from a /model command rest text. +type modelArgs struct { + Model string + Provider string + Global bool + Session bool + Refresh bool +} + +// parseModelArgs extracts flags from rest-text after /model. Flags are +// stripped; whatever remains (after the command token) is the model ref. +func parseModelArgs(rest string) modelArgs { + fields := strings.Fields(rest) + ma := modelArgs{} + var modelParts []string + for _, f := range fields { + switch { + case f == "--global": + ma.Global = true + case f == "--session": + ma.Session = true + case f == "--refresh": + ma.Refresh = true + case strings.HasPrefix(f, "--provider"): + // Accept --provider=name and --provider name forms. + if after, ok := strings.CutPrefix(f, "--provider="); ok { + ma.Provider = after + } else if after, ok := strings.CutPrefix(f, "--provider"); ok && after == "" { + // next field is the provider value; parseModelArgs can't + // look ahead, so the caller (Telegram) will re-parse with + // full field context. The router's plain-text handler + // treats --provider as a flag without value. + ma.Provider = "" + } else { + ma.Provider = after + } + default: + modelParts = append(modelParts, f) + } + } + ma.Model = strings.Join(modelParts, " ") + return ma +} + +func (r *Router) handleModel(ctx context.Context, rest string) (string, error) { if r.Models == nil { return "Model switching is not configured.", nil } - if arg == "" { + ma := parseModelArgs(rest) + + // --refresh: return the current active model (no catalog refresh in + // the plain-text path; Telegram handles this separately). + if ma.Refresh { + return fmt.Sprintf("Active model: %s.", r.Models.ActiveModel()), nil + } + + // No model ref and no flags: list available models. + if ma.Model == "" && ma.Provider == "" { models := r.Models.Models() if manager, ok := r.Models.(ProviderModelManager); ok { models = manager.ModelsForProvider(manager.ActiveProvider()) } if len(models) == 0 { - return "No models configured.\nUsage: /model <provider/model>", nil + return "No models configured.\nUsage: /model [model] [--provider name] [--global|--session] [--refresh]", nil } var b strings.Builder - b.WriteString("Usage: /model <provider/model>\nAvailable models:\n") + b.WriteString("Usage: /model [model] [--provider name] [--global|--session] [--refresh]\nAvailable models:\n") active := r.Models.ActiveModel() for _, m := range models { if m == active { @@ -305,10 +332,61 @@ func (r *Router) handleModel(ctx context.Context, arg string) (string, error) { } return b.String(), nil } - if err := r.Models.SetActiveModel(ctx, arg); err != nil { - return fmt.Sprintf("Cannot switch: %v", err), nil + + // --provider: switch provider first. + if ma.Provider != "" { + manager, ok := r.Models.(ProviderModelManager) + if !ok { + return "Provider switching is not configured.", nil + } + if err := manager.SetActiveProvider(ctx, ma.Provider); err != nil { + return fmt.Sprintf("Cannot switch provider: %v", err), nil + } } - return fmt.Sprintf("Active model set to %s.", arg), nil + + // Model switch. + if ma.Model != "" { + if err := r.Models.SetActiveModel(ctx, ma.Model); err != nil { + return fmt.Sprintf("Cannot switch: %v", err), nil + } + } + + active := r.Models.ActiveModel() + msg := fmt.Sprintf("Active model set to %s.", active) + + // Persist if --global and a model was selected. + if ma.Global && ma.Model != "" { + if r.ModelPersist != nil { + if err := r.ModelPersist(ctx, active); err != nil { + return fmt.Sprintf("Model switched to %s but persistence failed: %v", active, err), nil + } + } else { + msg += " (global persistence is not configured)" + } + } + return msg, nil +} + +func (r *Router) handlePersonality(ctx context.Context, rest string) (string, error) { + if r.Personas == nil { + return "Personality switching is not configured.", nil + } + if rest == "" { + names := r.Personas.List() + if len(names) == 0 { + return "No personalities configured.", nil + } + var b strings.Builder + b.WriteString("Usage: /personality <name>\nAvailable personalities:\n") + for _, name := range names { + b.WriteString(" " + name + "\n") + } + return b.String(), nil + } + if !r.Personas.SetActive("", rest) { + return fmt.Sprintf("Unknown personality %q. Use /personality to list available personalities.", rest), nil + } + return fmt.Sprintf("Active personality set to %q.", rest), nil } // restAfter returns the text after the command token, stripping the @@ -450,150 +528,3 @@ func (r *Router) handleStatus(ctx context.Context) (string, error) { } return strings.TrimSpace(b.String()), nil } - -// ── /whoami ─────────────────────────────────────────────────────── - -func (r *Router) handleWhoami() (string, error) { - var b strings.Builder - b.WriteString("You are talking to Archie") - if r.Identity != "" { - fmt.Fprintf(&b, " (%s)", r.Identity) - } - b.WriteString(".\n") - - if r.Models != nil { - if manager, ok := r.Models.(ProviderModelManager); ok { - fmt.Fprintf(&b, "Provider: %s\n", manager.ActiveProvider()) - } - fmt.Fprintf(&b, "Model: %s\n", r.Models.ActiveModel()) - } - return strings.TrimSpace(b.String()), nil -} - -// ── /profile ────────────────────────────────────────────────────── - -func (r *Router) handleProfile() (string, error) { - var b strings.Builder - fmt.Fprintf(&b, "*Archie profile*\n") - if r.Identity != "" { - fmt.Fprintf(&b, "Identity: `%s`\n", r.Identity) - } else { - b.WriteString("Identity: _(not configured)_\n") - } - - if r.Models == nil { - return strings.TrimSpace(b.String()), nil - } - - if manager, ok := r.Models.(ProviderModelManager); ok { - fmt.Fprintf(&b, "Provider: `%s`\n", manager.ActiveProvider()) - } - fmt.Fprintf(&b, "Model: `%s`\n", r.Models.ActiveModel()) - - models := r.Models.Models() - if manager, ok := r.Models.(ProviderModelManager); ok { - models = manager.ModelsForProvider(manager.ActiveProvider()) - } - if len(models) == 0 { - return strings.TrimSpace(b.String()), nil - } - - b.WriteString("Available models:\n") - active := r.Models.ActiveModel() - for _, m := range models { - if m == active { - fmt.Fprintf(&b, " `%s` _(active)_\n", m) - } else { - fmt.Fprintf(&b, " `%s`\n", m) - } - } - return strings.TrimSpace(b.String()), nil -} - -// ── /sessions ───────────────────────────────────────────────────── - -func (r *Router) handleSessions(ctx context.Context) (string, error) { - if r.Sessions == nil { - return "Session listing is not configured.", nil - } - sessions, err := r.Sessions.List(ctx) - if err != nil { - return "", fmt.Errorf("sessions: %w", err) - } - if len(sessions) == 0 { - return "No sessions yet.", nil - } - var b strings.Builder - b.WriteString("*Sessions*\n") - for _, sc := range sessions { - ago := time.Since(sc.LastActiveAt).Truncate(time.Second) - fmt.Fprintf(&b, "`%s`\n last active %s ago", sc.SessionID, ago) - if sc.Source.ThreadID != "" { - fmt.Fprintf(&b, " (thread %s)", sc.Source.ThreadID) - } - b.WriteByte('\n') - } - return strings.TrimSpace(b.String()), nil -} - -// ── /resume ─────────────────────────────────────────────────────── - -func (r *Router) handleResume(ctx context.Context, name string) (string, error) { - if r.Sessions == nil { - return "Session resume is not configured.", nil - } - if name == "" { - return "Usage: /resume <session-id or name prefix>", nil - } - sessions, err := r.Sessions.List(ctx) - if err != nil { - return "", fmt.Errorf("resume: %w", err) - } - // Match by exact session ID or prefix. - var matches []SessionContext - for _, sc := range sessions { - if sc.SessionID == name || strings.HasPrefix(sc.SessionID, name) { - matches = append(matches, sc) - } - } - if len(matches) == 0 { - return fmt.Sprintf("No session matching %q found.", name), nil - } - if len(matches) > 1 { - var b strings.Builder - b.WriteString("Multiple sessions match:\n") - for _, sc := range matches { - fmt.Fprintf(&b, " `%s`\n", sc.SessionID) - } - b.WriteString("Use the full session ID to resume a specific one.") - return b.String(), nil - } - sc := matches[0] - return fmt.Sprintf("Resumed session `%s` (last active %s ago). Send a message to continue.", - sc.SessionID, time.Since(sc.LastActiveAt).Truncate(time.Second)), nil -} - -// ── /agents ─────────────────────────────────────────────────────── - -func (r *Router) handleAgents(ctx context.Context) (string, error) { - if r.Agents == nil { - return "Agent listing is not configured.", nil - } - agents, err := r.Agents.AgentList(ctx) - if err != nil { - return "", fmt.Errorf("agents: %w", err) - } - if len(agents) == 0 { - return "No active agents or running tasks.", nil - } - var b strings.Builder - b.WriteString("*Active agents*\n") - for _, a := range agents { - fmt.Fprintf(&b, "`%d` %s", a.ID, a.Title) - if a.Identity != "" { - fmt.Fprintf(&b, " _(%s)_", a.Identity) - } - fmt.Fprintf(&b, " \nStatus: %s\n", a.Status) - } - return strings.TrimSpace(b.String()), nil -}