Phase 4: Telegram media support + inline keyboard approval

New files:
- approver.go — TelegramApprover implements danger.Approver with inline
  keyboard buttons (Approve/Deny/Trust Session) via callback queries
- approver_test.go — 13 tests, 100% coverage on 6/7 methods
- download.go — DownloadVoice/DownloadPhoto helpers with media dir
- download_test.go — 6 tests covering success, error paths, edge cases

Modified:
- bot.go — Added FileBaseURL field for testable file downloads
- handler.go — Approver routing in handleCallback, async agent dispatch,
  voice/photo default handlers now download media instead of placeholders
- handler_test.go — Updated default handler tests for new behavior
- telegram.go — Full agent loop wiring: TelegramApprover per chat,
  RunWithMessages for multi-turn sessions, async goroutine dispatch

All 16 packages pass. Coverage: 83.3% (+0.1% over baseline).

Author: jkyberneees

cmd/odek/telegram.go

@@ -5,84 +5,132 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 
+	"github.com/BackendStack21/kode"
+	"github.com/BackendStack21/kode/internal/config"
+	"github.com/BackendStack21/kode/internal/llm"
+	"github.com/BackendStack21/kode/internal/render"
 	"github.com/BackendStack21/kode/internal/session"
 	"github.com/BackendStack21/kode/internal/telegram"
 )
 
 // telegramCmd is the entry point for "odek telegram".
 func telegramCmd(args []string) error {
-	// 1. Load and validate config.
+	// 1. Load config from all sources (file → env).
+	resolved := config.LoadConfig(config.CLIFlags{})
+
+	// 2. Validate API key presence.
+	if resolved.APIKey == "" {
+		return fmt.Errorf("no API key configured — set ODEK_API_KEY, DEEPSEEK_API_KEY, or configure in odek.json")
+	}
+
+	// 3. Load and validate Telegram config.
 	cfg := telegram.ConfigFromEnv()
 	if err := telegram.ValidateConfig(cfg); err != nil {
 		fmt.Fprintf(os.Stderr, "odek telegram: %v\n", err)
 		return err
 	}
 
-	// 2. Create bot client.
+	// 4. Create bot client.
 	bot := telegram.NewBot(cfg.Token)
 
-	// 3. Create session store on disk (~/.odek/sessions/).
+	// 5. Create session store on disk (~/.odek/sessions/).
 	store, err := session.NewStore()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "odek telegram: session store: %v\n", err)
 		return err
 	}
 
-	// 4. Create session manager (per-chat Telegram session cache).
+	// 6. Create session manager (per-chat Telegram session cache).
 	sessionManager := telegram.NewSessionManager(store)
-	_ = sessionManager // will be used when the agent engine is wired in
 
-	// 5. Create handler.
+	// 7. Create handler.
 	handler := telegram.NewHandler(bot)
 
-	// 6. Set handler config from cfg.
+	// 8. Set handler config from cfg.
 	handler.Config = telegram.HandlerConfig{
 		AllowedChats: cfg.AllowedChats,
 		BotUsername:  cfg.BotUsername,
 		MaxMsgLength: cfg.MaxMsgLength,
 		AllowedUsers: cfg.AllowedUsers,
 	}
 
-	// 7. Wire handler callbacks.
+	// 9. Resolve system message.
+	systemMessage := resolved.System
+	if systemMessage == "" {
+		systemMessage = defaultSystem
+	}
+
+	// 10. Wire handler callbacks.
+	//
+	// Important: OnTextMessage processes in a background goroutine so it doesn't
+	// block the main update processing loop. The TelegramApprover blocks waiting
+	// for inline keyboard callbacks, which arrive via the main loop — only async
+	// dispatch prevents deadlock.
 	handler.OnTextMessage = func(chatID int64, text string) (string, error) {
-		// Placeholder: load session, append user message, run agent,
-		// save session, return response.
-		// For now, just echo the text back as a placeholder.
-		return fmt.Sprintf("Echo: %s", text), nil
+		go handleChatMessage(chatID, text, bot, handler, sessionManager,
+			resolved, systemMessage)
+		return "", nil
 	}
 
 	handler.OnCommand = func(chatID int64, cmdName string, argsStr string) (string, error) {
 		cmd := telegram.FindCommand(cmdName)
 		if cmd == nil {
 			return fmt.Sprintf("Unknown command: /%s", cmdName), nil
 		}
+
+		// Handle /new — clear session and reset trust in the approver.
+		if cmdName == "new" {
+			sessionManager.Delete(chatID)
+			if handler.Approver != nil {
+				handler.Approver.ResetTrust()
+			}
+		}
+
 		return cmd.Handler(argsStr)
 	}
 
 	handler.OnCallbackQuery = func(chatID int64, data string) (string, error) {
-		return fmt.Sprintf("Callback received: %s", data), nil
+		return "", nil // approval callbacks are routed by the approver
+	}
+
+	handler.OnVoiceMessage = func(chatID int64, fileID string) (string, error) {
+		go handleChatMessage(chatID, "[voice message: "+fileID+"]",
+			bot, handler, sessionManager, resolved, systemMessage)
+		return "", nil
+	}
+
+	handler.OnPhotoMessage = func(chatID int64, fileIDs []string) (string, error) {
+		go handleChatMessage(chatID, "[photo message: "+strings.Join(fileIDs, ",")+"]",
+			bot, handler, sessionManager, resolved, systemMessage)
+		return "", nil
 	}
 
 	handler.OnError = func(chatID int64, err error) {
 		fmt.Fprintf(os.Stderr, "odek telegram: error for chat %d: %v\n", chatID, err)
 	}
 
-	// 8. Print startup banner.
+	// 11. Set command list via Telegram API.
+	if err := bot.SetMyCommands(telegram.CommandDescriptors()); err != nil {
+		fmt.Fprintf(os.Stderr, "odek telegram: warning: set commands failed: %v\n", err)
+	}
+
+	// 12. Print startup banner.
 	fmt.Fprintf(os.Stderr, "odek telegram bot started\n")
 
-	// 9. Create poller.
+	// 13. Create poller.
 	poller := telegram.NewPoller(bot)
 	poller.Interval = time.Duration(cfg.PollInterval) * time.Second
 	poller.Timeout = cfg.PollTimeout
 
-	// 10. Create cancellable context for graceful shutdown.
+	// 14. Create cancellable context for graceful shutdown.
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	// 11. Handle SIGINT/SIGTERM for graceful shutdown.
+	// 15. Handle SIGINT/SIGTERM for graceful shutdown.
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
@@ -91,14 +139,97 @@ func telegramCmd(args []string) error {
 		cancel()
 	}()
 
-	// 12. Start polling in a background goroutine.
+	// 16. Start polling in a background goroutine.
 	updates := make(chan telegram.Update, 100)
 	go poller.Start(ctx, updates)
 
-	// 13. Process updates until the channel is closed (ctx cancelled).
+	// 17. Process updates until the channel is closed (ctx cancelled).
 	for upd := range updates {
 		handler.HandleUpdate(upd)
 	}
 
 	return nil
 }
+
+// handleChatMessage processes a user message from Telegram in a background
+// goroutine. It creates or loads the chat session, creates a TelegramApprover
+// for approval prompts, runs the agent loop with RunWithMessages, and sends
+// back the response. Each chat gets its own TelegramApprover instance.
+func handleChatMessage(
+	chatID int64,
+	text string,
+	bot *telegram.Bot,
+	handler *telegram.Handler,
+	sessionManager *telegram.SessionManager,
+	resolved	config.ResolvedConfig,
+	systemMessage string,
+) {
+	// Create a per-chat TelegramApprover for inline keyboard approval.
+	approver := telegram.NewTelegramApprover(bot, chatID)
+	handler.Approver = approver
+
+	// Get or create the session for this chat.
+	cs, err := sessionManager.GetOrCreate(chatID)
+	if err != nil {
+		reportError(bot, chatID, "Failed to create session: "+err.Error())
+		return
+	}
+
+	// Append user message to session.
+	cs.Messages = append(cs.Messages, llm.Message{Role: "user", Content: text})
+	cs.LastActive = time.Now()
+
+	// Build the agent with Telegram approver.
+	tools := builtinTools(resolved.Dangerous, nil, approver, resolved.MaxConcurrency)
+
+	modelLabel := odek.ProfileLabel(resolved.Model)
+	if modelLabel == "" {
+		modelLabel = "deepseek-chat"
+	}
+
+	rend := render.New(os.Stderr, false).WithModel(modelLabel)
+
+	agent, err := odek.New(odek.Config{
+		Model:         resolved.Model,
+		BaseURL:       resolved.BaseURL,
+		APIKey:        resolved.APIKey,
+		MaxIterations: resolved.MaxIter,
+		SystemMessage: systemMessage,
+		NoProjectFile: resolved.NoAgents,
+		Thinking:      resolved.Thinking,
+		Tools:         tools,
+		Renderer:      rend,
+	})
+	if err != nil {
+		reportError(bot, chatID, "Failed to create agent: "+err.Error())
+		return
+	}
+	defer agent.Close()
+
+	// Run the agent with the full message history (multi-turn).
+	response, updatedMessages, err := agent.RunWithMessages(context.Background(), cs.Messages)
+	if err != nil {
+		reportError(bot, chatID, "Agent error: "+err.Error())
+		return
+	}
+
+	// Save the updated session messages.
+	cs.Messages = updatedMessages
+	cs.TurnCount++
+	if err := sessionManager.Save(chatID, cs.Messages); err != nil {
+		fmt.Fprintf(os.Stderr, "odek telegram: session save: %v\n", err)
+	}
+
+	// Send the response.
+	if response != "" {
+		handler.SendResponse(chatID, response)
+	}
+}
+
+// reportError sends an error message to the given chat and logs to stderr.
+func reportError(bot *telegram.Bot, chatID int64, msg string) {
+	fmt.Fprintf(os.Stderr, "odek telegram: %s\n", msg)
+	if _, err := bot.SendMessage(chatID, "❌ "+msg, nil); err != nil {
+		fmt.Fprintf(os.Stderr, "odek telegram: send error message: %v\n", err)
+	}
+}