@coffer-org/plugin-telegram 1.4.0 → 2.0.0

package/dist/index.js

@@ -12,6 +12,16 @@ export default definePlugin({
             field.password({ key: 'api_hash', label: 'telegram.settings.api_hash' }),
             field.password({ key: 'bot_token', label: 'telegram.settings.bot_token' }),
             field.tel({ key: 'phone', label: 'telegram.settings.phone' }),
+            field.select({
+                key: 'reasoning_display',
+                label: 'telegram.settings.reasoning_display',
+                default: 'collapsible',
+                options: [
+                    { value: 'off', title: 'telegram.settings.reasoning_display_off' },
+                    { value: 'collapsible', title: 'telegram.settings.reasoning_display_collapsible' },
+                    { value: 'separate', title: 'telegram.settings.reasoning_display_separate' },
+                ],
+            }),
         ],
     }),
 });

package/dist/runtime/bot.d.ts

@@ -1,5 +1,11 @@
-import type { LoadOpts } from './config.ts';
+import type { LiveChannelOps, RenderFn, ReplyChannel, ReplyContext } from '@coffer-org/plugin-orchestrator/runtime';
+import type { LoadOpts, ReasoningDisplay } from './config.ts';
 export declare function stripHtml(s: string): string;
+export declare function escHtml(s: string): string;
+export declare function renderWithReasoning(mode: ReasoningDisplay, max: number): RenderFn;
+export declare const TG_MAX = 4096;
+export declare const TG_THROTTLE_MS = 2000;
+export declare function makeReplyFactory(t: LiveChannelOps, display: ReasoningDisplay): (_chatId: string, _ctx: ReplyContext) => ReplyChannel;
 export type StartOpts = LoadOpts;
 export declare function startBot(opts?: StartOpts): Promise<boolean>;
 export declare function stopBot(): Promise<void>;

package/dist/runtime/bot.js

@@ -4,9 +4,9 @@ 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 } from '@coffer-org/plugin-orchestrator/runtime';
+import { handleIncoming, loadGatePolicy, makeLiveChannel, chunk } from '@coffer-org/plugin-orchestrator/runtime';
 import { recordUser, recordAssistant, buildChain } from "./chain-store.js";
-import { loadBotConfig, hasCredentials } from "./config.js";
+import { loadBotConfig, hasCredentials, loadReasoningDisplay } from "./config.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 const log = getLogger('telegram');
 const FALLBACK_REPLY_WINDOW_MS = 1_800_000;
@@ -29,6 +29,31 @@ export function stripHtml(s) {
         .replace(/'/g, "'")
         .replace(/&/g, '&');
 }
+export function escHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+const OPEN = '<blockquote expandable>';
+const CLOSE = '</blockquote>\n\n';
+const MIN_REASONING = 100;
+export function renderWithReasoning(mode, max) {
+    return ({ text, reasoning }) => {
+        const answer = (text ?? '').trim() || '⚠️ the agent returned no response';
+        if (mode !== 'collapsible')
+            return chunk(answer, max);
+        const raw = (reasoning ?? '').trim();
+        if (!raw)
+            return chunk(answer, max);
+        const parts = chunk(answer, max);
+        const head = parts[0];
+        const room = max - head.length - OPEN.length - CLOSE.length;
+        if (room < MIN_REASONING)
+            return parts;
+        let body = escHtml(raw);
+        if (body.length > room)
+            body = `…${body.slice(-(room - 1))}`;
+        return [`${OPEN}${body}${CLOSE}${head}`, ...parts.slice(1)];
+    };
+}
 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.',
     '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>).',
@@ -39,6 +64,19 @@ const TELEGRAM_FORMAT = [
     'Beyond the tags, use Unicode symbols and emoji to structure and enrich replies — they render everywhere: bullets (•, ▪, –), separators (─────), arrows (→), status marks (✅ ⚠️ ❌ ⏳), and topic emoji (📅 💰 🏥 🛒 🌱 …). They make messages scannable and friendly.',
     'Keep replies short and skimmable (messages cap at 4096 chars): prefer short paragraphs and "• " bullet lists over long prose.',
 ].join('\n');
+export const TG_MAX = 4096;
+export const TG_THROTTLE_MS = 2000;
+export function makeReplyFactory(t, display) {
+    return (_chatId, _ctx) => {
+        const ch = makeLiveChannel({
+            ops: t,
+            throttleMs: TG_THROTTLE_MS,
+            maxLength: TG_MAX,
+            render: renderWithReasoning(display, TG_MAX),
+        });
+        return display === 'separate' ? ch : { ...ch, segment() { } };
+    };
+}
 function loadSessionString(file) {
     try {
         return fs.readFileSync(file, 'utf-8');
@@ -197,21 +235,18 @@ export async function startBot(opts = {}) {
                     }
                 };
                 const messages = await buildChain(incomingMsgId, { chatId, fetch, botId: meId ?? '' });
+                const reasoningDisplay = await loadReasoningDisplay();
                 const connector = {
                     id: 'telegram',
-                    capabilities: { streaming: true, typing: true, maxMessageLength: 4096 },
-                    async sendMessage(_chatId, msgText) {
-                        const sent = await sendHtml(peer, msgText, Number(incomingMsgId));
-                        if (!sent)
-                            return null;
-                        return { msgId: String(sent.id) };
-                    },
-                    async editMessage(_chatId, editId, msgText) {
-                        await editHtml(peer, Number(editId), msgText);
-                    },
-                    startTyping(_chatId) {
-                        return () => { };
-                    },
+                    reply: makeReplyFactory({
+                        send: async (text) => {
+                            const sent = await sendHtml(peer, text, Number(incomingMsgId));
+                            return sent ? String(sent.id) : null;
+                        },
+                        edit: async (msgId, text) => {
+                            await editHtml(peer, Number(msgId), text);
+                        },
+                    }, reasoningDisplay),
                     async recordAssistant(m) {
                         await recordAssistant({ ...m, chatId, now: Math.floor(Date.now() / 1000) });
                         if (m.botMsgId)

package/dist/runtime/chain-store.js

@@ -35,7 +35,9 @@ export async function buildChain(headMsgId, opts) {
             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 };
         }
-        acc.push({ role: stored.role, content: stored.text, sender: stored.sender, msgId: stored.msgId, ts: stored.ts });
+        if (stored.role !== 'reasoning') {
+            acc.push({ role: stored.role, content: stored.text, sender: stored.sender, msgId: stored.msgId, ts: stored.ts });
+        }
         cur = stored.replyToId;
     }
     if (acc.length >= max)

package/dist/runtime/config.d.ts

@@ -12,3 +12,6 @@ export interface LoadOpts {
 }
 export declare function loadBotConfig(opts?: LoadOpts): BotConfig;
 export declare function hasCredentials(cfg: Pick<BotConfig, 'apiId' | 'apiHash' | 'botToken' | 'phone'>): boolean;
+export type ReasoningDisplay = 'off' | 'collapsible' | 'separate';
+export declare function toReasoningDisplay(v: unknown): ReasoningDisplay;
+export declare function loadReasoningDisplay(): Promise<ReasoningDisplay>;

package/dist/runtime/config.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getPluginSettings } from '@coffer-org/server/plugin-runtime';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export const PLUGIN_ROOT = path.resolve(__dirname, '../..');
 export function loadBotConfig(opts = {}) {
@@ -16,3 +17,9 @@ export function loadBotConfig(opts = {}) {
 export function hasCredentials(cfg) {
     return Boolean(cfg.apiId && cfg.apiHash && (cfg.botToken || cfg.phone));
 }
+export function toReasoningDisplay(v) {
+    return v === 'off' || v === 'separate' ? v : 'collapsible';
+}
+export async function loadReasoningDisplay() {
+    return toReasoningDisplay((await getPluginSettings('telegram'))['reasoning_display']);
+}

package/dist/schema.js

@@ -4609,6 +4609,25 @@ function internalApiToken(o) {
 		]
 	});
 }
+/**
+* Internal "connected apps" list — the OAuth clients (claude.ai & co) the user
+* has authorized for MCP access. Same "internal" caveat and custom-renderer
+* trick as internalApiToken(): read-only rows + a revoke action, never part of
+* the parent form's save.
+*/
+function internalOauthGrants(o) {
+	return group({
+		key: o.key,
+		label: o.label ?? o.key,
+		multiple: true,
+		view: { kind: "internalOauthGrants" },
+		fields: [
+			string({ key: "clientName" }),
+			string({ key: "createdAt" }),
+			string({ key: "lastUsedAt" })
+		]
+	});
+}
 var SLUG_RE = /^[a-z0-9-]+$/;
 function slug(raw) {
 	const o = normalizeOpts(raw);
@@ -5038,7 +5057,8 @@ var presets = {
 	weight,
 	dimensions,
 	country,
-	internalApiToken
+	internalApiToken,
+	internalOauthGrants
 };
 //#endregion
 //#region ../../node_modules/iso-639-1/src/data.js
@@ -5865,7 +5885,7 @@ function group(o) {
 		required: o.required,
 		unique: r.unique,
 		label: o.label,
-		icon: v.icon,
+		icon: o.icon,
 		display: v.display ?? "wrap",
 		kind: v.kind,
 		fixed: r.fixed,
@@ -5876,11 +5896,9 @@ function group(o) {
 function row(o) {
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
-		view: {
-			...o.view,
-			display: "scroll"
-		}
+		view: { display: "scroll" }
 	});
 }
 /** Tabular collection (array of rows → <table>, aligned by columns). Sugar. */
@@ -5888,14 +5906,12 @@ function table(o) {
 	return group({
 		key: o.key,
 		label: o.label,
+		icon: o.icon,
 		fields: o.fields,
 		multiple: true,
 		required: o.required,
 		rules: o.rules,
-		view: {
-			...o.view,
-			display: "table"
-		}
+		view: { display: "table" }
 	});
 }
 /**
@@ -5911,11 +5927,9 @@ function sheet(o) {
 	});
 	return group({
 		label: o.label,
+		icon: o.icon,
 		fields: flat,
-		view: {
-			...o.view,
-			display: "sheet"
-		}
+		view: { display: "sheet" }
 	});
 }
 /**
@@ -5947,8 +5961,8 @@ function keyed(o) {
 	return {
 		...(o.container ?? group)({
 			label: o.label,
-			fields: [o.by, ...o.fields],
-			view: o.view
+			icon: o.icon,
+			fields: [o.by, ...o.fields]
 		}),
 		key: o.key,
 		multiple: true,
@@ -6384,7 +6398,7 @@ function relation(raw) {
 		},
 		relation: {
 			library: raw.options.library,
-			type: raw.options.shelf
+			shelf: raw.options.shelf
 		},
 		...multi && { json: true },
 		zod: optionalize(s, required)
@@ -6764,15 +6778,44 @@ function period(raw) {
 		zod: optionalize(s, required)
 	});
 }
+/** Keys a file entry may carry. Everything else is rejected — see fileEntryIssue. */
+var FILE_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"mime",
+	"size"
+]);
+/** Keys that mean "the author pasted a remote address" — the one mistake worth naming. */
+var FILE_URL_KEYS = [
+	"url",
+	"src",
+	"href",
+	"link"
+];
+/**
+* A file entry points at a file already uploaded to the server: `{ name }`, where
+* name is the bare filename returned by POST /api/upload. Anything else — a remote
+* URL, an extra key, a path — is refused here, so a record can never hold a
+* reference the server cannot serve. `mime`/`size` are accepted (legacy payloads
+* and the web uploader send them) but the server overwrites them from disk.
+* Returns a vmsg code, or null when the entry is well-formed.
+*/
+function fileEntryIssue(it) {
+	if (typeof it !== "object" || it === null || Array.isArray(it)) return "file_structure";
+	const rec = it;
+	if (FILE_URL_KEYS.some((k) => k in rec)) return "file_remote_url";
+	const name = rec["name"];
+	if (typeof name !== "string" || name === "") return "file_structure";
+	if (name.includes("://") || name.startsWith("//")) return "file_remote_url";
+	if (/[\\/]/.test(name) || name.includes("..")) return "file_name";
+	for (const k of Object.keys(rec)) if (!FILE_KEYS.has(k)) return "file_unknown_key";
+	if (rec["mime"] !== void 0 && typeof rec["mime"] !== "string") return "file_structure";
+	if (rec["size"] !== void 0 && typeof rec["size"] !== "number") return "file_structure";
+	return null;
+}
 function makeFile(kind, raw) {
 	const o = normalizeOpts(raw);
 	const required = o.required ?? false;
 	const multiple = o.multiple ?? false;
-	const rowSchema = object({
-		name: string$1().min(1),
-		mime: string$1().optional(),
-		size: number$1().optional()
-	});
 	const s = unknown().superRefine((raw, ctx) => {
 		if (typeof raw === "string") try {
 			JSON.parse(raw);
@@ -6785,12 +6828,15 @@ function makeFile(kind, raw) {
 		}
 		const parsed = jsonValue(raw);
 		const items = Array.isArray(parsed) ? parsed : [parsed];
-		for (const it of items) if (!rowSchema.safeParse(it).success) {
-			ctx.addIssue({
-				code: ZodIssueCode.custom,
-				message: vmsg("file_structure")
-			});
-			return;
+		for (const it of items) {
+			const code = fileEntryIssue(it);
+			if (code) {
+				ctx.addIssue({
+					code: ZodIssueCode.custom,
+					message: vmsg(code)
+				});
+				return;
+			}
 		}
 	});
 	return wrapKey(o, {
@@ -7058,6 +7104,25 @@ var src_default = definePlugin({
 			field.tel({
 				key: "phone",
 				label: "telegram.settings.phone"
+			}),
+			field.select({
+				key: "reasoning_display",
+				label: "telegram.settings.reasoning_display",
+				default: "collapsible",
+				options: [
+					{
+						value: "off",
+						title: "telegram.settings.reasoning_display_off"
+					},
+					{
+						value: "collapsible",
+						title: "telegram.settings.reasoning_display_collapsible"
+					},
+					{
+						value: "separate",
+						title: "telegram.settings.reasoning_display_separate"
+					}
+				]
 			})
 		]
 	})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/plugin-telegram",
-  "version": "1.4.0",
+  "version": "2.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": "^1.4.0",
-    "@coffer-org/sdk": "^1.5.0",
-    "@coffer-org/server": "^1.8.0",
+    "@coffer-org/plugin-orchestrator": "^2.0.0",
+    "@coffer-org/sdk": "^2.0.0",
+    "@coffer-org/server": "^2.0.1",
     "input": "^1.0.1",
     "teleproto": "^1.228.1"
   },