zardbot-telegram 1.0.0

package/dist/interaction/manager.js

@@ -0,0 +1,106 @@
+import { logger } from "../utils/logger.js";
+export const DEFAULT_ALLOWED_INTERACTION_COMMANDS = ["/help", "/status", "/abort"];
+function normalizeCommand(command) {
+    const trimmed = command.trim().toLowerCase();
+    if (!trimmed) {
+        return null;
+    }
+    const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    const withoutMention = withSlash.split("@")[0];
+    if (withoutMention.length <= 1) {
+        return null;
+    }
+    return withoutMention;
+}
+function normalizeAllowedCommands(commands) {
+    if (commands === undefined) {
+        return [...DEFAULT_ALLOWED_INTERACTION_COMMANDS];
+    }
+    const normalized = new Set();
+    for (const command of commands) {
+        const value = normalizeCommand(command);
+        if (value) {
+            normalized.add(value);
+        }
+    }
+    return Array.from(normalized);
+}
+function cloneState(state) {
+    return {
+        ...state,
+        allowedCommands: [...state.allowedCommands],
+        metadata: { ...state.metadata },
+    };
+}
+class InteractionManager {
+    state = null;
+    start(options) {
+        const now = Date.now();
+        let expiresAt = null;
+        if (this.state) {
+            this.clear("state_replaced");
+        }
+        if (typeof options.expiresInMs === "number") {
+            expiresAt = now + options.expiresInMs;
+        }
+        const nextState = {
+            kind: options.kind,
+            expectedInput: options.expectedInput,
+            allowedCommands: normalizeAllowedCommands(options.allowedCommands),
+            metadata: options.metadata ? { ...options.metadata } : {},
+            createdAt: now,
+            expiresAt,
+        };
+        this.state = nextState;
+        logger.info(`[InteractionManager] Started interaction: kind=${nextState.kind}, expectedInput=${nextState.expectedInput}, allowedCommands=${nextState.allowedCommands.join(",") || "none"}`);
+        return cloneState(nextState);
+    }
+    get() {
+        if (!this.state) {
+            return null;
+        }
+        return cloneState(this.state);
+    }
+    getSnapshot() {
+        return this.get();
+    }
+    isActive() {
+        return this.state !== null;
+    }
+    isExpired(referenceTimeMs = Date.now()) {
+        if (!this.state || this.state.expiresAt === null) {
+            return false;
+        }
+        return referenceTimeMs >= this.state.expiresAt;
+    }
+    transition(options) {
+        if (!this.state) {
+            return null;
+        }
+        const now = Date.now();
+        this.state = {
+            ...this.state,
+            kind: options.kind ?? this.state.kind,
+            expectedInput: options.expectedInput ?? this.state.expectedInput,
+            allowedCommands: options.allowedCommands !== undefined
+                ? normalizeAllowedCommands(options.allowedCommands)
+                : [...this.state.allowedCommands],
+            metadata: options.metadata ? { ...options.metadata } : { ...this.state.metadata },
+            expiresAt: options.expiresInMs === undefined
+                ? this.state.expiresAt
+                : options.expiresInMs === null
+                    ? null
+                    : now + options.expiresInMs,
+        };
+        logger.debug(`[InteractionManager] Transitioned interaction: kind=${this.state.kind}, expectedInput=${this.state.expectedInput}, allowedCommands=${this.state.allowedCommands.join(",") || "none"}`);
+        return cloneState(this.state);
+    }
+    clear(reason = "manual") {
+        if (!this.state) {
+            return;
+        }
+        logger.info(`[InteractionManager] Cleared interaction: reason=${reason}, kind=${this.state.kind}, expectedInput=${this.state.expectedInput}`);
+        this.state = null;
+    }
+}
+export const interactionManager = new InteractionManager();

package/dist/interaction/types.js

@@ -0,0 +1 @@
+export {};

package/dist/keyboard/manager.js

@@ -0,0 +1,172 @@
+import { createMainKeyboard } from "../bot/utils/keyboard.js";
+import { getStoredAgent } from "../agent/manager.js";
+import { getStoredModel } from "../model/manager.js";
+import { formatVariantForButton } from "../variant/manager.js";
+import { logger } from "../utils/logger.js";
+import { t } from "../i18n/index.js";
+/**
+ * Keyboard Manager - manages Reply Keyboard state and updates
+ * Singleton pattern
+ */
+class KeyboardManager {
+    state = null;
+    api = null;
+    chatId = null;
+    lastUpdateTime = 0;
+    UPDATE_DEBOUNCE_MS = 2000; // Don't update more than once per 2 seconds
+    /**
+     * Initialize the keyboard manager with Telegram API and chat ID
+     * Loads initial state from settings/config
+     */
+    initialize(api, chatId) {
+        this.api = api;
+        this.chatId = chatId;
+        // Initialize state from settings/config on first call
+        if (!this.state) {
+            const currentModel = getStoredModel();
+            this.state = {
+                currentAgent: getStoredAgent(),
+                currentModel: currentModel,
+                contextInfo: null,
+                variantName: formatVariantForButton(currentModel.variant || "default"),
+            };
+            logger.debug(`[KeyboardManager] Initialized with agent="${this.state.currentAgent}", model="${this.state.currentModel.providerID}/${this.state.currentModel.modelID}", variant="${currentModel.variant || "default"}", chatId=${chatId}`);
+        }
+        else {
+            logger.debug("[KeyboardManager] Already initialized, updating chatId:", chatId);
+        }
+    }
+    /**
+     * Update current agent
+     */
+    updateAgent(agent) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update agent: not initialized");
+            return;
+        }
+        this.state.currentAgent = agent;
+        logger.debug(`[KeyboardManager] Agent updated: ${agent}`);
+    }
+    /**
+     * Update current model
+     */
+    updateModel(model) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update model: not initialized");
+            return;
+        }
+        this.state.currentModel = model;
+        this.state.variantName = formatVariantForButton(model.variant || "default");
+        logger.debug(`[KeyboardManager] Model updated: ${model.providerID}/${model.modelID}, variant: ${model.variant || "default"}`);
+    }
+    /**
+     * Update current variant
+     */
+    updateVariant(variantId) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update variant: not initialized");
+            return;
+        }
+        this.state.variantName = formatVariantForButton(variantId);
+        logger.debug(`[KeyboardManager] Variant updated: ${variantId}`);
+    }
+    /**
+     * Update context information
+     */
+    updateContext(tokensUsed, tokensLimit) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update context: not initialized");
+            return;
+        }
+        this.state.contextInfo = { tokensUsed, tokensLimit };
+        logger.debug(`[KeyboardManager] Context updated: ${tokensUsed}/${tokensLimit}`);
+    }
+    /**
+     * Clear context information
+     */
+    clearContext() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot clear context: not initialized");
+            return;
+        }
+        this.state.contextInfo = null;
+        logger.debug("[KeyboardManager] Context cleared");
+    }
+    /**
+     * Get current context info
+     */
+    getContextInfo() {
+        return this.state?.contextInfo ?? null;
+    }
+    /**
+     * Build keyboard with current state
+     */
+    buildKeyboard() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot build keyboard: not initialized");
+            // Return a minimal keyboard as fallback
+            return createMainKeyboard("build", { providerID: "", modelID: "" }, undefined);
+        }
+        return createMainKeyboard(this.state.currentAgent, this.state.currentModel, this.state.contextInfo ?? undefined, this.state.variantName);
+    }
+    /**
+     * Send keyboard update to user
+     * Implements debouncing to avoid rate limits
+     */
+    async sendKeyboardUpdate(chatId) {
+        if (!this.api) {
+            logger.warn("[KeyboardManager] API not initialized");
+            return;
+        }
+        const targetChatId = chatId ?? this.chatId;
+        if (!targetChatId) {
+            logger.warn("[KeyboardManager] No chatId available");
+            return;
+        }
+        // Debounce: don't update more frequently than UPDATE_DEBOUNCE_MS
+        const now = Date.now();
+        if (now - this.lastUpdateTime < this.UPDATE_DEBOUNCE_MS) {
+            logger.debug("[KeyboardManager] Update debounced");
+            return;
+        }
+        this.lastUpdateTime = now;
+        try {
+            const keyboard = this.buildKeyboard();
+            // Send a dummy message with updated keyboard
+            // This is needed because Reply Keyboard updates require a message
+            await this.api.sendMessage(targetChatId, t("keyboard.updated"), {
+                reply_markup: keyboard,
+            });
+            logger.debug("[KeyboardManager] Keyboard update sent");
+        }
+        catch (err) {
+            logger.error("[KeyboardManager] Failed to send keyboard update:", err);
+        }
+    }
+    /**
+     * Update keyboard without sending a message (for use in existing messages)
+     * Returns undefined if not initialized (caller should handle this)
+     */
+    getKeyboard() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot get keyboard: not initialized");
+            return undefined;
+        }
+        return this.buildKeyboard();
+    }
+    /**
+     * Get current keyboard state
+     * Returns undefined if not initialized
+     */
+    getState() {
+        return this.state ?? undefined;
+    }
+    /**
+     * Check if keyboard manager is initialized
+     */
+    isInitialized() {
+        return this.state !== null;
+    }
+}
+// Export singleton instance
+export const keyboardManager = new KeyboardManager();

package/dist/keyboard/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/capabilities.js

@@ -0,0 +1,62 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const capabilitiesCache = {};
+/**
+ * Get model capabilities from OpenCode API
+ * Results are cached in memory per model
+ */
+export async function getModelCapabilities(providerID, modelID) {
+    const cacheKey = `${providerID}/${modelID}`;
+    if (capabilitiesCache[cacheKey] !== undefined) {
+        logger.debug(`[ModelCapabilities] Cache hit for ${cacheKey}`);
+        return capabilitiesCache[cacheKey];
+    }
+    try {
+        logger.debug(`[ModelCapabilities] Fetching capabilities for ${cacheKey}`);
+        const response = await opencodeClient.config.providers();
+        if (response.error || !response.data) {
+            logger.error("[ModelCapabilities] API returned error:", response.error);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const providers = response.data.providers;
+        const provider = providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[ModelCapabilities] Provider ${providerID} not found`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[ModelCapabilities] Model ${cacheKey} not found in provider`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        logger.debug(`[ModelCapabilities] Found capabilities for ${cacheKey}`);
+        capabilitiesCache[cacheKey] = model.capabilities;
+        return model.capabilities;
+    }
+    catch (error) {
+        logger.error("[ModelCapabilities] Failed to fetch providers:", error);
+        capabilitiesCache[cacheKey] = null;
+        return null;
+    }
+}
+/**
+ * Check if model supports a specific input type
+ */
+export function supportsInput(capabilities, inputType) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.input[inputType] === true;
+}
+/**
+ * Check if model supports attachments in general
+ */
+export function supportsAttachment(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.attachment === true;
+}

package/dist/model/context-limit.js

@@ -0,0 +1,57 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+import { DEFAULT_CONTEXT_LIMIT } from "../pinned/format.js";
+const PROVIDER_CACHE_TTL_MS = 10 * 60 * 1000;
+const contextLimitCache = new Map();
+let providersCacheExpiresAt = 0;
+let providersFetchInFlight = null;
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+async function refreshContextLimitCache() {
+    if (Date.now() < providersCacheExpiresAt) {
+        return;
+    }
+    if (providersFetchInFlight) {
+        await providersFetchInFlight;
+        return;
+    }
+    providersFetchInFlight = (async () => {
+        try {
+            const { data, error } = await opencodeClient.config.providers();
+            if (error || !data) {
+                logger.warn("[ModelContextLimit] Failed to fetch providers:", error);
+                return;
+            }
+            contextLimitCache.clear();
+            for (const provider of data.providers) {
+                for (const [modelID, model] of Object.entries(provider.models)) {
+                    if (model?.limit?.context) {
+                        contextLimitCache.set(getModelKey(provider.id, modelID), model.limit.context);
+                    }
+                }
+            }
+            providersCacheExpiresAt = Date.now() + PROVIDER_CACHE_TTL_MS;
+            logger.debug(`[ModelContextLimit] Cached limits for ${contextLimitCache.size} provider/model pairs`);
+        }
+        catch (error) {
+            logger.warn("[ModelContextLimit] Error refreshing providers cache:", error);
+        }
+        finally {
+            providersFetchInFlight = null;
+        }
+    })();
+    await providersFetchInFlight;
+}
+export async function getModelContextLimit(providerID, modelID) {
+    if (!providerID || !modelID) {
+        return DEFAULT_CONTEXT_LIMIT;
+    }
+    const cacheKey = getModelKey(providerID, modelID);
+    const cachedLimit = contextLimitCache.get(cacheKey);
+    if (cachedLimit) {
+        return cachedLimit;
+    }
+    await refreshContextLimitCache();
+    return contextLimitCache.get(cacheKey) ?? DEFAULT_CONTEXT_LIMIT;
+}

package/dist/model/manager.js

@@ -0,0 +1,259 @@
+import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
+import { config } from "../config.js";
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+import path from "node:path";
+const MODEL_CATALOG_CACHE_TTL_MS = 10 * 60 * 1000;
+let cachedValidModelKeys = null;
+let modelCatalogCacheExpiresAt = 0;
+let modelCatalogFetchInFlight = null;
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+function getEnvDefaultModel() {
+    const providerID = config.opencode.model.provider;
+    const modelID = config.opencode.model.modelId;
+    if (!providerID || !modelID) {
+        return null;
+    }
+    return { providerID, modelID };
+}
+function dedupeModels(models) {
+    const unique = new Map();
+    for (const model of models) {
+        const key = `${model.providerID}/${model.modelID}`;
+        if (!unique.has(key)) {
+            unique.set(key, model);
+        }
+    }
+    return Array.from(unique.values());
+}
+function filterModelsByCatalog(models, validModelKeys) {
+    if (!validModelKeys) {
+        return models;
+    }
+    return models.filter((model) => validModelKeys.has(getModelKey(model.providerID, model.modelID)));
+}
+async function getValidModelKeys() {
+    if (cachedValidModelKeys && Date.now() < modelCatalogCacheExpiresAt) {
+        logger.debug(`[ModelManager] Model catalog cache hit: models=${cachedValidModelKeys.size}, ttlMs=${modelCatalogCacheExpiresAt - Date.now()}`);
+        return cachedValidModelKeys;
+    }
+    if (modelCatalogFetchInFlight) {
+        logger.debug("[ModelManager] Awaiting in-flight model catalog refresh");
+        return modelCatalogFetchInFlight;
+    }
+    modelCatalogFetchInFlight = (async () => {
+        try {
+            logger.debug("[ModelManager] Refreshing model catalog from OpenCode API");
+            const response = await opencodeClient.config.providers();
+            if (response.error || !response.data) {
+                logger.warn("[ModelManager] Failed to refresh model catalog:", response.error);
+                if (cachedValidModelKeys) {
+                    logger.warn("[ModelManager] Using stale model catalog cache after refresh failure");
+                    return cachedValidModelKeys;
+                }
+                return null;
+            }
+            const validModelKeys = new Set();
+            for (const provider of response.data.providers) {
+                for (const modelID of Object.keys(provider.models)) {
+                    validModelKeys.add(getModelKey(provider.id, modelID));
+                }
+            }
+            cachedValidModelKeys = validModelKeys;
+            modelCatalogCacheExpiresAt = Date.now() + MODEL_CATALOG_CACHE_TTL_MS;
+            logger.debug(`[ModelManager] Model catalog refreshed: providers=${response.data.providers.length}, models=${validModelKeys.size}`);
+            return cachedValidModelKeys;
+        }
+        catch (err) {
+            logger.warn("[ModelManager] Error refreshing model catalog:", err);
+            if (cachedValidModelKeys) {
+                logger.warn("[ModelManager] Using stale model catalog cache after refresh exception");
+                return cachedValidModelKeys;
+            }
+            return null;
+        }
+        finally {
+            modelCatalogFetchInFlight = null;
+        }
+    })();
+    return modelCatalogFetchInFlight;
+}
+function normalizeFavoriteModels(state) {
+    if (!Array.isArray(state.favorite)) {
+        return [];
+    }
+    return state.favorite
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
+function normalizeRecentModels(state) {
+    if (!Array.isArray(state.recent)) {
+        return [];
+    }
+    return state.recent
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
+function getOpenCodeModelStatePath() {
+    const xdgStateHome = process.env.XDG_STATE_HOME;
+    if (xdgStateHome && xdgStateHome.trim().length > 0) {
+        return path.join(xdgStateHome, "opencode", "model.json");
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(homeDir, ".local", "state", "opencode", "model.json");
+}
+/**
+ * Get favorite and recent models from OpenCode local state file.
+ * Config model is always treated as favorite.
+ */
+export async function getModelSelectionLists() {
+    const envDefaultModel = getEnvDefaultModel();
+    try {
+        const fs = await import("fs/promises");
+        const stateFilePath = getOpenCodeModelStatePath();
+        const content = await fs.readFile(stateFilePath, "utf-8");
+        const state = JSON.parse(content);
+        const rawFavorites = normalizeFavoriteModels(state);
+        const rawRecent = normalizeRecentModels(state);
+        const shouldValidateWithCatalog = rawFavorites.length > 0 || rawRecent.length > 0;
+        const validModelKeys = shouldValidateWithCatalog ? await getValidModelKeys() : null;
+        const validatedFavorites = filterModelsByCatalog(rawFavorites, validModelKeys);
+        const validatedRecent = filterModelsByCatalog(rawRecent, validModelKeys);
+        const favorites = envDefaultModel
+            ? dedupeModels([...validatedFavorites, envDefaultModel])
+            : validatedFavorites;
+        if (rawFavorites.length === 0 && envDefaultModel) {
+            logger.info(`[ModelManager] No favorites in ${stateFilePath}, using config model as favorite`);
+        }
+        if (favorites.length === 0) {
+            logger.warn(`[ModelManager] No favorites in ${stateFilePath}`);
+        }
+        const filteredOutFavorites = rawFavorites.length - validatedFavorites.length;
+        const filteredOutRecent = rawRecent.length - validatedRecent.length;
+        if (filteredOutFavorites > 0 || filteredOutRecent > 0) {
+            logger.info(`[ModelManager] Filtered unavailable models from OpenCode state: favoritesRemoved=${filteredOutFavorites}, recentRemoved=${filteredOutRecent}`);
+        }
+        const favoriteKeys = new Set(favorites.map((model) => getModelKey(model.providerID, model.modelID)));
+        const recent = dedupeModels(validatedRecent).filter((model) => !favoriteKeys.has(getModelKey(model.providerID, model.modelID)));
+        logger.debug(`[ModelManager] Loaded model selection lists from ${stateFilePath}: favorites=${favorites.length}, recent=${recent.length}`);
+        return { favorites, recent };
+    }
+    catch (err) {
+        if (envDefaultModel) {
+            logger.warn("[ModelManager] Failed to load OpenCode model state, using config model as favorite:", err);
+            return {
+                favorites: [envDefaultModel],
+                recent: [],
+            };
+        }
+        logger.error("[ModelManager] Failed to load OpenCode model state:", err);
+        return {
+            favorites: [],
+            recent: [],
+        };
+    }
+}
+/**
+ * Validate stored selected model against OpenCode providers catalog.
+ * If selected model is unavailable, fallback to env default model.
+ */
+export async function reconcileStoredModelSelection() {
+    const currentModel = getCurrentModel();
+    if (!currentModel?.providerID || !currentModel.modelID) {
+        return;
+    }
+    const validModelKeys = await getValidModelKeys();
+    if (!validModelKeys) {
+        logger.warn("[ModelManager] Skipping stored model validation: model catalog unavailable");
+        return;
+    }
+    const currentModelKey = getModelKey(currentModel.providerID, currentModel.modelID);
+    if (validModelKeys.has(currentModelKey)) {
+        return;
+    }
+    const envDefaultModel = getEnvDefaultModel();
+    if (!envDefaultModel) {
+        logger.warn(`[ModelManager] Stored model ${currentModelKey} is unavailable and env default model is missing`);
+        return;
+    }
+    const fallbackKey = getModelKey(envDefaultModel.providerID, envDefaultModel.modelID);
+    logger.warn(`[ModelManager] Stored model ${currentModelKey} is unavailable, falling back to ${fallbackKey}`);
+    setCurrentModel({
+        providerID: envDefaultModel.providerID,
+        modelID: envDefaultModel.modelID,
+        variant: "default",
+    });
+}
+export function __resetModelCatalogCacheForTests() {
+    cachedValidModelKeys = null;
+    modelCatalogCacheExpiresAt = 0;
+    modelCatalogFetchInFlight = null;
+}
+/**
+ * Get list of favorite models from OpenCode local state file
+ * Falls back to env default model if file is unavailable or empty
+ */
+export async function getFavoriteModels() {
+    const { favorites } = await getModelSelectionLists();
+    return favorites;
+}
+/**
+ * Get current model from settings or fallback to config
+ * @returns Current model info
+ */
+export function fetchCurrentModel() {
+    return getStoredModel();
+}
+/**
+ * Select model and persist to settings
+ * @param modelInfo Model to select
+ */
+export function selectModel(modelInfo) {
+    logger.info(`[ModelManager] Selected model: ${modelInfo.providerID}/${modelInfo.modelID}`);
+    setCurrentModel(modelInfo);
+}
+/**
+ * Get stored model from settings (synchronous)
+ * ALWAYS returns a model - fallback to config if not found
+ * @returns Current model info
+ */
+export function getStoredModel() {
+    const storedModel = getCurrentModel();
+    if (storedModel) {
+        // Ensure variant is set (default to "default")
+        if (!storedModel.variant) {
+            storedModel.variant = "default";
+        }
+        return storedModel;
+    }
+    // Fallback to model from config (environment variables)
+    if (config.opencode.model.provider && config.opencode.model.modelId) {
+        logger.debug("[ModelManager] Using model from config");
+        return {
+            providerID: config.opencode.model.provider,
+            modelID: config.opencode.model.modelId,
+            variant: "default",
+        };
+    }
+    // This should not happen if config is properly set
+    logger.warn("[ModelManager] No model found in settings or config, returning empty model");
+    return {
+        providerID: "",
+        modelID: "",
+        variant: "default",
+    };
+}

package/dist/model/types.js

@@ -0,0 +1,24 @@
+/**
+ * Model types and formatting utilities
+ */
+/**
+ * Format model for button display (compact format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID/modelID"
+ */
+export function formatModelForButton(providerID, modelID) {
+    // If model name is too long, we only truncate the model part
+    const displayModelId = modelID.length > 20 ? `${modelID.substring(0, 17)}...` : modelID;
+    const displayProviderId = providerID.length > 15 ? `${providerID.substring(0, 12)}...` : providerID;
+    return `🤖 ${displayProviderId}\n${displayModelId}`;
+}
+/**
+ * Format model for display in messages (full format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID / modelID"
+ */
+export function formatModelForDisplay(providerID, modelID) {
+    return `${providerID} / ${modelID}`;
+}