moltbot-termux 2026.1.27-1 → 2026.1.27-2-pre

package/CHANGELOG.md

@@ -77,6 +77,13 @@ Status: beta.
 - macOS: auto-scroll to bottom when sending a new message while scrolled up. (#2471) Thanks @kennyklee.
 - Web UI: auto-expand the chat compose textarea while typing (with sensible max height). (#2950) Thanks @shivamraut101.
 - Gateway: prevent crashes on transient network errors (fetch failures, timeouts, DNS). Added fatal error detection to only exit on truly critical errors. Fixes #2895, #2879, #2873. (#2980) Thanks @elliotsecops.
+- Agents: guard channel tool listActions to avoid plugin crashes. (#2859) Thanks @mbelinky.
+- Discord: avoid resolving bare channel names to user DMs when a username matches. Thanks @thewilloftheshadow.
+- Discord: fix directory config type import for target resolution. Thanks @thewilloftheshadow.
+- Providers: update MiniMax API endpoint and compatibility mode. (#3064) Thanks @hlbbbbbbb.
+- Telegram: treat more network errors as recoverable in polling. (#3013) Thanks @ryancontent.
+- Discord: resolve usernames to user IDs for outbound messages. (#2649) Thanks @nonggialiang.
+- Providers: update Moonshot Kimi model references to kimi-k2.5. (#2762) Thanks @MarvinCui.
 - Gateway: suppress AbortError and transient network errors in unhandled rejections. (#2451) Thanks @Glucksberg.
 - TTS: keep /tts status replies on text-only commands and avoid duplicate block-stream audio. (#2451) Thanks @Glucksberg.
 - Security: pin npm overrides to keep tar@7.5.4 for install toolchains.
@@ -90,6 +97,7 @@ Status: beta.
 - Agents: release session locks on process termination and cover more signals. (#2483) Thanks @janeexai.
 - Agents: skip cooldowned providers during model failover. (#2143) Thanks @YiWang24.
 - Telegram: harden polling + retry behavior for transient network errors and Node 22 transport issues. (#2420) Thanks @techboss.
+- Telegram: ignore non-forum group message_thread_id while preserving DM thread sessions. (#2731) Thanks @dylanneve1.
 - Telegram: wrap reasoning italics per line to avoid raw underscores. (#2181) Thanks @YuriNachos.
 - Telegram: centralize API error logging for delivery and bot calls. (#2492) Thanks @altryne.
 - Voice Call: enforce Twilio webhook signature verification for ngrok URLs; disable ngrok free tier bypass by default.

package/dist/agents/channel-tools.js

@@ -1,6 +1,7 @@
 import { getChannelDock } from "../channels/dock.js";
 import { getChannelPlugin, listChannelPlugins } from "../channels/plugins/index.js";
 import { normalizeAnyChannelId } from "../channels/registry.js";
+import { defaultRuntime } from "../runtime.js";
 /**
  * Get the list of supported message actions for a specific channel.
  * Returns an empty array if channel is not found or has no actions configured.
@@ -12,7 +13,7 @@ export function listChannelSupportedActions(params) {
     if (!plugin?.actions?.listActions)
         return [];
     const cfg = params.cfg ?? {};
-    return plugin.actions.listActions({ cfg });
+    return runPluginListActions(plugin, cfg);
 }
 /**
  * Get the list of all supported message actions across all configured channels.
@@ -23,7 +24,7 @@ export function listAllChannelSupportedActions(params) {
         if (!plugin.actions?.listActions)
             continue;
         const cfg = params.cfg ?? {};
-        const channelActions = plugin.actions.listActions({ cfg });
+        const channelActions = runPluginListActions(plugin, cfg);
         for (const action of channelActions) {
             actions.add(action);
         }
@@ -56,3 +57,31 @@ export function resolveChannelMessageToolHints(params) {
         .map((entry) => entry.trim())
         .filter(Boolean);
 }
+const loggedListActionErrors = new Set();
+function runPluginListActions(plugin, cfg) {
+    if (!plugin.actions?.listActions)
+        return [];
+    try {
+        const listed = plugin.actions.listActions({ cfg });
+        return Array.isArray(listed) ? listed : [];
+    }
+    catch (err) {
+        logListActionsError(plugin.id, err);
+        return [];
+    }
+}
+function logListActionsError(pluginId, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const key = `${pluginId}:${message}`;
+    if (loggedListActionErrors.has(key))
+        return;
+    loggedListActionErrors.add(key);
+    const stack = err instanceof Error && err.stack ? err.stack : null;
+    const details = stack ?? message;
+    defaultRuntime.error?.(`[channel-tools] ${pluginId}.actions.listActions failed: ${details}`);
+}
+export const __testing = {
+    resetLoggedListActionErrors() {
+        loggedListActionErrors.clear();
+    },
+};

package/dist/agents/models-config.providers.js

@@ -4,7 +4,7 @@ import { resolveAwsSdkEnvVarName, resolveEnvApiKey } from "./model-auth.js";
 import { discoverBedrockModels } from "./bedrock-discovery.js";
 import { buildSyntheticModelDefinition, SYNTHETIC_BASE_URL, SYNTHETIC_MODEL_CATALOG, } from "./synthetic-models.js";
 import { discoverVeniceModels, VENICE_BASE_URL } from "./venice-models.js";
-const MINIMAX_API_BASE_URL = "https://api.minimax.io/anthropic";
+const MINIMAX_API_BASE_URL = "https://api.minimax.chat/v1";
 const MINIMAX_DEFAULT_MODEL_ID = "MiniMax-M2.1";
 const MINIMAX_DEFAULT_VISION_MODEL_ID = "MiniMax-VL-01";
 const MINIMAX_DEFAULT_CONTEXT_WINDOW = 200000;
@@ -17,7 +17,7 @@ const MINIMAX_API_COST = {
     cacheWrite: 10,
 };
 const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
-const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
+const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2.5";
 const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
 const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
 const MOONSHOT_DEFAULT_COST = {
@@ -198,7 +198,7 @@ export function normalizeProviders(params) {
 function buildMinimaxProvider() {
     return {
         baseUrl: MINIMAX_API_BASE_URL,
-        api: "anthropic-messages",
+        api: "openai-completions",
         models: [
             {
                 id: MINIMAX_DEFAULT_MODEL_ID,
@@ -228,7 +228,7 @@ function buildMoonshotProvider() {
         models: [
             {
                 id: MOONSHOT_DEFAULT_MODEL_ID,
-                name: "Kimi K2 0905 Preview",
+                name: "Kimi K2.5",
                 reasoning: false,
                 input: ["text"],
                 cost: MOONSHOT_DEFAULT_COST,

package/dist/agents/transcript-policy.js

@@ -30,7 +30,8 @@ function isAnthropicApi(modelApi, provider) {
     if (modelApi === "anthropic-messages")
         return true;
     const normalized = normalizeProviderId(provider ?? "");
-    return normalized === "anthropic" || normalized === "minimax";
+    // MiniMax now uses openai-completions API, not anthropic-messages
+    return normalized === "anthropic";
 }
 function isMistralModel(params) {
     const provider = normalizeProviderId(params.provider ?? "");

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.1.27-1",
-  "commit": "0c9dde1181e14a0b0da113dc119ba7d5a3977ece",
-  "builtAt": "2026-01-28T05:08:31.899Z"
+  "version": "2026.1.27-2-pre",
+  "commit": "ea53cbc3cebd63f309cc698a7de6d7c1c83d8811",
+  "builtAt": "2026-01-28T06:28:40.764Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-78705dc5edb010dd13a5225641862dd1580e2058b2ff024d9be6e2ec011f80e5
+5ab92d64997cf901fe504836ff46635580f54cac27a47cefee42eb50bfced85f

package/dist/cli/banner.js

@@ -46,12 +46,12 @@ export function formatCliBannerLine(version, options = {}) {
     return `${line1}\n${line2}`;
 }
 const LOBSTER_ASCII = [
-    "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
-    "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
-    "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
-    "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
-    "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
-    "              🦞 FRESH DAILY 🦞",
+    "▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄",
+    "██░▄▀▄░██░▄▄▄░██░████▄▄░▄▄██░▄▄▀██░▄▄▄░█▄▄░▄▄██",
+    "██░█░█░██░███░██░██████░████░▄▄▀██░███░███░████",
+    "██░███░██░▀▀▀░██░▀▀░███░████░▀▀░██░▀▀▀░███░████",
+    "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀",
+    "               🦞 FRESH DAILY 🦞               ",
 ];
 export function formatCliBannerArt(options = {}) {
     const rich = options.richTty ?? isRich();

package/dist/commands/onboard-helpers.js

@@ -53,12 +53,12 @@ export function randomToken() {
 }
 export function printWizardHeader(runtime) {
     const header = [
-        "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
-        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
-        "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
-        "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
-        "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
-        "              🦞 FRESH DAILY 🦞",
+        "▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄",
+        "██░▄▀▄░██░▄▄▄░██░████▄▄░▄▄██░▄▄▀██░▄▄▄░█▄▄░▄▄██",
+        "██░█░█░██░███░██░██████░████░▄▄▀██░███░███░████",
+        "██░███░██░▀▀▀░██░▀▀░███░████░▀▀░██░▀▀▀░███░████",
+        "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀",
+        "               🦞 FRESH DAILY 🦞               ",
     ].join("\n");
     runtime.log(header);
 }

package/dist/config/paths.js

@@ -93,6 +93,7 @@ export function resolveConfigPath(env = process.env, stateDir = resolveStateDir(
     const override = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
     if (override)
         return resolveUserPath(override);
+    const stateOverride = env.MOLTBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
     const candidates = [
         path.join(stateDir, CONFIG_FILENAME),
         path.join(stateDir, LEGACY_CONFIG_FILENAME),
@@ -107,6 +108,8 @@ export function resolveConfigPath(env = process.env, stateDir = resolveStateDir(
     });
     if (existing)
         return existing;
+    if (stateOverride)
+        return path.join(stateDir, CONFIG_FILENAME);
     const defaultStateDir = resolveStateDir(env, homedir);
     if (path.resolve(stateDir) === path.resolve(defaultStateDir)) {
         return resolveConfigPathCandidate(env, homedir);

package/dist/discord/send.outbound.js

@@ -5,7 +5,7 @@ import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { convertMarkdownTables } from "../markdown/tables.js";
 import { resolveDiscordAccount } from "./accounts.js";
-import { buildDiscordSendError, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
+import { buildDiscordSendError, createDiscordClient, normalizeDiscordPollInput, normalizeStickerIds, parseAndResolveRecipient, resolveChannelId, sendDiscordMedia, sendDiscordText, } from "./send.shared.js";
 export async function sendMessageDiscord(to, text, opts = {}) {
     const cfg = loadConfig();
     const accountInfo = resolveDiscordAccount({
@@ -20,7 +20,7 @@ export async function sendMessageDiscord(to, text, opts = {}) {
     const chunkMode = resolveChunkMode(cfg, "discord", accountInfo.accountId);
     const textWithTables = convertMarkdownTables(text ?? "", tableMode);
     const { token, rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     let result;
     try {
@@ -52,7 +52,7 @@ export async function sendMessageDiscord(to, text, opts = {}) {
 export async function sendStickerDiscord(to, stickerIds, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const stickers = normalizeStickerIds(stickerIds);
@@ -70,7 +70,7 @@ export async function sendStickerDiscord(to, stickerIds, opts = {}) {
 export async function sendPollDiscord(to, poll, opts = {}) {
     const cfg = loadConfig();
     const { rest, request } = createDiscordClient(opts, cfg);
-    const recipient = parseRecipient(to);
+    const recipient = await parseAndResolveRecipient(to, opts.accountId);
     const { channelId } = await resolveChannelId(rest, recipient, request);
     const content = opts.content?.trim();
     const payload = normalizeDiscordPollInput(poll);

package/dist/discord/send.shared.js

@@ -9,7 +9,7 @@ import { resolveDiscordAccount } from "./accounts.js";
 import { chunkDiscordTextWithMode } from "./chunk.js";
 import { fetchChannelPermissionsDiscord, isThreadChannelType } from "./send.permissions.js";
 import { DiscordSendError } from "./send.types.js";
-import { parseDiscordTarget } from "./targets.js";
+import { parseDiscordTarget, resolveDiscordTarget } from "./targets.js";
 import { normalizeDiscordToken } from "./token.js";
 const DISCORD_TEXT_LIMIT = 2000;
 const DISCORD_MAX_STICKERS = 3;
@@ -68,6 +68,35 @@ function parseRecipient(raw) {
     }
     return { kind: target.kind, id: target.id };
 }
+/**
+ * Parse and resolve Discord recipient, including username lookup.
+ * This enables sending DMs by username (e.g., "john.doe") by querying
+ * the Discord directory to resolve usernames to user IDs.
+ *
+ * @param raw - The recipient string (username, ID, or known format)
+ * @param accountId - Discord account ID to use for directory lookup
+ * @returns Parsed DiscordRecipient with resolved user ID if applicable
+ */
+export async function parseAndResolveRecipient(raw, accountId) {
+    const cfg = loadConfig();
+    const accountInfo = resolveDiscordAccount({ cfg, accountId });
+    // First try to resolve using directory lookup (handles usernames)
+    const resolved = await resolveDiscordTarget(raw, {
+        cfg,
+        accountId: accountInfo.accountId,
+    });
+    if (resolved) {
+        return { kind: resolved.kind, id: resolved.id };
+    }
+    // Fallback to standard parsing (for channels, etc.)
+    const parsed = parseDiscordTarget(raw, {
+        ambiguousMessage: `Ambiguous Discord recipient "${raw.trim()}". Use "user:${raw.trim()}" for DMs or "channel:${raw.trim()}" for channel messages.`,
+    });
+    if (!parsed) {
+        throw new Error("Recipient is required for Discord sends");
+    }
+    return { kind: parsed.kind, id: parsed.id };
+}
 function normalizeStickerIds(raw) {
     const ids = raw.map((entry) => entry.trim()).filter(Boolean);
     if (ids.length === 0) {

package/dist/discord/targets.js

@@ -1,4 +1,5 @@
 import { buildMessagingTarget, ensureTargetId, requireTargetKind, } from "../channels/targets.js";
+import { listDiscordDirectoryPeersLive } from "./directory-live.js";
 export function parseDiscordTarget(raw, options = {}) {
     const trimmed = raw.trim();
     if (!trimmed)
@@ -41,3 +42,68 @@ export function resolveDiscordChannelId(raw) {
     const target = parseDiscordTarget(raw, { defaultKind: "channel" });
     return requireTargetKind({ platform: "Discord", target, kind: "channel" });
 }
+/**
+ * Resolve a Discord username to user ID using the directory lookup.
+ * This enables sending DMs by username instead of requiring explicit user IDs.
+ *
+ * @param raw - The username or raw target string (e.g., "john.doe")
+ * @param options - Directory configuration params (cfg, accountId, limit)
+ * @param parseOptions - Optional parsing options (defaultKind, ambiguousMessage)
+ * @returns Parsed MessagingTarget with user ID, or undefined if not found
+ */
+export async function resolveDiscordTarget(raw, options, parseOptions = {}) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    const shouldLookup = isExplicitUserLookup(trimmed, parseOptions);
+    const directParse = safeParseDiscordTarget(trimmed, parseOptions);
+    if (directParse && directParse.kind !== "channel") {
+        return directParse;
+    }
+    if (!shouldLookup) {
+        return directParse ?? parseDiscordTarget(trimmed, parseOptions);
+    }
+    // Try to resolve as a username via directory lookup
+    try {
+        const directoryEntries = await listDiscordDirectoryPeersLive({
+            ...options,
+            query: trimmed,
+            limit: 1,
+        });
+        const match = directoryEntries[0];
+        if (match && match.kind === "user") {
+            // Extract user ID from the directory entry (format: "user:<id>")
+            const userId = match.id.replace(/^user:/, "");
+            return buildMessagingTarget("user", userId, trimmed);
+        }
+    }
+    catch (error) {
+        // Directory lookup failed - fall through to parse as-is
+        // This preserves existing behavior for channel names
+    }
+    // Fallback to original parsing (for channels, etc.)
+    return parseDiscordTarget(trimmed, parseOptions);
+}
+function safeParseDiscordTarget(input, options) {
+    try {
+        return parseDiscordTarget(input, options);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isExplicitUserLookup(input, options) {
+    if (/^<@!?(\d+)>$/.test(input)) {
+        return true;
+    }
+    if (/^(user:|discord:)/.test(input)) {
+        return true;
+    }
+    if (input.startsWith("@")) {
+        return true;
+    }
+    if (/^\d+$/.test(input)) {
+        return options.defaultKind === "user";
+    }
+    return false;
+}

package/dist/telegram/bot/helpers.js

@@ -1,10 +1,21 @@
 import { formatLocationText } from "../../channels/location.js";
 const TELEGRAM_GENERAL_TOPIC_ID = 1;
+/**
+ * Resolve the thread ID for Telegram forum topics.
+ * For non-forum groups, returns undefined even if messageThreadId is present
+ * (reply threads in regular groups should not create separate sessions).
+ * For forum groups, returns the topic ID (or General topic ID=1 if unspecified).
+ */
 export function resolveTelegramForumThreadId(params) {
-    if (params.isForum && params.messageThreadId == null) {
+    // Non-forum groups: ignore message_thread_id (reply threads are not real topics)
+    if (!params.isForum) {
+        return undefined;
+    }
+    // Forum groups: use the topic ID, defaulting to General topic
+    if (params.messageThreadId == null) {
         return TELEGRAM_GENERAL_TOPIC_ID;
     }
-    return params.messageThreadId ?? undefined;
+    return params.messageThreadId;
 }
 /**
  * Build thread params for Telegram API calls (messages, media).

package/dist/telegram/bot-message-context.js

@@ -66,7 +66,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         },
     });
     const baseSessionKey = route.sessionKey;
-    const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+    // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+    const dmThreadId = !isGroup ? messageThreadId : undefined;
     const threadKeys = dmThreadId != null
         ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
         : null;
@@ -438,7 +439,8 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
         Sticker: allMedia[0]?.stickerMetadata,
         ...(locationData ? toLocationContext(locationData) : undefined),
         CommandAuthorized: commandAuthorized,
-        MessageThreadId: resolvedThreadId,
+        // For groups: use resolvedThreadId (forum topics only); for DMs: use raw messageThreadId
+        MessageThreadId: isGroup ? resolvedThreadId : messageThreadId,
         IsForum: isForum,
         // Originating channel for reply routing.
         OriginatingChannel: "telegram",

package/dist/telegram/bot-native-commands.js

@@ -189,7 +189,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
         ...customCommands,
     ];
     if (allCommands.length > 0) {
-        void withTelegramApiErrorLogging({
+        withTelegramApiErrorLogging({
             operation: "setMyCommands",
             runtime,
             fn: () => bot.api.setMyCommands(allCommands),
@@ -220,6 +220,8 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                     if (!auth)
                         return;
                     const { chatId, isGroup, isForum, resolvedThreadId, senderId, senderUsername, groupConfig, topicConfig, commandAuthorized, } = auth;
+                    const messageThreadId = msg.message_thread_id;
+                    const threadIdForSend = isGroup ? resolvedThreadId : messageThreadId;
                     const commandDefinition = findCommandByNativeName(command.name, "telegram");
                     const rawText = ctx.match?.trim() ?? "";
                     const commandArgs = commandDefinition
@@ -261,7 +263,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                             runtime,
                             fn: () => bot.api.sendMessage(chatId, title, {
                                 ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
-                                ...(resolvedThreadId != null ? { message_thread_id: resolvedThreadId } : {}),
+                                ...(threadIdForSend != null ? { message_thread_id: threadIdForSend } : {}),
                             }),
                         });
                         return;
@@ -276,7 +278,8 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         },
                     });
                     const baseSessionKey = route.sessionKey;
-                    const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+                    // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+                    const dmThreadId = !isGroup ? messageThreadId : undefined;
                     const threadKeys = dmThreadId != null
                         ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
                         : null;
@@ -319,7 +322,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         CommandSource: "native",
                         SessionKey: `telegram:slash:${senderId || chatId}`,
                         CommandTargetSessionKey: sessionKey,
-                        MessageThreadId: resolvedThreadId,
+                        MessageThreadId: threadIdForSend,
                         IsForum: isForum,
                         // Originating context for sub-agent announce routing
                         OriginatingChannel: "telegram",
@@ -343,7 +346,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                                     bot,
                                     replyToMode,
                                     textLimit,
-                                    messageThreadId: resolvedThreadId,
+                                    messageThreadId: threadIdForSend,
                                     tableMode,
                                     chunkMode,
                                     linkPreview: telegramCfg.linkPreview,
@@ -393,7 +396,9 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                     });
                     if (!auth)
                         return;
-                    const { resolvedThreadId, senderId, commandAuthorized } = auth;
+                    const { resolvedThreadId, senderId, commandAuthorized, isGroup } = auth;
+                    const messageThreadId = msg.message_thread_id;
+                    const threadIdForSend = isGroup ? resolvedThreadId : messageThreadId;
                     const result = await executePluginCommand({
                         command: match.command,
                         args: match.args,
@@ -417,7 +422,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
                         bot,
                         replyToMode,
                         textLimit,
-                        messageThreadId: resolvedThreadId,
+                        messageThreadId: threadIdForSend,
                         tableMode,
                         chunkMode,
                         linkPreview: telegramCfg.linkPreview,
@@ -427,7 +432,7 @@ export const registerTelegramNativeCommands = ({ bot, cfg, runtime, accountId, t
         }
     }
     else if (nativeDisabledExplicit) {
-        void withTelegramApiErrorLogging({
+        withTelegramApiErrorLogging({
             operation: "setMyCommands",
             runtime,
             fn: () => bot.api.setMyCommands([]),

package/dist/telegram/bot.js

@@ -45,11 +45,12 @@ export function getTelegramSequentialKey(ctx) {
             return `telegram:${chatId}:control`;
         return "telegram:control";
     }
+    const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
+    const messageThreadId = msg?.message_thread_id;
     const isForum = msg?.chat?.is_forum;
-    const threadId = resolveTelegramForumThreadId({
-        isForum,
-        messageThreadId: msg?.message_thread_id,
-    });
+    const threadId = isGroup
+        ? resolveTelegramForumThreadId({ isForum, messageThreadId })
+        : messageThreadId;
     if (typeof chatId === "number") {
         return threadId != null ? `telegram:${chatId}:topic:${threadId}` : `telegram:${chatId}`;
     }
@@ -357,7 +358,8 @@ export function createTelegramBot(opts) {
                 peer: { kind: isGroup ? "group" : "dm", id: peerId },
             });
             const baseSessionKey = route.sessionKey;
-            const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+            // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+            const dmThreadId = !isGroup ? messageThreadId : undefined;
             const threadKeys = dmThreadId != null
                 ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
                 : null;

package/dist/telegram/monitor.js

@@ -50,6 +50,23 @@ const isGetUpdatesConflict = (err) => {
         .toLowerCase();
     return haystack.includes("getupdates");
 };
+const NETWORK_ERROR_SNIPPETS = [
+    "fetch failed",
+    "network",
+    "timeout",
+    "socket",
+    "econnreset",
+    "econnrefused",
+    "undici",
+];
+const isNetworkRelatedError = (err) => {
+    if (!err)
+        return false;
+    const message = formatErrorMessage(err).toLowerCase();
+    if (!message)
+        return false;
+    return NETWORK_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
+};
 export async function monitorTelegramProvider(opts = {}) {
     const cfg = opts.config ?? loadConfig();
     const account = resolveTelegramAccount({
@@ -126,7 +143,8 @@ export async function monitorTelegramProvider(opts = {}) {
             }
             const isConflict = isGetUpdatesConflict(err);
             const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-            if (!isConflict && !isRecoverable) {
+            const isNetworkError = isNetworkRelatedError(err);
+            if (!isConflict && !isRecoverable && !isNetworkError) {
                 throw err;
             }
             restartAttempts += 1;

package/dist/telegram/network-errors.js

@@ -14,6 +14,8 @@ const RECOVERABLE_ERROR_CODES = new Set([
     "UND_ERR_BODY_TIMEOUT",
     "UND_ERR_SOCKET",
     "UND_ERR_ABORTED",
+    "ECONNABORTED",
+    "ERR_NETWORK",
 ]);
 const RECOVERABLE_ERROR_NAMES = new Set([
     "AbortError",
@@ -24,6 +26,8 @@ const RECOVERABLE_ERROR_NAMES = new Set([
 ]);
 const RECOVERABLE_MESSAGE_SNIPPETS = [
     "fetch failed",
+    "typeerror: fetch failed",
+    "undici",
     "network error",
     "network request",
     "client network socket disconnected",

package/docs/concepts/model-providers.md

@@ -130,9 +130,10 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
 
 - Provider: `moonshot`
 - Auth: `MOONSHOT_API_KEY`
-- Example model: `moonshot/kimi-k2-0905-preview`
+- Example model: `moonshot/kimi-k2.5`
 - Kimi K2 model IDs:
   {/* moonshot-kimi-k2-model-refs:start */}
+  - `moonshot/kimi-k2.5`
   - `moonshot/kimi-k2-0905-preview`
   - `moonshot/kimi-k2-turbo-preview`
   - `moonshot/kimi-k2-thinking`
@@ -141,7 +142,7 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
 ```json5
 {
   agents: {
-    defaults: { model: { primary: "moonshot/kimi-k2-0905-preview" } }
+    defaults: { model: { primary: "moonshot/kimi-k2.5" } }
   },
   models: {
     mode: "merge",
@@ -150,7 +151,7 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
         baseUrl: "https://api.moonshot.ai/v1",
         apiKey: "${MOONSHOT_API_KEY}",
         api: "openai-completions",
-        models: [{ id: "kimi-k2-0905-preview", name: "Kimi K2 0905 Preview" }]
+        models: [{ id: "kimi-k2.5", name: "Kimi K2.5" }]
       }
     }
   }

package/docs/gateway/configuration.md

@@ -2396,8 +2396,8 @@ Use Moonshot's OpenAI-compatible endpoint:
   env: { MOONSHOT_API_KEY: "sk-..." },
   agents: {
     defaults: {
-      model: { primary: "moonshot/kimi-k2-0905-preview" },
-      models: { "moonshot/kimi-k2-0905-preview": { alias: "Kimi K2" } }
+      model: { primary: "moonshot/kimi-k2.5" },
+      models: { "moonshot/kimi-k2.5": { alias: "Kimi K2.5" } }
     }
   },
   models: {
@@ -2409,8 +2409,8 @@ Use Moonshot's OpenAI-compatible endpoint:
         api: "openai-completions",
         models: [
           {
-            id: "kimi-k2-0905-preview",
-            name: "Kimi K2 0905 Preview",
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
             reasoning: false,
             input: ["text"],
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -2426,7 +2426,7 @@ Use Moonshot's OpenAI-compatible endpoint:
 
 Notes:
 - Set `MOONSHOT_API_KEY` in the environment or use `moltbot onboard --auth-choice moonshot-api-key`.
-- Model ref: `moonshot/kimi-k2-0905-preview`.
+- Model ref: `moonshot/kimi-k2.5`.
 - Use `https://api.moonshot.cn/v1` if you need the China endpoint.
 
 ### Kimi Code