@coffer-org/plugin-telegram 2.2.3 → 3.0.0

package/dist/runtime/bot.js

@@ -3,10 +3,13 @@ import path from 'node:path';
 import { TelegramClient, Api } from 'teleproto';
 import { LogLevel } from 'teleproto/extensions/Logger.js';
 import { StringSession } from 'teleproto/sessions/index.js';
-import { NewMessage } from 'teleproto/events/index.js';
-import { handleIncoming, loadGatePolicy, makeLiveChannel, chunk } from '@coffer-org/plugin-orchestrator/runtime';
+import { NewMessage, CallbackQuery } from 'teleproto/events/index.js';
+import { Button } from 'teleproto/tl/custom/button.js';
+import { handleIncoming, loadGatePolicy, makeLiveChannel, chunk, listAgentCatalog, isSenderAllowed, liveAgentId, } from '@coffer-org/plugin-orchestrator/runtime';
+import { getThreadState, setThreadState } from '@coffer-org/server/thread-state';
 import { recordUser, recordAssistant, buildChain } from "./chain-store.js";
-import { loadBotConfig, hasCredentials, loadReasoningDisplay } from "./config.js";
+import { loadBotConfig, hasCredentials, loadReasoningDisplay, loadModelStrings } from "./config.js";
+import { buildModelKeyboard, isModelCommand, parseModelCallback } from "./model-command.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('telegram');
 const FALLBACK_REPLY_WINDOW_MS = 1_800_000;
@@ -55,7 +58,7 @@ export function renderWithReasoning(mode, max) {
     };
 }
 const TELEGRAM_FORMAT = [
-    'CRITICAL OUTPUT FORMAT — Telegram HTML ONLY. Format the reply strictly with Telegram\'s HTML subset (<b>, <i>, <code>, <a>, …) and NOTHING else. NEVER use Markdown — no *bold*, _italic_, **bold**, `code`, ```blocks```, # headings, - bullets, or | tables. Markdown does not render here; it shows up as literal characters and breaks the message. When in doubt, use an HTML tag or plain text.',
+    "CRITICAL OUTPUT FORMAT — Telegram HTML ONLY. Format the reply strictly with Telegram's HTML subset (<b>, <i>, <code>, <a>, …) and NOTHING else. NEVER use Markdown — no *bold*, _italic_, **bold**, `code`, ```blocks```, # headings, - bullets, or | tables. Markdown does not render here; it shows up as literal characters and breaks the message. When in doubt, use an HTML tag or plain text.",
     'Inline styling (tags may nest): <b>bold</b>, <i>italic</i>, <u>underline</u>, <s>strike</s>, <code>inline code</code>, <spoiler>spoiler</spoiler>. Links: <a href="https://…">text</a> (also <a href="tg://user?id=123">mention</a>).',
     'Blocks: <pre>code block</pre> or, for syntax highlight, <pre><code class="language-python">…</code></pre>. Quotes: <blockquote>quote</blockquote>, or <blockquote expandable>long collapsible quote</blockquote>. Bullet lists: start plain lines with "• ".',
     'Only those tags are parsed. NOT supported here (do not use): <tg-spoiler>, <span>, <ins>, <strike>, <tg-time> — use <spoiler>, <u>, <s> instead. Avoid <tg-emoji> (needs a custom-emoji id + Premium); use ordinary emoji.',
@@ -74,7 +77,13 @@ export function makeReplyFactory(t, display) {
             maxLength: TG_MAX,
             render: renderWithReasoning(display, TG_MAX),
         });
-        return display === 'separate' ? ch : { ...ch, segment() { } };
+        return display === 'separate'
+            ? ch
+            : {
+                ...ch,
+                segment() {
+                },
+            };
     };
 }
 function mediaInfo(message) {
@@ -159,6 +168,28 @@ export async function startBot(opts = {}) {
             }
         }
     }
+    async function sendModelKeyboard(peer, rows, prompt) {
+        if (rows.length === 0) {
+            log.warn('/model: no agent presets registered — nothing to show');
+            return;
+        }
+        try {
+            await tg.sendMessage(peer, {
+                message: prompt,
+                buttons: rows.map((row) => row.map((b) => Button.inline(b.text, Buffer.from(b.data, 'utf-8')))),
+            });
+        }
+        catch (err) {
+            log.warn(`send /model keyboard: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async function answerCallback(query, text) {
+        try {
+            await query.answer({ message: text });
+        }
+        catch {
+        }
+    }
     function startTypingPeer(peer) {
         let logged = false;
         let stopped = false;
@@ -180,9 +211,7 @@ export async function startBot(opts = {}) {
             }
             if (stopped)
                 return;
-            const ping = () => tg
-                .invoke(new Api.messages.SetTyping({ peer: input, action: new Api.SendMessageTypingAction() }))
-                .catch(warn);
+            const ping = () => tg.invoke(new Api.messages.SetTyping({ peer: input, action: new Api.SendMessageTypingAction() })).catch(warn);
             void ping();
             timer = setInterval(() => void ping(), 5000);
         })();
@@ -219,6 +248,14 @@ export async function startBot(opts = {}) {
             try {
                 const chatId = String(event.chatId ?? '?');
                 const userId = message.senderId?.toString() ?? '?';
+                if (isModelCommand(text)) {
+                    if (!(await isSenderAllowed('telegram', userId)))
+                        return;
+                    const strings = await loadModelStrings();
+                    const rows = buildModelKeyboard(await listAgentCatalog(), await getThreadState('telegram', chatId));
+                    await sendModelKeyboard(peer, rows, strings.prompt);
+                    return;
+                }
                 const incomingMsgId = String(message.id);
                 const replyTo = message.replyTo?.replyToMsgId ?? null;
                 let replyToId = replyTo != null ? String(replyTo) : null;
@@ -275,6 +312,8 @@ export async function startBot(opts = {}) {
                     }
                     : undefined;
                 const reasoningDisplay = await loadReasoningDisplay();
+                const selection = await getThreadState('telegram', chatId);
+                const selectedAgentId = liveAgentId(selection.agentId);
                 const connector = {
                     id: 'telegram',
                     reply: makeReplyFactory({
@@ -299,6 +338,8 @@ export async function startBot(opts = {}) {
                     sender: { id: userId, displayName },
                     messages,
                     ...(prepareAttachments ? { prepareAttachments } : {}),
+                    ...(selectedAgentId ? { agentId: selectedAgentId } : {}),
+                    ...(selection.presetId ? { presetId: selection.presetId } : {}),
                 });
             }
             finally {
@@ -309,6 +350,30 @@ export async function startBot(opts = {}) {
             log.error(`message handling: ${err instanceof Error ? err.message : String(err)}`);
         }
     }, new NewMessage({}));
+    tg.addEventHandler(async (event) => {
+        try {
+            const data = event.data?.toString('utf-8');
+            if (!data)
+                return;
+            const picked = parseModelCallback(data);
+            if (!picked)
+                return;
+            const senderId = event.senderId?.toString() ?? '?';
+            if (!(await isSenderAllowed('telegram', senderId)))
+                return;
+            if (!liveAgentId(picked.agentId)) {
+                log.warn(`/model tap named an unregistered agent: ${picked.agentId}`);
+                return;
+            }
+            const chatId = String(event.chatId ?? '?');
+            await setThreadState('telegram', chatId, picked);
+            const strings = await loadModelStrings();
+            await answerCallback(event, strings.confirm);
+        }
+        catch (err) {
+            log.error(`callback query handling: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, new CallbackQuery({}));
     clearInterval(healthTimer);
     healthTimer = setInterval(() => {
         if (!tg.connected) {

package/dist/runtime/chain-store.js

@@ -4,7 +4,17 @@ const log = getLogger('telegram');
 const CONNECTOR = 'telegram';
 const DEFAULT_MAX_DEPTH = 30;
 export async function recordUser(m) {
-    await putThreadMessage({ connector: CONNECTOR, chatId: m.chatId, msgId: m.msgId, role: 'user', sender: m.sender ?? null, attachments: m.attachments, text: m.text, ts: m.ts, replyToId: m.replyToId });
+    await putThreadMessage({
+        connector: CONNECTOR,
+        chatId: m.chatId,
+        msgId: m.msgId,
+        role: 'user',
+        sender: m.sender ?? null,
+        attachments: m.attachments,
+        text: m.text,
+        ts: m.ts,
+        replyToId: m.replyToId,
+    });
 }
 export async function recordAssistant(m) {
     if (m.botMsgId == null)
@@ -32,7 +42,16 @@ export async function buildChain(headMsgId, opts) {
             if (!fetched)
                 break;
             const role = fetched.senderId === opts.botId ? 'assistant' : 'user';
-            await putThreadMessage({ connector: CONNECTOR, chatId: opts.chatId, msgId: cur, role, sender: null, text: fetched.text, ts: fetched.date, replyToId: fetched.replyToId });
+            await putThreadMessage({
+                connector: CONNECTOR,
+                chatId: opts.chatId,
+                msgId: cur,
+                role,
+                sender: null,
+                text: fetched.text,
+                ts: fetched.date,
+                replyToId: fetched.replyToId,
+            });
             stored = { msgId: cur, role, sender: null, text: fetched.text, ts: fetched.date, replyToId: fetched.replyToId };
         }
         if (stored.role !== 'reasoning') {

package/dist/runtime/config.d.ts

@@ -15,3 +15,8 @@ export declare function hasCredentials(cfg: Pick<BotConfig, 'apiId' | 'apiHash'
 export type ReasoningDisplay = 'off' | 'collapsible' | 'separate';
 export declare function toReasoningDisplay(v: unknown): ReasoningDisplay;
 export declare function loadReasoningDisplay(): Promise<ReasoningDisplay>;
+export interface ModelStrings {
+    prompt: string;
+    confirm: string;
+}
+export declare function loadModelStrings(): Promise<ModelStrings>;

package/dist/runtime/config.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getPluginSettings } from '@coffer-org/server/plugin-runtime';
+import { loadPluginI18n } from '@coffer-org/server/plugin-i18n';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const PLUGIN_ROOT = path.resolve(__dirname, '../..');
 export function loadBotConfig(opts = {}) {
@@ -23,3 +24,11 @@ export function toReasoningDisplay(v) {
 export async function loadReasoningDisplay() {
     return toReasoningDisplay((await getPluginSettings('telegram'))['reasoning_display']);
 }
+const MODEL_STRINGS_FALLBACK = { prompt: 'Choose a model:', confirm: 'Done' };
+export async function loadModelStrings() {
+    const i18n = await loadPluginI18n(new URL('../../locales/', import.meta.url));
+    return {
+        prompt: i18n.t('telegram.model.prompt', MODEL_STRINGS_FALLBACK.prompt),
+        confirm: i18n.t('telegram.model.confirm', MODEL_STRINGS_FALLBACK.confirm),
+    };
+}

package/dist/runtime/model-command.d.ts

@@ -0,0 +1,12 @@
+import type { AgentDescriptor } from '@coffer-org/plugin-orchestrator/runtime';
+import type { ThreadSelection } from '@coffer-org/server/thread-state';
+export interface KeyboardButton {
+    text: string;
+    data: string;
+}
+export declare function isModelCommand(text: string): boolean;
+export declare function buildModelKeyboard(agents: AgentDescriptor[], selection: ThreadSelection): KeyboardButton[][];
+export declare function parseModelCallback(data: string): {
+    agentId: string;
+    presetId: string;
+} | null;

package/dist/runtime/model-command.js

@@ -0,0 +1,32 @@
+import { getLogger } from '@coffer-org/sdk/logger';
+const log = getLogger('telegram');
+const MODEL_COMMAND = /^\/model(@[a-z0-9_]{1,32})?(\s|$)/i;
+export function isModelCommand(text) {
+    return MODEL_COMMAND.test(text.trim());
+}
+const CALLBACK_MAX_BYTES = 64;
+function callbackBytes(data) {
+    return new TextEncoder().encode(data).length;
+}
+export function buildModelKeyboard(agents, selection) {
+    const multi = agents.length > 1;
+    return agents.flatMap((a) => a.presets.flatMap((p) => {
+        const data = `model:${a.id}:${p.id}`;
+        if (callbackBytes(data) > CALLBACK_MAX_BYTES) {
+            log.warn(`/model: skipping ${a.id}/${p.id} — callback data over ${CALLBACK_MAX_BYTES} bytes`);
+            return [];
+        }
+        const current = a.id === selection.agentId && p.id === selection.presetId;
+        const label = multi ? `${a.title} · ${p.title}` : p.title;
+        return [[{ text: current ? `✓ ${label}` : label, data }]];
+    }));
+}
+export function parseModelCallback(data) {
+    const parts = data.split(':');
+    if (parts.length !== 3 || parts[0] !== 'model')
+        return null;
+    const [, agentId, presetId] = parts;
+    if (!agentId || !presetId)
+        return null;
+    return { agentId, presetId };
+}

package/dist/schema.js

@@ -4502,6 +4502,8 @@ function normalizeOpts(rawIn) {
 		unique: r.unique,
 		fixed: r.fixed,
 		exts: r.exts,
+		ext: r.ext,
+		maxBytes: r.maxBytes,
 		lead: r.lead,
 		by: r.by,
 		min: r.min,
@@ -4913,6 +4915,42 @@ function snippet(raw) {
 		}
 	});
 }
+/** A NUL byte, or U+FFFD left behind by decoding non-UTF-8 bytes as text. */
+function isBinaryText(v) {
+	return v.includes("\0") || v.includes("�");
+}
+function source(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const ext = o.ext ?? "txt";
+	const maxBytes = o.maxBytes ?? 262144;
+	const s = string$1(reqTypeErr()).superRefine((v, ctx) => {
+		if (isBinaryText(v)) {
+			ctx.addIssue({
+				code: ZodIssueCode.custom,
+				message: vmsg("source_binary")
+			});
+			return;
+		}
+		if (new TextEncoder().encode(v).length > maxBytes) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			message: vmsg("source_too_large", { maxBytes })
+		});
+	});
+	return wrapKey(o, {
+		kind: "source",
+		label: o.label ?? "",
+		required,
+		prim: "text",
+		column: "text",
+		hints: {
+			ext,
+			maxBytes,
+			noEditControl: true
+		},
+		zod: optionalize(s, required)
+	});
+}
 function rating(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
@@ -5049,6 +5087,7 @@ var presets = {
 	tags,
 	markdown,
 	snippet,
+	source,
 	rating,
 	duration,
 	reminder,
@@ -6035,6 +6074,15 @@ function wrapKey(opts, meta) {
 		...m,
 		hidden: opts.hidden
 	};
+	if (opts.derive) m = {
+		...m,
+		derive: opts.derive,
+		derived: true,
+		hints: {
+			...m.hints,
+			noEditControl: true
+		}
+	};
 	if (opts.key) return {
 		key: opts.key,
 		type: m
@@ -6349,11 +6397,18 @@ function triState(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Inline option entry → OptionItem (plain string = value and label at once). */
+function toOptionItem(o) {
+	return typeof o === "string" ? {
+		value: o,
+		title: o
+	} : o;
+}
 function select(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const source = typeof o.options === "string" ? o.options : null;
-	const inlineOpts = Array.isArray(o.options) ? o.options : [];
+	const inlineOpts = Array.isArray(o.options) ? o.options.map(toOptionItem) : [];
 	const s = inlineOpts.length > 0 ? _enum(inlineOpts.map((x) => x.value), { error: () => vmsg("enum") }) : string$1(reqErr());
 	return wrapKey(o, applyMultiple({
 		kind: "select",
@@ -6550,6 +6605,47 @@ function measured(raw) {
 		zod: optionalize(s, required)
 	});
 }
+function unit(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const units = resolveUnits(o.options);
+	const s = string$1(reqErr()).refine((v) => units.some((u) => u.value === v), { message: vmsg("measured_unit") });
+	return wrapKey(o, {
+		kind: "unit",
+		label: o.label ?? "",
+		required,
+		prim: "select",
+		column: "text",
+		hints: { source: typeof o.options === "string" ? o.options : null },
+		options: units.map((u) => ({
+			value: u.value,
+			title: u.label
+		})),
+		zod: optionalize(s, required)
+	});
+}
+function amount(raw) {
+	const o = normalizeOpts(raw);
+	const required = o.required ?? false;
+	const cfg = o.config ?? {};
+	let s = number(typeErr());
+	if (cfg.min != null) s = s.min(cfg.min, { message: vmsg("min", { min: cfg.min }) });
+	if (cfg.max != null) s = s.max(cfg.max, { message: vmsg("max", { max: cfg.max }) });
+	return wrapKey(o, {
+		kind: "amount",
+		label: o.label ?? "",
+		required,
+		prim: "number",
+		column: "real",
+		hints: {
+			unitFrom: o.unitFrom,
+			min: cfg.min,
+			max: cfg.max,
+			step: cfg.step ?? "any"
+		},
+		zod: optionalize(s, required)
+	});
+}
 function money(raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
@@ -7027,6 +7123,8 @@ var PRIMITIVES = {
 	json,
 	check,
 	measured,
+	unit,
+	amount,
 	money,
 	code,
 	geo,
@@ -7072,7 +7170,7 @@ var field = new Proxy({}, {
 	has: (_t, k) => k in composedField()
 });
 function toClient(field) {
-	const { kind, label, required, prim, hints, options, relation, virtual, json, hidden } = field;
+	const { kind, label, required, prim, hints, options, relation, virtual, json, hidden, derived } = field;
 	return {
 		kind,
 		label,
@@ -7083,7 +7181,8 @@ function toClient(field) {
 		relation,
 		virtual,
 		json,
-		hidden
+		hidden,
+		derived
 	};
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-telegram",
-  "version": "2.2.3",
+  "version": "3.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -25,9 +25,9 @@
     "test": "node --import tsx --test \"src/runtime/*.test.ts\""
   },
   "dependencies": {
-    "@coffer-org/plugin-orchestrator": "^2.3.3",
-    "@coffer-org/sdk": "^2.1.3",
-    "@coffer-org/server": "^2.5.2",
+    "@coffer-org/plugin-orchestrator": "^3.0.0",
+    "@coffer-org/sdk": "^3.0.0",
+    "@coffer-org/server": "^3.0.0",
     "input": "^1.0.1",
     "teleproto": "^1.228.1"
   },