@fickydev/pigent 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -43,6 +43,8 @@
 - Planned model selection support across profile, agent, and Telegram chat override levels.
 - Added profile and agent config-based Pi model and thinking level selection.
 - Added session-scoped model and thinking level overrides with `/model` and `/thinking` Telegram commands.
+- Planned Telegram inline-button model and thinking level pickers backed by configured model choices.
+- Added Telegram inline-button pickers for `/model` and `/thinking`, callback handling, and bot command menu registration.
 - Kept daemon process alive after startup so CLI runs do not exit after `pigent ready`.
 
 ### Changed

package/PLAN.md

@@ -206,7 +206,27 @@ Telegram command support should persist session-scoped overrides after config su
 - `/thinking <level>` sets thinking level for the default agent session in the current chat/thread
 - `/thinking default` clears thinking override for the default agent session in the current chat/thread
 
-The command handler should validate agent access and model availability through a Pi model resolver. It must not reveal API keys, auth values, raw environment variables, or provider secrets.
+Telegram should also provide inline-button pickers so non-technical users can choose from configured choices:
+
+- `/model` can reply with inline keyboard buttons for configured model choices plus `Use default`
+- `/thinking` can reply with inline keyboard buttons for `Off`, `Low`, `Medium`, `High`, and `Use default`
+- callback payloads should be short and action-scoped, such as `model:set:<choiceId>`, `model:default`, `thinking:set:medium`, and `thinking:default`
+- after selection, bot should answer the callback and update or send a confirmation message
+- daemon startup should register Telegram bot commands through `setMyCommands` so users see Pigent commands in the Telegram command menu
+
+Model choices should be explicitly configured instead of exposing every Pi model blindly:
+
+```yaml
+modelChoices:
+  - id: anthropic/claude-sonnet-4-5
+    label: Claude Sonnet
+  - id: anthropic/claude-opus-4-5
+    label: Claude Opus
+  - id: openai/gpt-4.1
+    label: GPT-4.1
+```
+
+The command and callback handlers should validate agent access and model availability through a Pi model resolver. They must not reveal API keys, auth values, raw environment variables, or provider secrets.
 
 ## Prompt Composition
 

package/TODO.md

@@ -39,6 +39,7 @@
 
 ## Config
 
+- [x] Add root `modelChoices` config for Telegram model picker buttons
 - [x] Add profile-level `thinkingLevel` config
 - [x] Add agent-level `model` override config
 - [x] Add agent-level `thinkingLevel` override config
@@ -84,11 +85,15 @@
 - [x] Define `OutboundMessage`
 - [x] Define `ChannelAdapter`
 - [x] Define Telegram normalized types
+- [x] Normalize Telegram callback query updates
 - [ ] Implement `TelegramApi`
   - [x] `getUpdates`
   - [x] `sendMessage`
   - [x] error handling
   - [x] retry/backoff
+  - [x] `answerCallbackQuery`
+  - [x] inline keyboard `reply_markup` support
+  - [x] `setMyCommands` Telegram command menu registration
 - [x] Implement `TelegramPollingAdapter`
   - [x] polling loop
   - [x] offset tracking
@@ -179,6 +184,11 @@
 - [x] `/thinking` show thinking level for default chat agent session
 - [x] `/thinking <level>` set thinking level for default chat agent session
 - [x] `/thinking default` clear thinking level for default chat agent session
+- [x] `/model` inline button picker for configured model choices
+- [x] `/thinking` inline button picker
+- [x] Handle model picker callback and persist selected session model
+- [x] Handle thinking picker callback and persist selected session thinking level
+- [x] Add `Use default` model/thinking buttons
 - [ ] `/model <agentId> <provider/modelId>` set model for an explicit agent session
 - [ ] `/thinking <agentId> <level>` set thinking level for an explicit agent session
 - [x] `/help` show bot commands
@@ -192,6 +202,8 @@
 - [ ] Unit test heartbeat `NOOP` behavior
 - [ ] Unit test model selection priority
 - [ ] Unit test Telegram `/model` command parsing
+- [ ] Unit test Telegram model picker callback parsing
+- [ ] Unit test Telegram thinking picker callback parsing
 - [ ] Repository tests against temp SQLite DB
 - [ ] Integration test fake Telegram update to fake Pi runner
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": false,
   "type": "module",
   "description": "Autonomous multi-agent daemon using Pi as core execution engine.",

package/pigent.yaml

@@ -1,5 +1,14 @@
 telegramChats: []
+modelChoices: []
 
+# Add choices to show buttons for /model.
+#
+# modelChoices:
+#   - id: anthropic/claude-sonnet-4-5
+#     label: Claude Sonnet
+#   - id: anthropic/claude-opus-4-5
+#     label: Claude Opus
+#
 # Replace chatId with a real Telegram chat id to enable routing.
 #
 # telegramChats:

package/src/agents/BotCommandHandler.ts

@@ -1,4 +1,5 @@
-import type { InboundMessage } from "../channels/types";
+import type { InboundMessage, InlineKeyboardButton } from "../channels/types";
+import type { ModelChoiceConfig } from "../config/schemas";
 import type { Repositories } from "../db/repositories";
 import { isValidModelRef } from "../pi/PiModelResolver";
 import type { AgentRegistry } from "./AgentRegistry";
@@ -7,6 +8,7 @@ export type BotCommandResult =
   | {
       handled: true;
       text: string;
+      inlineKeyboard?: InlineKeyboardButton[][];
     }
   | {
       handled: false;
@@ -19,6 +21,7 @@ export class BotCommandHandler {
   constructor(
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
+    private readonly modelChoices: ModelChoiceConfig[] = [],
   ) {}
 
   async handle(message: InboundMessage): Promise<BotCommandResult> {
@@ -31,9 +34,17 @@ export class BotCommandHandler {
       case "/agents":
         return { handled: true, text: await this.agentsText(message) };
       case "/model":
-        return { handled: true, text: await this.modelText(message) };
+        return await this.modelResult(message);
       case "/thinking":
-        return { handled: true, text: await this.thinkingText(message) };
+        return await this.thinkingResult(message);
+      case "/model:set":
+        return { handled: true, text: await this.setModelFromChoice(message) };
+      case "/model:default":
+        return { handled: true, text: await this.clearModel(message) };
+      case "/thinking:set":
+        return { handled: true, text: await this.setThinkingFromCallback(message) };
+      case "/thinking:default":
+        return { handled: true, text: await this.clearThinking(message) };
       default:
         return { handled: false };
     }
@@ -44,10 +55,10 @@ export class BotCommandHandler {
       "Pigent commands:",
       "/help - show this help",
       "/agents - list agents for this chat",
-      "/model - show model for this chat session",
+      "/model - show model picker for this chat session",
       "/model <provider/modelId> - set model for this chat session",
       "/model default - clear model override for this chat session",
-      "/thinking - show thinking level for this chat session",
+      "/thinking - show thinking picker for this chat session",
       "/thinking <off|low|medium|high> - set thinking level for this chat session",
       "/thinking default - clear thinking override for this chat session",
       "/agent <agentId> <message> - send message to specific agent",
@@ -77,56 +88,97 @@ export class BotCommandHandler {
     ].join("\n");
   }
 
-  private async modelText(message: InboundMessage): Promise<string> {
+  private async modelResult(message: InboundMessage): Promise<BotCommandResult> {
     const sessionResult = await this.getDefaultSession(message);
-    if (!sessionResult.ok) return sessionResult.message;
+    if (!sessionResult.ok) return { handled: true, text: sessionResult.message };
 
     const [, ...args] = message.text.trim().split(/\s+/);
     const value = args.join(" ").trim();
 
     if (!value) {
-      return [
-        `Agent: ${sessionResult.agentId}`,
-        `Session model: ${sessionResult.session.model ?? "default"}`,
-        "Use /model <provider/modelId> to set a session model.",
-        "Use /model default to clear the session model override.",
-      ].join("\n");
+      return {
+        handled: true,
+        text: [
+          `Agent: ${sessionResult.agentId}`,
+          `Session model: ${sessionResult.session.model ?? "default"}`,
+          this.modelChoices.length > 0
+            ? "Choose a model:"
+            : "No model choices configured. Use /model <provider/modelId> to set manually.",
+        ].join("\n"),
+        inlineKeyboard: this.modelChoices.length > 0 ? this.modelKeyboard() : undefined,
+      };
     }
 
     if (value === "default") {
-      const session = await this.repositories.sessions.updateModel(sessionResult.session.id, null);
-      return `Session model cleared for ${session.agentId}. Current: ${session.model ?? "default"}`;
+      return { handled: true, text: await this.clearModel(message) };
     }
 
     if (!isValidModelRef(value)) {
-      return "Invalid model. Use provider/modelId, for example: anthropic/claude-opus-4-5";
+      return { handled: true, text: "Invalid model. Use provider/modelId, for example: anthropic/claude-opus-4-5" };
     }
 
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, value);
-    return `Session model for ${session.agentId} set to ${session.model}.`;
+    return { handled: true, text: `Session model for ${session.agentId} set to ${session.model}.` };
   }
 
-  private async thinkingText(message: InboundMessage): Promise<string> {
+  private async thinkingResult(message: InboundMessage): Promise<BotCommandResult> {
     const sessionResult = await this.getDefaultSession(message);
-    if (!sessionResult.ok) return sessionResult.message;
+    if (!sessionResult.ok) return { handled: true, text: sessionResult.message };
 
     const [, rawValue] = message.text.trim().split(/\s+/, 2);
     const value = rawValue?.trim();
 
     if (!value) {
-      return [
-        `Agent: ${sessionResult.agentId}`,
-        `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
-        "Use /thinking <off|low|medium|high> to set a session thinking level.",
-        "Use /thinking default to clear the session thinking override.",
-      ].join("\n");
+      return {
+        handled: true,
+        text: [
+          `Agent: ${sessionResult.agentId}`,
+          `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
+          "Choose thinking level:",
+        ].join("\n"),
+        inlineKeyboard: this.thinkingKeyboard(),
+      };
     }
 
     if (value === "default") {
-      const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, null);
-      return `Session thinking level cleared for ${session.agentId}. Current: ${session.thinkingLevel ?? "default"}`;
+      return { handled: true, text: await this.clearThinking(message) };
+    }
+
+    if (!isThinkingLevel(value)) {
+      return { handled: true, text: "Invalid thinking level. Use one of: off, low, medium, high, default" };
     }
 
+    const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
+    return { handled: true, text: `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.` };
+  }
+
+  private async setModelFromChoice(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const choiceIndex = Number(message.text.slice("/model:set:".length));
+    if (!Number.isSafeInteger(choiceIndex) || choiceIndex < 0 || choiceIndex >= this.modelChoices.length) {
+      return "Unknown model choice.";
+    }
+
+    const choice = this.modelChoices[choiceIndex];
+    const session = await this.repositories.sessions.updateModel(sessionResult.session.id, choice.id);
+    return `Session model for ${session.agentId} set to ${choice.label} (${session.model}).`;
+  }
+
+  private async clearModel(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const session = await this.repositories.sessions.updateModel(sessionResult.session.id, null);
+    return `Session model cleared for ${session.agentId}. Current: ${session.model ?? "default"}`;
+  }
+
+  private async setThinkingFromCallback(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const value = message.text.slice("/thinking:set:".length);
     if (!isThinkingLevel(value)) {
       return "Invalid thinking level. Use one of: off, low, medium, high, default";
     }
@@ -135,6 +187,41 @@ export class BotCommandHandler {
     return `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.`;
   }
 
+  private async clearThinking(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, null);
+    return `Session thinking level cleared for ${session.agentId}. Current: ${session.thinkingLevel ?? "default"}`;
+  }
+
+  private modelKeyboard(): InlineKeyboardButton[][] {
+    const rows = chunk(
+      this.modelChoices.map((choice, index) => ({
+        text: choice.label,
+        callbackData: `model:set:${index}`,
+      })),
+      2,
+    );
+
+    rows.push([{ text: "Use default", callbackData: "model:default" }]);
+    return rows;
+  }
+
+  private thinkingKeyboard(): InlineKeyboardButton[][] {
+    return [
+      [
+        { text: "Off", callbackData: "thinking:set:off" },
+        { text: "Low", callbackData: "thinking:set:low" },
+      ],
+      [
+        { text: "Medium", callbackData: "thinking:set:medium" },
+        { text: "High", callbackData: "thinking:set:high" },
+      ],
+      [{ text: "Use default", callbackData: "thinking:default" }],
+    ];
+  }
+
   private async getDefaultSession(message: InboundMessage) {
     if (message.channel !== "telegram") {
       return { ok: false as const, message: "Unsupported channel." };
@@ -175,3 +262,13 @@ export class BotCommandHandler {
 function isThinkingLevel(value: string): value is ThinkingLevel {
   return THINKING_LEVELS.includes(value as ThinkingLevel);
 }
+
+function chunk<T>(items: T[], size: number): T[][] {
+  const rows: T[][] = [];
+
+  for (let index = 0; index < items.length; index += size) {
+    rows.push(items.slice(index, index + size));
+  }
+
+  return rows;
+}

package/src/channels/telegram/TelegramApi.ts

@@ -1,4 +1,13 @@
-import type { TelegramGetMeResponse, TelegramGetUpdatesResponse, TelegramSendMessageResponse, TelegramUpdate, TelegramUser } from "./types";
+import type {
+  TelegramAnswerCallbackQueryResponse,
+  TelegramGetMeResponse,
+  TelegramGetUpdatesResponse,
+  TelegramSendMessageResponse,
+  TelegramSetMyCommandsResponse,
+  TelegramUpdate,
+  TelegramUser,
+} from "./types";
+import type { InlineKeyboardButton } from "../types";
 
 export type TelegramApiOptions = {
   token: string;
@@ -13,6 +22,11 @@ export type GetUpdatesOptions = {
   limit?: number;
 };
 
+export type TelegramBotCommand = {
+  command: string;
+  description: string;
+};
+
 type TelegramApiResponse<T> = T & {
   ok: boolean;
   description?: string;
@@ -43,18 +57,37 @@ export class TelegramApi {
       offset: options.offset,
       timeout: options.timeoutSeconds ?? 30,
       limit: options.limit ?? 50,
-      allowed_updates: ["message"],
+      allowed_updates: ["message", "callback_query"],
     });
 
     return response.result;
   }
 
-  async sendMessage(input: { chatId: string; text: string; threadId?: string | null }): Promise<void> {
+  async sendMessage(input: {
+    chatId: string;
+    text: string;
+    threadId?: string | null;
+    inlineKeyboard?: InlineKeyboardButton[][];
+  }): Promise<void> {
     await this.request<TelegramSendMessageResponse>("sendMessage", {
       chat_id: input.chatId,
       text: input.text,
       message_thread_id: input.threadId ? Number(input.threadId) : undefined,
       disable_web_page_preview: true,
+      reply_markup: input.inlineKeyboard ? toTelegramInlineKeyboard(input.inlineKeyboard) : undefined,
+    });
+  }
+
+  async answerCallbackQuery(input: { callbackQueryId: string; text?: string }): Promise<void> {
+    await this.request<TelegramAnswerCallbackQueryResponse>("answerCallbackQuery", {
+      callback_query_id: input.callbackQueryId,
+      text: input.text,
+    });
+  }
+
+  async setMyCommands(commands: TelegramBotCommand[]): Promise<void> {
+    await this.request<TelegramSetMyCommandsResponse>("setMyCommands", {
+      commands,
     });
   }
 
@@ -150,6 +183,17 @@ class TelegramApiError extends Error {
   }
 }
 
+function toTelegramInlineKeyboard(inlineKeyboard: InlineKeyboardButton[][]) {
+  return {
+    inline_keyboard: inlineKeyboard.map((row) =>
+      row.map((button) => ({
+        text: button.text,
+        callback_data: button.callbackData,
+      })),
+    ),
+  };
+}
+
 async function parseTelegramPayload<T extends { ok: boolean; description?: string }>(
   response: Response,
 ): Promise<TelegramApiResponse<T> | null> {

package/src/channels/telegram/TelegramPollingAdapter.ts

@@ -1,14 +1,15 @@
 import type { RuntimeKvRepository } from "../../db/repositories/RuntimeKvRepository";
 import { logger } from "../../logging/logger";
 import type { ChannelAdapter, InboundMessage, MessageHandler, OutboundMessage } from "../types";
-import { TelegramApi } from "./TelegramApi";
-import type { TelegramMessage, TelegramUpdate } from "./types";
+import { TelegramApi, type TelegramBotCommand } from "./TelegramApi";
+import type { TelegramCallbackQuery, TelegramMessage, TelegramUpdate } from "./types";
 
 export type TelegramPollingAdapterOptions = {
   api: TelegramApi;
   runtimeKv: RuntimeKvRepository;
   pollTimeoutSeconds?: number;
   pollIntervalMs?: number;
+  commands?: TelegramBotCommand[];
 };
 
 const offsetKey = "telegram:update_offset";
@@ -28,6 +29,10 @@ export class TelegramPollingAdapter implements ChannelAdapter {
     const botUser = await this.options.api.getMe();
     this.botUserId = String(botUser.id);
 
+    if (this.options.commands?.length) {
+      await this.options.api.setMyCommands(this.options.commands);
+    }
+
     this.running = true;
     this.loopPromise = this.poll(handler);
     logger.info("telegram polling started", {
@@ -54,6 +59,7 @@ export class TelegramPollingAdapter implements ChannelAdapter {
       chatId: message.chatId,
       threadId: message.threadId,
       text: message.text,
+      inlineKeyboard: message.inlineKeyboard,
     });
   }
 
@@ -80,6 +86,11 @@ export class TelegramPollingAdapter implements ChannelAdapter {
   }
 
   private async handleUpdate(update: TelegramUpdate, handler: MessageHandler): Promise<void> {
+    if (update.callback_query) {
+      await this.handleCallbackQuery(update.update_id, update.callback_query, handler);
+      return;
+    }
+
     const message = update.message;
     if (!message?.text) return;
     if (message.from?.is_bot) return;
@@ -89,6 +100,21 @@ export class TelegramPollingAdapter implements ChannelAdapter {
     await handler(normalized);
   }
 
+  private async handleCallbackQuery(
+    updateId: number,
+    callbackQuery: TelegramCallbackQuery,
+    handler: MessageHandler,
+  ): Promise<void> {
+    await this.options.api.answerCallbackQuery({ callbackQueryId: callbackQuery.id });
+
+    if (!callbackQuery.data || !callbackQuery.message) return;
+    if (callbackQuery.from.is_bot) return;
+    if (this.botUserId && String(callbackQuery.from.id) === this.botUserId) return;
+
+    const normalized = normalizeTelegramCallbackQuery(updateId, callbackQuery);
+    await handler(normalized);
+  }
+
   private async loadOffset(): Promise<number | undefined> {
     const value = await this.options.runtimeKv.get(offsetKey);
     if (!value) return undefined;
@@ -118,6 +144,23 @@ function normalizeTelegramMessage(updateId: number, message: TelegramMessage): I
   };
 }
 
+function normalizeTelegramCallbackQuery(updateId: number, callbackQuery: TelegramCallbackQuery): InboundMessage {
+  const message = callbackQuery.message;
+  const senderName = [callbackQuery.from.first_name, callbackQuery.from.last_name].filter(Boolean).join(" ");
+
+  return {
+    id: String(updateId),
+    channel: "telegram",
+    chatId: String(message?.chat.id),
+    threadId: message?.message_thread_id ? String(message.message_thread_id) : null,
+    senderId: String(callbackQuery.from.id),
+    senderName: senderName || callbackQuery.from.username || null,
+    text: `/${callbackQuery.data}`,
+    raw: callbackQuery,
+    receivedAt: new Date(),
+  };
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/channels/telegram/types.ts

@@ -25,10 +25,18 @@ export type TelegramMessage = {
   text?: string;
 };
 
+export type TelegramCallbackQuery = {
+  id: string;
+  from: TelegramUser;
+  message?: TelegramMessage;
+  data?: string;
+};
+
 export type TelegramUpdate = {
   update_id: number;
   message?: TelegramMessage;
   edited_message?: TelegramMessage;
+  callback_query?: TelegramCallbackQuery;
 };
 
 export type TelegramGetUpdatesResponse = {
@@ -48,3 +56,15 @@ export type TelegramSendMessageResponse = {
   result?: TelegramMessage;
   description?: string;
 };
+
+export type TelegramAnswerCallbackQueryResponse = {
+  ok: boolean;
+  result: boolean;
+  description?: string;
+};
+
+export type TelegramSetMyCommandsResponse = {
+  ok: boolean;
+  result: boolean;
+  description?: string;
+};

package/src/channels/types.ts

@@ -12,11 +12,17 @@ export type InboundMessage = {
   receivedAt: Date;
 };
 
+export type InlineKeyboardButton = {
+  text: string;
+  callbackData: string;
+};
+
 export type OutboundMessage = {
   channel: ChannelId;
   chatId: string;
   threadId?: string | null;
   text: string;
+  inlineKeyboard?: InlineKeyboardButton[][];
 };
 
 export type MessageHandler = (message: InboundMessage) => Promise<void>;

package/src/config/loadConfig.ts

@@ -111,5 +111,6 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Loade
     agents,
     profiles,
     telegramChats: rootConfig.telegramChats,
+    modelChoices: rootConfig.modelChoices,
   };
 }

package/src/config/schemas.ts

@@ -65,6 +65,11 @@ export const ProfileConfigSchema = z.object({
   }),
 });
 
+export const ModelChoiceConfigSchema = z.object({
+  id: modelReferenceSchema,
+  label: z.string().min(1),
+});
+
 export const TelegramChatConfigSchema = z.object({
   chatId: z.string().min(1),
   title: z.string().optional(),
@@ -76,6 +81,7 @@ export const TelegramChatConfigSchema = z.object({
 
 export const RootConfigSchema = z.object({
   telegramChats: z.array(TelegramChatConfigSchema).default([]),
+  modelChoices: z.array(ModelChoiceConfigSchema).default([]),
 });
 
 export type PermissionConfig = z.infer<typeof PermissionConfigSchema>;
@@ -83,6 +89,7 @@ export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 export type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
 export type TelegramChatConfig = z.infer<typeof TelegramChatConfigSchema>;
+export type ModelChoiceConfig = z.infer<typeof ModelChoiceConfigSchema>;
 export type RootConfig = z.infer<typeof RootConfigSchema>;
 
 export type LoadedAgentConfig = AgentConfig & {
@@ -94,4 +101,5 @@ export type LoadedConfig = {
   agents: LoadedAgentConfig[];
   profiles: ProfileConfig[];
   telegramChats: TelegramChatConfig[];
+  modelChoices: ModelChoiceConfig[];
 };

package/src/daemon/AgentDaemon.ts

@@ -24,7 +24,7 @@ export class AgentDaemon {
   ) {
     this.adapters = createAdapters(repositories);
     this.registry = new AgentRegistry(config, repositories);
-    this.commands = new BotCommandHandler(this.registry, repositories);
+    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices);
     this.router = new MessageRouter(repositories, this.registry);
     this.runner = new AgentRunner(this.registry, repositories);
   }
@@ -92,6 +92,7 @@ export class AgentDaemon {
         chatId: message.chatId,
         threadId: message.threadId,
         text: command.text,
+        inlineKeyboard: command.inlineKeyboard,
       });
       return;
     }
@@ -158,9 +159,20 @@ function createAdapters(repositories: Repositories): ChannelAdapter[] {
         runtimeKv: repositories.runtimeKv,
         pollTimeoutSeconds: Number(process.env.TELEGRAM_POLL_TIMEOUT_SECONDS ?? 30),
         pollIntervalMs: Number(process.env.TELEGRAM_POLL_INTERVAL_MS ?? 1000),
+        commands: telegramCommands(),
       }),
     );
   }
 
   return adapters;
 }
+
+function telegramCommands() {
+  return [
+    { command: "help", description: "Show Pigent commands" },
+    { command: "agents", description: "List agents available in this chat" },
+    { command: "model", description: "Choose model for this chat session" },
+    { command: "thinking", description: "Choose thinking level for this chat session" },
+    { command: "agent", description: "Send message to a specific agent" },
+  ];
+}