558 lines
16 KiB
Go
558 lines
16 KiB
Go
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)
|
||
}
|
||
}
|