Files
archie/internal/channels/telegram/model.go
T

558 lines
16 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"
)
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.
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,
client messaging.ChatContract,
) {
snap, err := client.Snapshot(ctx)
if err != nil || len(snap.Models) == 0 {
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Model switching is not configured.")
return
}
text := strings.TrimSpace(msg.Text)
fields := strings.Fields(text)
rest := ""
if len(fields) > 1 {
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 {
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID,
fmt.Sprintf("Active model: %s.", modelDisplayName(snap.ActiveModel, "")))
return
}
// --provider without a specific model: switch provider only.
if provider != "" && model == "" {
models := snap.ModelsByProvider[provider]
if len(models) == 0 {
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, "Provider switching is not configured.")
return
}
g.switchModel(ctx, b, msg, client, models[0], global)
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, client, model, global)
return
}
// Neither model nor provider: delegate to inline selector.
g.sendModelSelector(ctx, b, msg, client)
}
// 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,
client messaging.ChatContract,
model string,
global bool,
) {
reply, err := client.Route(ctx, messaging.Inbound{
Message: messaging.Message{
ConversationID: conversationID(msg),
Sender: msg.From.Username,
Role: messaging.RoleUser,
Text: "/model " + model,
},
})
if err != nil {
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID,
fmt.Sprintf("Cannot switch: %v", err))
return
}
if strings.HasPrefix(reply.Text, "Cannot switch") {
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, reply.Text)
return
}
provider, _, _ := strings.Cut(model, "/")
result := fmt.Sprintf("Model changed to %s.", modelDisplayName(model, provider))
if global {
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,
client messaging.ChatContract,
) {
snap, err := client.Snapshot(ctx)
if err != nil || len(snap.Models) == 0 {
reply, err := client.Route(ctx, messaging.Inbound{
Message: messaging.Message{Role: messaging.RoleUser, Text: "/model"},
})
if err != nil {
g.log.ErrorContext(ctx, "model selector fallback failed", "error", err)
return
}
g.sendMessage(ctx, b, msg.Chat.ID, msg.MessageThreadID, reply.Text)
return
}
params := &bot.SendMessageParams{
ChatID: msg.Chat.ID,
Text: modelSelectorText(snap.ActiveModel),
ReplyMarkup: g.modelSelectorKeyboard(snap.ActiveModel, snap.Models, snap.ActiveProvider, snap.ModelsByProvider),
}
if msg.MessageThreadID != 0 {
params.MessageThreadID = msg.MessageThreadID
}
if _, err := b.SendMessage(ctx, params); err != nil {
g.log.ErrorContext(ctx, "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(active string, models []string, activeProvider string, modelsByProvider map[string][]string) *models.InlineKeyboardMarkup {
provider := activeProvider
available := models
if provider != "" && len(modelsByProvider[provider]) > 0 {
available = modelsByProvider[provider]
}
return g.modelSelectorKeyboardPage(active, available, provider, 0)
}
func (g *Gateway) modelSelectorKeyboardPage(active string, available []string, provider string, page int) *models.InlineKeyboardMarkup {
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
}
func (g *Gateway) modelCallbackToken(model string) string {
sum := sha256.Sum256([]byte(model))
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
}
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,
client messaging.ChatContract,
) {
query := update.CallbackQuery
if query == nil {
return
}
if !g.isSenderAllowed(query.From.ID) {
g.log.WarnContext(ctx, "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
}
selected, ok := g.modelForCallback(query.Data)
if !ok {
g.answerModelCallback(ctx, b, query.ID, "That model selection is no longer valid.", true)
return
}
reply, err := client.Route(ctx, messaging.Inbound{
Message: messaging.Message{
Role: messaging.RoleUser,
Text: "/model " + selected,
},
})
if err != nil {
g.answerModelCallback(ctx, b, query.ID, fmt.Sprintf("Cannot switch: %v", err), true)
return
}
if strings.HasPrefix(reply.Text, "Cannot switch") {
g.answerModelCallback(ctx, b, query.ID, reply.Text, 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(client, selected), nil)
}
func modelSelectionConfirmation(manager any, 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.(messaging.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,
client messaging.ChatContract,
) {
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
}
snap, err := client.Snapshot(ctx)
if err != nil || len(snap.Models) == 0 {
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 := snap.ModelsByProvider[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(models)),
g.modelSelectorKeyboardPage(snap.ActiveModel, models, page.Provider, page.Page))
}
func (g *Gateway) handleModelBackCallback(
ctx context.Context,
b *bot.Bot,
update *models.Update,
client messaging.ChatContract,
) {
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
}
snap, err := client.Snapshot(ctx)
if err != nil || len(snap.Providers) == 0 {
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(snap.ActiveModel, snap.ActiveProvider),
g.providerSelectorKeyboard(snap.ActiveProvider, snap.Providers, snap.ModelsByProvider))
}
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)
params := &bot.EditMessageTextParams{
Text: "Model selection cancelled.",
}
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.WarnContext(ctx, "cancel model selector failed", "error", err)
}
}
func (g *Gateway) handleModelNoopCallback(ctx context.Context, b *bot.Bot, update *models.Update) {
query := update.CallbackQuery
if query == nil {
return
}
g.answerModelCallback(ctx, b, query.ID, "", false)
}
func (g *Gateway) answerModelCallback(ctx context.Context, b *bot.Bot, queryID, text string, alert bool) {
params := &bot.AnswerCallbackQueryParams{
CallbackQueryID: queryID,
Text: text,
ShowAlert: alert,
}
if _, err := b.AnswerCallbackQuery(ctx, params); err != nil {
g.log.WarnContext(ctx, "answer model callback query failed", "error", err)
}
}
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.WarnContext(ctx, "edit model picker failed", "error", err)
}
}