@fickydev/pigent 0.1.6 → 0.1.8

package/src/agents/BotCommandHandler.ts

@@ -1,20 +1,27 @@
-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";
 
 export type BotCommandResult =
   | {
       handled: true;
       text: string;
+      inlineKeyboard?: InlineKeyboardButton[][];
     }
   | {
       handled: false;
     };
 
+const THINKING_LEVELS = ["off", "low", "medium", "high"] as const;
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
 export class BotCommandHandler {
   constructor(
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
+    private readonly modelChoices: ModelChoiceConfig[] = [],
   ) {}
 
   async handle(message: InboundMessage): Promise<BotCommandResult> {
@@ -26,6 +33,18 @@ export class BotCommandHandler {
         return { handled: true, text: this.helpText() };
       case "/agents":
         return { handled: true, text: await this.agentsText(message) };
+      case "/model":
+        return await this.modelResult(message);
+      case "/thinking":
+        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 };
     }
@@ -36,6 +55,12 @@ export class BotCommandHandler {
       "Pigent commands:",
       "/help - show this help",
       "/agents - list agents for this chat",
+      "/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 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",
       "@agentId <message> - send message to specific agent",
     ].join("\n");
@@ -62,4 +87,188 @@ export class BotCommandHandler {
       `Allowed agents: ${allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"}`,
     ].join("\n");
   }
+
+  private async modelResult(message: InboundMessage): Promise<BotCommandResult> {
+    const sessionResult = await this.getDefaultSession(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 {
+        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") {
+      return { handled: true, text: await this.clearModel(message) };
+    }
+
+    if (!isValidModelRef(value)) {
+      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 { handled: true, text: `Session model for ${session.agentId} set to ${session.model}.` };
+  }
+
+  private async thinkingResult(message: InboundMessage): Promise<BotCommandResult> {
+    const sessionResult = await this.getDefaultSession(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 {
+        handled: true,
+        text: [
+          `Agent: ${sessionResult.agentId}`,
+          `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
+          "Choose thinking level:",
+        ].join("\n"),
+        inlineKeyboard: this.thinkingKeyboard(),
+      };
+    }
+
+    if (value === "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";
+    }
+
+    const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
+    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." };
+    }
+
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+
+    if (!chat?.enabled) {
+      return { ok: false as const, message: "No enabled chat configuration found." };
+    }
+
+    const agentId = chat.defaultAgentId;
+
+    if (!agentId) {
+      return { ok: false as const, message: "No default agent configured for this chat." };
+    }
+
+    if (!this.registry.hasAgent(agentId)) {
+      return { ok: false as const, message: `Unknown agent: ${agentId}` };
+    }
+
+    if (!(await this.repositories.telegram.isAgentAllowed(message.chatId, agentId))) {
+      return { ok: false as const, message: `Agent is not allowed in this chat: ${agentId}` };
+    }
+
+    const session = await this.repositories.sessions.getOrCreate({
+      agentId,
+      channel: message.channel,
+      chatId: message.chatId,
+      threadId: message.threadId,
+      userId: message.senderId,
+    });
+
+    return { ok: true as const, agentId, session };
+  }
+}
+
+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,8 +1,19 @@
-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;
   baseUrl?: string;
+  maxAttempts?: number;
+  baseRetryDelayMs?: number;
 };
 
 export type GetUpdatesOptions = {
@@ -11,11 +22,29 @@ export type GetUpdatesOptions = {
   limit?: number;
 };
 
+export type TelegramBotCommand = {
+  command: string;
+  description: string;
+};
+
+type TelegramApiResponse<T> = T & {
+  ok: boolean;
+  description?: string;
+  error_code?: number;
+  parameters?: {
+    retry_after?: number;
+  };
+};
+
 export class TelegramApi {
   private readonly baseUrl: string;
+  private readonly maxAttempts: number;
+  private readonly baseRetryDelayMs: number;
 
   constructor(options: TelegramApiOptions) {
     this.baseUrl = options.baseUrl ?? `https://api.telegram.org/bot${options.token}`;
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.baseRetryDelayMs = options.baseRetryDelayMs ?? 500;
   }
 
   async getMe(): Promise<TelegramUser> {
@@ -28,40 +57,169 @@ 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,
     });
   }
 
-  private async request<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
-    const response = await fetch(`${this.baseUrl}/${method}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify(body),
+  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,
+    });
+  }
+
+  private async request<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
+    let lastError: unknown;
+
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      try {
+        return await this.requestOnce<T>(method, body);
+      } catch (error) {
+        lastError = error;
+
+        if (!isRetryableTelegramError(error) || attempt >= this.maxAttempts) {
+          throw error;
+        }
+
+        await sleep(retryDelayMs(error, attempt, this.baseRetryDelayMs));
+      }
+    }
+
+    throw lastError instanceof Error ? lastError : new Error(`telegram ${method} failed`);
+  }
+
+  private async requestOnce<T extends { ok: boolean; description?: string }>(method: string, body: unknown): Promise<T> {
+    let response: Response;
+
+    try {
+      response = await fetch(`${this.baseUrl}/${method}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+      });
+    } catch (error) {
+      throw new TelegramApiError(method, `telegram ${method} failed: ${error instanceof Error ? error.message : String(error)}`, {
+        cause: error,
+        retryable: true,
+      });
+    }
+
+    const payload = await parseTelegramPayload<T>(response);
 
     if (!response.ok) {
-      throw new Error(`telegram ${method} failed with HTTP ${response.status}`);
+      throw new TelegramApiError(method, `telegram ${method} failed with HTTP ${response.status}`, {
+        status: response.status,
+        description: payload?.description,
+        retryAfterSeconds: payload?.parameters?.retry_after,
+        retryable: isRetryableStatus(response.status),
+      });
     }
 
-    const payload = (await response.json()) as T;
+    if (!payload?.ok) {
+      const status = payload?.error_code;
 
-    if (!payload.ok) {
-      throw new Error(`telegram ${method} failed: ${payload.description ?? "unknown error"}`);
+      throw new TelegramApiError(method, `telegram ${method} failed: ${payload?.description ?? "unknown error"}`, {
+        status,
+        description: payload?.description,
+        retryAfterSeconds: payload?.parameters?.retry_after,
+        retryable: status ? isRetryableStatus(status) : false,
+      });
     }
 
     return payload;
   }
 }
+
+class TelegramApiError extends Error {
+  readonly method: string;
+  readonly status?: number;
+  readonly description?: string;
+  readonly retryAfterSeconds?: number;
+  readonly retryable: boolean;
+
+  constructor(
+    method: string,
+    message: string,
+    options: {
+      status?: number;
+      description?: string;
+      retryAfterSeconds?: number;
+      retryable: boolean;
+      cause?: unknown;
+    },
+  ) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "TelegramApiError";
+    this.method = method;
+    this.status = options.status;
+    this.description = options.description;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.retryable = options.retryable;
+  }
+}
+
+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> {
+  try {
+    return (await response.json()) as TelegramApiResponse<T>;
+  } catch {
+    return null;
+  }
+}
+
+function isRetryableTelegramError(error: unknown): boolean {
+  return error instanceof TelegramApiError && error.retryable;
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status === 429 || status >= 500;
+}
+
+function retryDelayMs(error: unknown, attempt: number, baseDelayMs: number): number {
+  if (error instanceof TelegramApiError && error.retryAfterSeconds) {
+    return error.retryAfterSeconds * 1000;
+  }
+
+  return baseDelayMs * 2 ** (attempt - 1);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -1,6 +1,8 @@
 import { z } from "zod";
 
 const relativeOrAbsolutePathSchema = z.string().min(1);
+const modelReferenceSchema = z.string().min(1).regex(/^[^/\s]+\/.+$/);
+const ThinkingLevelSchema = z.enum(["off", "low", "medium", "high"]);
 
 export const PermissionConfigSchema = z.object({
   canRunShell: z.boolean().default(false),
@@ -28,6 +30,8 @@ export const AgentConfigSchema = z.object({
   name: z.string().min(1),
   profile: z.string().min(1),
   workspace: relativeOrAbsolutePathSchema,
+  model: modelReferenceSchema.nullable().default(null),
+  thinkingLevel: ThinkingLevelSchema.nullable().default(null),
   systemPromptFile: relativeOrAbsolutePathSchema.optional(),
   skills: z.array(z.string()).default([]),
   extensions: z.array(z.string()).default([]),
@@ -48,7 +52,8 @@ export const AgentConfigSchema = z.object({
 export const ProfileConfigSchema = z.object({
   id: z.string().min(1).regex(/^[a-zA-Z0-9_-]+$/),
   name: z.string().min(1),
-  model: z.string().min(1).nullable().default(null),
+  model: modelReferenceSchema.nullable().default(null),
+  thinkingLevel: ThinkingLevelSchema.nullable().default(null),
   instructions: z.string().default(""),
   defaultSkills: z.array(z.string()).default([]),
   defaultExtensions: z.array(z.string()).default([]),
@@ -60,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(),
@@ -71,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>;
@@ -78,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 & {
@@ -89,4 +101,5 @@ export type LoadedConfig = {
   agents: LoadedAgentConfig[];
   profiles: ProfileConfig[];
   telegramChats: TelegramChatConfig[];
+  modelChoices: ModelChoiceConfig[];
 };