Files
archie/internal/channels/telegram/model.go
T
sam e3b1a859a8 feat(gateway): flip channel boundary onto messaging.Message
Replaced gateway.Message as the currency at the channel-facing boundary
with the canonical internal/domain/messaging.Message. Channel adapters
now build the record directly (RoleUser, ConversationID, Sender) and the
Router hands it back unchanged, so nothing converts between two shapes in
process. gateway.Message is deleted; the dashboard route that had no home
in the record lives in a new Inbound envelope (Message + transport-only
Page), which reaches the system prompt and is never persisted.

Role is now set at construction instead of derived at the store boundary,
and the assistant reply is a direct messaging.Message (RoleAssistant,
Sender=botUser). The gRPC proto is unchanged: pb.Message still carries no
role, and both sides keep deriving it from the owning session's bot
identity via gateway.RoleForSender (ToStoredMessage/FromStoredMessage are
deleted).

Adds tests that the old shape could not express: Page reaches the system
prompt but not the persisted record, and a channel-built Inbound round-trips
with the Role the channel set.

Refs: archie-core-9g5e
2026-09-09 01:05:36 +10:00

578 lines
18 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package telegram
import (
"context"
"crypto/sha256"
"fmt"
"strings"
"github.com/go-telegram/bot"
"github.com/go-telegram/bot/models"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/gateway"
)
const (
modelCallbackPrefix = "model:"
modelPageCallbackPrefix = "modelpage:"
modelBackCallback = "modelback"
modelCancelCallback = "modelcancel"
modelNoopCallback = "modelnoop"
modelPageSize = 8
)
type modelPage struct {
Provider string
Page int
}
func isModelSelectorRequest(text string) bool {
fields := strings.Fields(text)
if len(fields) != 1 {
return false
}
command, _, _ := strings.Cut(fields[0], "@")
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) {
provider, fields := splitProviderFlag(strings.Fields(rest))
var modelParts []string
for _, f := range fields {
switch f {
case "--global":
global = true
case "--session":
session = true
case "--refresh":
refresh = true
default:
modelParts = append(modelParts, f)
}
}
model = strings.Join(modelParts, " ")
return model, provider, global, session, refresh
}
// splitProviderFlag extracts --provider=<value> or --provider <value> and
// returns the provider along with the fields that remain. It is the only place
// the surviving fields are accumulated: an earlier version handed a shared
// slice to the helper and appended to it again in the caller's loop, so every
// model name was doubled ("/model gpt-4o" asked for "gpt-4o gpt-4o"). A
// space-separated provider value is removed with its flag rather than left in
// the remainder, where it would be joined into the model name.
func splitProviderFlag(fields []string) (provider string, remaining []string) {
for i := 0; i < len(fields); i++ {
f := fields[i]
if !strings.HasPrefix(f, "--provider") {
remaining = append(remaining, f)
continue
}
if after, ok := strings.CutPrefix(f, "--provider="); ok {
provider = after
continue
}
// --provider <value> (space-separated)
if i+1 < len(fields) && !strings.HasPrefix(fields[i+1], "--") {
provider = fields[i+1]
i++
}
}
return provider, remaining
}
// 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
}
// A provider-qualified direct selection is one atomic model mutation.
if provider != "" && model != "" {
if !strings.HasPrefix(model, provider+"/") {
model = provider + "/" + model
}
}
// Switch model.
if model != "" {
g.switchModel(ctx, b, msg, router, model, global)
return
}
// Neither model nor provider: delegate to inline selector.
g.sendModelSelector(ctx, b, msg, router)
}
// switchModel activates a model and sends confirmation. When global is true
// the new selection is persisted across restarts.
func (g *Gateway) switchModel(
ctx context.Context,
b *bot.Bot,
msg *models.Message,
router *gateway.Router,
model string,
global bool,
) {
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)
}
func (g *Gateway) sendModelSelector(
ctx context.Context,
b *bot.Bot,
msg *models.Message,
router *gateway.Router,
) {
if router.Models == nil || len(router.Models.Models()) == 0 {
reply, err := router.Route(ctx, gateway.Inbound{
Message: messaging.Message{Role: messaging.RoleUser, Text: "/model"},
})
if err != nil {
g.log.Error("model selector fallback failed", "error", err)
return
}
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, reply)
return
}
params := &bot.SendMessageParams{
ChatID: msg.Chat.ID,
Text: modelSelectorText(router.Models.ActiveModel()),
ReplyMarkup: g.modelSelectorKeyboard(router.Models),
}
if msg.MessageThreadID != 0 {
params.MessageThreadID = msg.MessageThreadID
}
if _, err := b.SendMessage(ctx, params); err != nil {
g.log.Error("send model selector failed", "error", err)
}
}
func modelSelectorText(active string) string {
if active == "" {
return "Select a model:"
}
provider, _, ok := strings.Cut(active, "/")
if !ok {
return "Select a model:\nActive: " + active
}
return "Select a model:\nCurrent Provider: " + providerDisplayName(provider) +
"\nActive: " + modelDisplayName(active, provider)
}
func modelSelectorTextForProvider(provider string, page, count int) string {
start, end := pageBounds(page, count)
return fmt.Sprintf("⚙ Model Configuration\n\nProvider: %s (%d–%d of %d)\nSelect a model:",
providerDisplayName(provider), start+1, end, count)
}
func (g *Gateway) modelSelectorKeyboard(manager gateway.ModelManager) *models.InlineKeyboardMarkup {
provider := ""
if providerManager, ok := manager.(gateway.ProviderModelManager); ok {
provider = providerManager.ActiveProvider()
}
return g.modelSelectorKeyboardForProvider(manager, provider)
}
func (g *Gateway) modelSelectorKeyboardForProvider(manager gateway.ModelManager, provider string) *models.InlineKeyboardMarkup {
return g.modelSelectorKeyboardPage(manager, provider, 0)
}
func (g *Gateway) modelSelectorKeyboardPage(manager gateway.ModelManager, provider string, page int) *models.InlineKeyboardMarkup {
active := manager.ActiveModel()
available := manager.Models()
if providerManager, ok := manager.(gateway.ProviderModelManager); ok {
available = providerManager.ModelsForProvider(provider)
}
start, end := pageBounds(page, len(available))
buttons := make([]models.InlineKeyboardButton, 0, end-start)
for _, model := range available[start:end] {
label := modelDisplayName(model, provider)
if model == active {
label = "✓ " + label
}
buttons = append(buttons, models.InlineKeyboardButton{
Text: label,
CallbackData: g.modelCallbackToken(model),
})
}
rows := make([][]models.InlineKeyboardButton, 0, (len(buttons)+1)/2+2)
for i := 0; i < len(buttons); i += 2 {
rows = append(rows, buttons[i:min(i+2, len(buttons))])
}
pages := max(1, (len(available)+modelPageSize-1)/modelPageSize)
if pages > 1 {
var nav []models.InlineKeyboardButton
if page > 0 {
nav = append(nav, models.InlineKeyboardButton{
Text: "◀ Prev", CallbackData: g.modelPageCallbackToken(provider, page-1),
})
}
nav = append(nav, models.InlineKeyboardButton{
Text: fmt.Sprintf("%d/%d", page+1, pages), CallbackData: modelNoopCallback,
})
if page+1 < pages {
nav = append(nav, models.InlineKeyboardButton{
Text: "Next ▶", CallbackData: g.modelPageCallbackToken(provider, page+1),
})
}
rows = append(rows, nav)
}
rows = append(rows, []models.InlineKeyboardButton{
{Text: "◀ Back", CallbackData: modelBackCallback},
{Text: "✗ Cancel", CallbackData: modelCancelCallback},
})
return &models.InlineKeyboardMarkup{InlineKeyboard: rows}
}
func pageBounds(page, count int) (int, int) {
pages := max(1, (count+modelPageSize-1)/modelPageSize)
page = max(0, min(page, pages-1))
start := page * modelPageSize
return start, min(start+modelPageSize, count)
}
func (g *Gateway) modelPageCallbackToken(provider string, page int) string {
sum := sha256.Sum256(fmt.Appendf(nil, "%s:%d", provider, page))
token := fmt.Sprintf("%s%x", modelPageCallbackPrefix, sum[:24])
g.modelMu.Lock()
g.modelPages[token] = modelPage{Provider: provider, Page: page}
g.modelMu.Unlock()
return token
}
func (g *Gateway) modelPageForCallback(token string) (modelPage, bool) {
g.modelMu.RLock()
defer g.modelMu.RUnlock()
page, ok := g.modelPages[token]
return page, ok
}
// modelCallbackToken records a stable model identity for an inline button.
// A positional index is unsafe: provider changes can reorder the selectable
// list after Telegram has rendered the keyboard.
func (g *Gateway) modelCallbackToken(model string) string {
sum := sha256.Sum256([]byte(model))
// 192 bits keeps the callback well below Telegram's 64-byte limit while
// making a collision infeasible for a configured model catalog.
token := fmt.Sprintf("%s%x", modelCallbackPrefix, sum[:24])
g.modelMu.Lock()
g.modelCallbacks[token] = model
g.modelMu.Unlock()
return token
}
func (g *Gateway) modelForCallback(token string) (string, bool) {
g.modelMu.RLock()
defer g.modelMu.RUnlock()
model, ok := g.modelCallbacks[token]
return model, ok
}
// modelDisplayName removes routing/provider prefixes from a model reference.
// The selected provider is already shown in the selector heading; repeating it
// in every button makes provider-aware selection needlessly noisy.
func modelDisplayName(ref, provider string) string {
name := strings.TrimPrefix(ref, provider+"/")
if slash := strings.LastIndexByte(name, '/'); slash >= 0 {
name = name[slash+1:]
}
return name
}
func (g *Gateway) handleModelCallback(
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("model 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.Models == nil {
g.answerModelCallback(ctx, b, query.ID, "Model switching is not configured.", true)
return
}
selected, ok := g.modelForCallback(query.Data)
if !ok {
g.answerModelCallback(ctx, b, query.ID, "That model selection is no longer valid.", true)
return
}
if err := router.Models.SetActiveModel(ctx, selected); err != nil {
g.answerModelCallback(ctx, b, query.ID, fmt.Sprintf("Cannot switch: %v", err), true)
return
}
provider, _, _ := strings.Cut(selected, "/")
g.answerModelCallback(ctx, b, query.ID,
"The model has been changed to: "+modelDisplayName(selected, provider), false)
g.editModelPicker(ctx, b, query, modelSelectionConfirmation(router.Models, selected), nil)
}
func modelSelectionConfirmation(manager gateway.ModelManager, ref string) string {
provider, _, _ := strings.Cut(ref, "/")
var b strings.Builder
fmt.Fprintf(&b, "Model switched to %s\nProvider: %s",
modelDisplayName(ref, provider), providerDisplayName(provider))
detailed, ok := manager.(gateway.DetailedModelManager)
if !ok {
b.WriteString("\n\n_(active for this daemon process; resets on restart)_")
return b.String()
}
details, ok := detailed.ModelDetails(ref)
if !ok {
b.WriteString("\n\n_(active for this daemon process; resets on restart)_")
return b.String()
}
if details.ContextWindow > 0 {
fmt.Fprintf(&b, "\nContext: %d tokens", details.ContextWindow)
}
if details.MaxOutputTokens > 0 {
fmt.Fprintf(&b, "\nMax output: %d tokens", details.MaxOutputTokens)
}
var capabilities []string
if details.Reasoning {
capabilities = append(capabilities, "reasoning")
}
if details.Tools {
capabilities = append(capabilities, "tools")
}
for _, modality := range details.InputModalities {
if modality != "text" {
capabilities = append(capabilities, modality)
}
}
if details.Attachment {
capabilities = append(capabilities, "attachments")
}
if details.Structured {
capabilities = append(capabilities, "structured output")
}
if len(capabilities) > 0 {
fmt.Fprintf(&b, "\nCapabilities: %s", strings.Join(capabilities, ", "))
}
b.WriteString("\n\n_(active for this daemon process; resets on restart)_")
return b.String()
}
func (g *Gateway) handleModelPageCallback(
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.answerModelCallback(ctx, b, query.ID, "You are not authorised to use this bot.", true)
return
}
manager, ok := router.Models.(gateway.ProviderModelManager)
if !ok {
g.answerModelCallback(ctx, b, query.ID, "Model switching is not configured.", true)
return
}
page, ok := g.modelPageForCallback(query.Data)
if !ok {
g.answerModelCallback(ctx, b, query.ID, "That model page is no longer valid.", true)
return
}
models := manager.ModelsForProvider(page.Provider)
if page.Page < 0 || page.Page*modelPageSize >= len(models) {
g.answerModelCallback(ctx, b, query.ID, "That model page is no longer valid.", true)
return
}
g.answerModelCallback(ctx, b, query.ID, "", false)
g.editModelPicker(ctx, b, query,
modelSelectorTextForProvider(page.Provider, page.Page, len(manager.ModelsForProvider(page.Provider))),
g.modelSelectorKeyboardPage(manager, page.Provider, page.Page))
}
func (g *Gateway) handleModelBackCallback(
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.answerModelCallback(ctx, b, query.ID, "You are not authorised to use this bot.", true)
return
}
manager, ok := router.Models.(gateway.ProviderModelManager)
if !ok {
g.answerModelCallback(ctx, b, query.ID, "Model switching is not configured.", true)
return
}
g.answerModelCallback(ctx, b, query.ID, "", false)
g.editModelPicker(ctx, b, query,
providerSelectorText(manager.ActiveModel(), manager.ActiveProvider()),
g.providerSelectorKeyboard(manager))
}
func (g *Gateway) handleModelCancelCallback(ctx context.Context, b *bot.Bot, update *models.Update) {
query := update.CallbackQuery
if query == nil {
return
}
if !g.isSenderAllowed(query.From.ID) {
g.answerModelCallback(ctx, b, query.ID, "You are not authorised to use this bot.", true)
return
}
g.answerModelCallback(ctx, b, query.ID, "", false)
g.editModelPicker(ctx, b, query, "Model selection cancelled.", nil)
}
func (g *Gateway) handleModelNoopCallback(ctx context.Context, b *bot.Bot, update *models.Update) {
query := update.CallbackQuery
if query == nil {
return
}
if !g.isSenderAllowed(query.From.ID) {
g.answerModelCallback(ctx, b, query.ID, "You are not authorised to use this bot.", true)
return
}
g.answerModelCallback(ctx, b, query.ID, "", false)
}
func (g *Gateway) editModelPicker(
ctx context.Context,
b *bot.Bot,
query *models.CallbackQuery,
text string,
markup *models.InlineKeyboardMarkup,
) {
params := &bot.EditMessageTextParams{Text: text}
if markup != nil {
params.ReplyMarkup = markup
}
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 model picker failed", "error", err)
}
}
func (g *Gateway) answerModelCallback(
ctx context.Context,
b *bot.Bot,
queryID string,
text string,
alert bool,
) {
if _, err := b.AnswerCallbackQuery(ctx, &bot.AnswerCallbackQueryParams{
CallbackQueryID: queryID,
Text: text,
ShowAlert: alert,
}); err != nil {
g.log.Warn("answer model callback failed", "error", err)
}
}