@xopcai/xopc 0.0.99 → 0.0.100

package/dist/extensions/telegram/src/api-root.js

@@ -0,0 +1,42 @@
+//#region extensions/telegram/src/api-root.ts
+const DEFAULT_TELEGRAM_API_ROOT = "https://api.telegram.org";
+const TELEGRAM_BOT_ENDPOINT_SEGMENT_RE = /^bot\d+:[^/]+$/u;
+function isTelegramBotEndpointSegment(segment) {
+	try {
+		return TELEGRAM_BOT_ENDPOINT_SEGMENT_RE.test(decodeURIComponent(segment));
+	} catch {
+		return TELEGRAM_BOT_ENDPOINT_SEGMENT_RE.test(segment);
+	}
+}
+/** Strip trailing `/bot<token>` from a misconfigured apiRoot URL. */
+function normalizeTelegramApiRoot(apiRoot) {
+	const trimmed = apiRoot?.trim();
+	if (!trimmed) return DEFAULT_TELEGRAM_API_ROOT;
+	let normalized = trimmed.replace(/\/+$/u, "");
+	try {
+		const url = new URL(normalized);
+		const segments = url.pathname.split("/").filter(Boolean);
+		if (segments.length > 0 && isTelegramBotEndpointSegment(segments[segments.length - 1] ?? "")) {
+			segments.pop();
+			url.pathname = segments.length > 0 ? `/${segments.join("/")}` : "/";
+			url.search = "";
+			url.hash = "";
+			normalized = url.toString().replace(/\/+$/u, "");
+		}
+	} catch {}
+	return normalized;
+}
+function hasTelegramBotEndpointApiRoot(apiRoot) {
+	if (typeof apiRoot !== "string" || !apiRoot.trim()) return false;
+	try {
+		const segments = new URL(apiRoot.trim()).pathname.split("/").filter(Boolean);
+		const last = segments[segments.length - 1];
+		return Boolean(last && isTelegramBotEndpointSegment(last));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { DEFAULT_TELEGRAM_API_ROOT, hasTelegramBotEndpointApiRoot, normalizeTelegramApiRoot };
+
+//# sourceMappingURL=api-root.js.map

package/dist/extensions/telegram/src/api-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-root.js","names":[],"sources":["../../../../extensions/telegram/src/api-root.ts"],"sourcesContent":["export const DEFAULT_TELEGRAM_API_ROOT = 'https://api.telegram.org';\n\nconst TELEGRAM_BOT_ENDPOINT_SEGMENT_RE = /^bot\\d+:[^/]+$/u;\n\nfunction isTelegramBotEndpointSegment(segment: string): boolean {\n  try {\n    return TELEGRAM_BOT_ENDPOINT_SEGMENT_RE.test(decodeURIComponent(segment));\n  } catch {\n    return TELEGRAM_BOT_ENDPOINT_SEGMENT_RE.test(segment);\n  }\n}\n\n/** Strip trailing `/bot<token>` from a misconfigured apiRoot URL. */\nexport function normalizeTelegramApiRoot(apiRoot?: string): string {\n  const trimmed = apiRoot?.trim();\n  if (!trimmed) {\n    return DEFAULT_TELEGRAM_API_ROOT;\n  }\n\n  let normalized = trimmed.replace(/\\/+$/u, '');\n  try {\n    const url = new URL(normalized);\n    const segments = url.pathname.split('/').filter(Boolean);\n    if (segments.length > 0 && isTelegramBotEndpointSegment(segments[segments.length - 1] ?? '')) {\n      segments.pop();\n      url.pathname = segments.length > 0 ? `/${segments.join('/')}` : '/';\n      url.search = '';\n      url.hash = '';\n      normalized = url.toString().replace(/\\/+$/u, '');\n    }\n  } catch {\n    // Invalid URLs are caught at config validation; keep trimmed value for runtime callers.\n  }\n  return normalized;\n}\n\nexport function hasTelegramBotEndpointApiRoot(apiRoot: unknown): boolean {\n  if (typeof apiRoot !== 'string' || !apiRoot.trim()) {\n    return false;\n  }\n  try {\n    const url = new URL(apiRoot.trim());\n    const segments = url.pathname.split('/').filter(Boolean);\n    const last = segments[segments.length - 1];\n    return Boolean(last && isTelegramBotEndpointSegment(last));\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";AAAA,MAAa,4BAA4B;AAEzC,MAAM,mCAAmC;AAEzC,SAAS,6BAA6B,SAA0B;AAC9D,KAAI;AACF,SAAO,iCAAiC,KAAK,mBAAmB,QAAQ,CAAC;SACnE;AACN,SAAO,iCAAiC,KAAK,QAAQ;;;;AAKzD,SAAgB,yBAAyB,SAA0B;CACjE,MAAM,UAAU,SAAS,MAAM;AAC/B,KAAI,CAAC,QACH,QAAO;CAGT,IAAI,aAAa,QAAQ,QAAQ,SAAS,GAAG;AAC7C,KAAI;EACF,MAAM,MAAM,IAAI,IAAI,WAAW;EAC/B,MAAM,WAAW,IAAI,SAAS,MAAM,IAAI,CAAC,OAAO,QAAQ;AACxD,MAAI,SAAS,SAAS,KAAK,6BAA6B,SAAS,SAAS,SAAS,MAAM,GAAG,EAAE;AAC5F,YAAS,KAAK;AACd,OAAI,WAAW,SAAS,SAAS,IAAI,IAAI,SAAS,KAAK,IAAI,KAAK;AAChE,OAAI,SAAS;AACb,OAAI,OAAO;AACX,gBAAa,IAAI,UAAU,CAAC,QAAQ,SAAS,GAAG;;SAE5C;AAGR,QAAO;;AAGT,SAAgB,8BAA8B,SAA2B;AACvE,KAAI,OAAO,YAAY,YAAY,CAAC,QAAQ,MAAM,CAChD,QAAO;AAET,KAAI;EAEF,MAAM,WAAW,IADD,IAAI,QAAQ,MAAM,CACd,CAAC,SAAS,MAAM,IAAI,CAAC,OAAO,QAAQ;EACxD,MAAM,OAAO,SAAS,SAAS,SAAS;AACxC,SAAO,QAAQ,QAAQ,6BAA6B,KAAK,CAAC;SACpD;AACN,SAAO"}

package/dist/extensions/telegram/src/approval-delivery.d.ts

@@ -0,0 +1,9 @@
+import type { Bot } from 'grammy';
+import type { TelegramPendingApproval } from './approval-store.js';
+import type { Config } from '@xopcai/xopc/config/index.js';
+export declare function deliverTelegramExecApprovalPrompt(params: {
+    bot: Bot;
+    cfg: Config;
+    accountId: string;
+    approval: TelegramPendingApproval;
+}): Promise<void>;

package/dist/extensions/telegram/src/approval-delivery.js

@@ -0,0 +1,36 @@
+import { createLogger } from "../../../src/utils/logger/index.js";
+import { init_logger } from "../../../src/utils/logger.js";
+import { resolveTelegramExecApprovers } from "./exec-approvals.js";
+import { InlineKeyboard } from "grammy";
+//#region extensions/telegram/src/approval-delivery.ts
+init_logger();
+const log = createLogger("TelegramApprovalDelivery");
+async function deliverTelegramExecApprovalPrompt(params) {
+	const approvers = resolveTelegramExecApprovers(params.cfg, params.accountId);
+	if (approvers.length === 0) {
+		log.warn({ accountId: params.accountId }, "No exec approvers configured");
+		return;
+	}
+	const keyboard = new InlineKeyboard().text("✅ Approve", `approval:approve:${params.approval.id}`).text("❌ Deny", `approval:deny:${params.approval.id}`);
+	const text = [
+		"⚠️ Exec approval required",
+		"",
+		`Tool: ${params.approval.toolName}`,
+		params.approval.summary,
+		"",
+		`ID: ${params.approval.id}`
+	].join("\n");
+	for (const approver of approvers) try {
+		await params.bot.api.sendMessage(approver, text, { reply_markup: keyboard });
+	} catch (err) {
+		log.warn({
+			err,
+			approver,
+			approvalId: params.approval.id
+		}, "Failed to send approval prompt");
+	}
+}
+//#endregion
+export { deliverTelegramExecApprovalPrompt };
+
+//# sourceMappingURL=approval-delivery.js.map

package/dist/extensions/telegram/src/approval-delivery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-delivery.js","names":[],"sources":["../../../../extensions/telegram/src/approval-delivery.ts"],"sourcesContent":["import type { Bot } from 'grammy';\nimport { InlineKeyboard } from 'grammy';\nimport { createLogger } from '@xopcai/xopc/utils/logger.js';\nimport type { TelegramPendingApproval } from './approval-store.js';\nimport { resolveTelegramExecApprovers } from './exec-approvals.js';\nimport type { Config } from '@xopcai/xopc/config/index.js';\n\nconst log = createLogger('TelegramApprovalDelivery');\n\nexport async function deliverTelegramExecApprovalPrompt(params: {\n  bot: Bot;\n  cfg: Config;\n  accountId: string;\n  approval: TelegramPendingApproval;\n}): Promise<void> {\n  const approvers = resolveTelegramExecApprovers(params.cfg, params.accountId);\n  if (approvers.length === 0) {\n    log.warn({ accountId: params.accountId }, 'No exec approvers configured');\n    return;\n  }\n\n  const keyboard = new InlineKeyboard()\n    .text('✅ Approve', `approval:approve:${params.approval.id}`)\n    .text('❌ Deny', `approval:deny:${params.approval.id}`);\n\n  const text = [\n    '⚠️ Exec approval required',\n    '',\n    `Tool: ${params.approval.toolName}`,\n    params.approval.summary,\n    '',\n    `ID: ${params.approval.id}`,\n  ].join('\\n');\n\n  for (const approver of approvers) {\n    try {\n      await params.bot.api.sendMessage(approver, text, { reply_markup: keyboard });\n    } catch (err) {\n      log.warn({ err, approver, approvalId: params.approval.id }, 'Failed to send approval prompt');\n    }\n  }\n}\n"],"mappings":";;;;;aAE4D;AAK5D,MAAM,MAAM,aAAa,2BAA2B;AAEpD,eAAsB,kCAAkC,QAKtC;CAChB,MAAM,YAAY,6BAA6B,OAAO,KAAK,OAAO,UAAU;AAC5E,KAAI,UAAU,WAAW,GAAG;AAC1B,MAAI,KAAK,EAAE,WAAW,OAAO,WAAW,EAAE,+BAA+B;AACzE;;CAGF,MAAM,WAAW,IAAI,gBAAgB,CAClC,KAAK,aAAa,oBAAoB,OAAO,SAAS,KAAK,CAC3D,KAAK,UAAU,iBAAiB,OAAO,SAAS,KAAK;CAExD,MAAM,OAAO;EACX;EACA;EACA,SAAS,OAAO,SAAS;EACzB,OAAO,SAAS;EAChB;EACA,OAAO,OAAO,SAAS;EACxB,CAAC,KAAK,KAAK;AAEZ,MAAK,MAAM,YAAY,UACrB,KAAI;AACF,QAAM,OAAO,IAAI,IAAI,YAAY,UAAU,MAAM,EAAE,cAAc,UAAU,CAAC;UACrE,KAAK;AACZ,MAAI,KAAK;GAAE;GAAK;GAAU,YAAY,OAAO,SAAS;GAAI,EAAE,iCAAiC"}

package/dist/extensions/telegram/src/approval-store.d.ts

@@ -0,0 +1,25 @@
+export type TelegramApprovalStatus = 'pending' | 'approved' | 'denied' | 'expired';
+export interface TelegramPendingApproval {
+    id: string;
+    accountId: string;
+    sessionKey: string;
+    chatId: string;
+    toolName: string;
+    summary: string;
+    createdAtMs: number;
+    expiresAtMs: number;
+    status: TelegramApprovalStatus;
+    resolve?: (approved: boolean) => void;
+}
+export declare function createTelegramPendingApproval(params: {
+    accountId: string;
+    sessionKey: string;
+    chatId: string;
+    toolName: string;
+    summary: string;
+    ttlMs?: number;
+}): TelegramPendingApproval;
+export declare function waitForTelegramApproval(id: string, timeoutMs?: number): Promise<boolean>;
+export declare function resolveTelegramApproval(id: string, approved: boolean): boolean;
+export declare function getTelegramPendingApproval(id: string): TelegramPendingApproval | undefined;
+export declare function listTelegramPendingApprovals(): TelegramPendingApproval[];

package/dist/extensions/telegram/src/approval-store.js

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+//#region extensions/telegram/src/approval-store.ts
+const DEFAULT_TTL_MS = 300 * 1e3;
+const pending = /* @__PURE__ */ new Map();
+function createTelegramPendingApproval(params) {
+	const id = randomUUID().slice(0, 8);
+	const now = Date.now();
+	const entry = {
+		id,
+		accountId: params.accountId,
+		sessionKey: params.sessionKey,
+		chatId: params.chatId,
+		toolName: params.toolName,
+		summary: params.summary,
+		createdAtMs: now,
+		expiresAtMs: now + (params.ttlMs ?? DEFAULT_TTL_MS),
+		status: "pending"
+	};
+	pending.set(id, entry);
+	return entry;
+}
+function waitForTelegramApproval(id, timeoutMs = DEFAULT_TTL_MS) {
+	const entry = pending.get(id);
+	if (!entry || entry.status !== "pending") return Promise.resolve(false);
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			if (entry.status === "pending") {
+				entry.status = "expired";
+				pending.delete(id);
+			}
+			resolve(false);
+		}, timeoutMs);
+		entry.resolve = (approved) => {
+			clearTimeout(timer);
+			resolve(approved);
+		};
+	});
+}
+function resolveTelegramApproval(id, approved) {
+	const entry = pending.get(id);
+	if (!entry || entry.status !== "pending") return false;
+	entry.status = approved ? "approved" : "denied";
+	entry.resolve?.(approved);
+	pending.delete(id);
+	return true;
+}
+function getTelegramPendingApproval(id) {
+	return pending.get(id);
+}
+function listTelegramPendingApprovals() {
+	const now = Date.now();
+	for (const [id, entry] of pending) if (entry.status === "pending" && entry.expiresAtMs <= now) {
+		entry.status = "expired";
+		pending.delete(id);
+	}
+	return [...pending.values()].filter((e) => e.status === "pending");
+}
+//#endregion
+export { createTelegramPendingApproval, getTelegramPendingApproval, listTelegramPendingApprovals, resolveTelegramApproval, waitForTelegramApproval };
+
+//# sourceMappingURL=approval-store.js.map

package/dist/extensions/telegram/src/approval-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-store.js","names":[],"sources":["../../../../extensions/telegram/src/approval-store.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\n\nexport type TelegramApprovalStatus = 'pending' | 'approved' | 'denied' | 'expired';\n\nexport interface TelegramPendingApproval {\n  id: string;\n  accountId: string;\n  sessionKey: string;\n  chatId: string;\n  toolName: string;\n  summary: string;\n  createdAtMs: number;\n  expiresAtMs: number;\n  status: TelegramApprovalStatus;\n  resolve?: (approved: boolean) => void;\n}\n\nconst DEFAULT_TTL_MS = 5 * 60 * 1000;\nconst pending = new Map<string, TelegramPendingApproval>();\n\nexport function createTelegramPendingApproval(params: {\n  accountId: string;\n  sessionKey: string;\n  chatId: string;\n  toolName: string;\n  summary: string;\n  ttlMs?: number;\n}): TelegramPendingApproval {\n  const id = randomUUID().slice(0, 8);\n  const now = Date.now();\n  const entry: TelegramPendingApproval = {\n    id,\n    accountId: params.accountId,\n    sessionKey: params.sessionKey,\n    chatId: params.chatId,\n    toolName: params.toolName,\n    summary: params.summary,\n    createdAtMs: now,\n    expiresAtMs: now + (params.ttlMs ?? DEFAULT_TTL_MS),\n    status: 'pending',\n  };\n  pending.set(id, entry);\n  return entry;\n}\n\nexport function waitForTelegramApproval(id: string, timeoutMs = DEFAULT_TTL_MS): Promise<boolean> {\n  const entry = pending.get(id);\n  if (!entry || entry.status !== 'pending') {\n    return Promise.resolve(false);\n  }\n  return new Promise((resolve) => {\n    const timer = setTimeout(() => {\n      if (entry.status === 'pending') {\n        entry.status = 'expired';\n        pending.delete(id);\n      }\n      resolve(false);\n    }, timeoutMs);\n    entry.resolve = (approved) => {\n      clearTimeout(timer);\n      resolve(approved);\n    };\n  });\n}\n\nexport function resolveTelegramApproval(id: string, approved: boolean): boolean {\n  const entry = pending.get(id);\n  if (!entry || entry.status !== 'pending') {\n    return false;\n  }\n  entry.status = approved ? 'approved' : 'denied';\n  entry.resolve?.(approved);\n  pending.delete(id);\n  return true;\n}\n\nexport function getTelegramPendingApproval(id: string): TelegramPendingApproval | undefined {\n  return pending.get(id);\n}\n\nexport function listTelegramPendingApprovals(): TelegramPendingApproval[] {\n  const now = Date.now();\n  for (const [id, entry] of pending) {\n    if (entry.status === 'pending' && entry.expiresAtMs <= now) {\n      entry.status = 'expired';\n      pending.delete(id);\n    }\n  }\n  return [...pending.values()].filter((e) => e.status === 'pending');\n}\n"],"mappings":";;AAiBA,MAAM,iBAAiB,MAAS;AAChC,MAAM,0BAAU,IAAI,KAAsC;AAE1D,SAAgB,8BAA8B,QAOlB;CAC1B,MAAM,KAAK,YAAY,CAAC,MAAM,GAAG,EAAE;CACnC,MAAM,MAAM,KAAK,KAAK;CACtB,MAAM,QAAiC;EACrC;EACA,WAAW,OAAO;EAClB,YAAY,OAAO;EACnB,QAAQ,OAAO;EACf,UAAU,OAAO;EACjB,SAAS,OAAO;EAChB,aAAa;EACb,aAAa,OAAO,OAAO,SAAS;EACpC,QAAQ;EACT;AACD,SAAQ,IAAI,IAAI,MAAM;AACtB,QAAO;;AAGT,SAAgB,wBAAwB,IAAY,YAAY,gBAAkC;CAChG,MAAM,QAAQ,QAAQ,IAAI,GAAG;AAC7B,KAAI,CAAC,SAAS,MAAM,WAAW,UAC7B,QAAO,QAAQ,QAAQ,MAAM;AAE/B,QAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,QAAQ,iBAAiB;AAC7B,OAAI,MAAM,WAAW,WAAW;AAC9B,UAAM,SAAS;AACf,YAAQ,OAAO,GAAG;;AAEpB,WAAQ,MAAM;KACb,UAAU;AACb,QAAM,WAAW,aAAa;AAC5B,gBAAa,MAAM;AACnB,WAAQ,SAAS;;GAEnB;;AAGJ,SAAgB,wBAAwB,IAAY,UAA4B;CAC9E,MAAM,QAAQ,QAAQ,IAAI,GAAG;AAC7B,KAAI,CAAC,SAAS,MAAM,WAAW,UAC7B,QAAO;AAET,OAAM,SAAS,WAAW,aAAa;AACvC,OAAM,UAAU,SAAS;AACzB,SAAQ,OAAO,GAAG;AAClB,QAAO;;AAGT,SAAgB,2BAA2B,IAAiD;AAC1F,QAAO,QAAQ,IAAI,GAAG;;AAGxB,SAAgB,+BAA0D;CACxE,MAAM,MAAM,KAAK,KAAK;AACtB,MAAK,MAAM,CAAC,IAAI,UAAU,QACxB,KAAI,MAAM,WAAW,aAAa,MAAM,eAAe,KAAK;AAC1D,QAAM,SAAS;AACf,UAAQ,OAAO,GAAG;;AAGtB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC,CAAC,QAAQ,MAAM,EAAE,WAAW,UAAU"}

package/dist/extensions/telegram/src/config-schema.d.ts

@@ -1,27 +1,71 @@
 import { z } from 'zod';
+export declare const TelegramStreamingBlockCoalesceSchema: z.ZodObject<{
+    minChars: z.ZodDefault<z.ZodNumber>;
+    idleMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const TelegramStreamingPreviewSchema: z.ZodObject<{
+    toolProgress: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const TelegramStreamingConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        partial: "partial";
+        block: "block";
+    }>>;
+    preview: z.ZodOptional<z.ZodObject<{
+        toolProgress: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    block: z.ZodOptional<z.ZodObject<{
+        coalesce: z.ZodOptional<z.ZodObject<{
+            minChars: z.ZodDefault<z.ZodNumber>;
+            idleMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const TelegramTopicConfigSchema: z.ZodObject<{
-    topicId: z.ZodString;
+    topicId: z.ZodOptional<z.ZodString>;
     requireMention: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     systemPrompt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const TelegramGroupConfigSchema: z.ZodObject<{
-    groupId: z.ZodString;
+    groupId: z.ZodOptional<z.ZodString>;
     requireMention: z.ZodOptional<z.ZodBoolean>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     systemPrompt: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
     topics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        topicId: z.ZodString;
+        topicId: z.ZodOptional<z.ZodString>;
         requireMention: z.ZodOptional<z.ZodBoolean>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const TelegramActionsConfigSchema: z.ZodObject<{
+    reactions: z.ZodDefault<z.ZodBoolean>;
+    sendMessage: z.ZodDefault<z.ZodBoolean>;
+    editMessage: z.ZodDefault<z.ZodBoolean>;
+    deleteMessage: z.ZodDefault<z.ZodBoolean>;
+    poll: z.ZodDefault<z.ZodBoolean>;
+    sticker: z.ZodDefault<z.ZodBoolean>;
+    createForumTopic: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const TelegramExecApprovalsConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strict>;
+export declare const TelegramThreadBindingsConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxAgeMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 export declare const TelegramAccountConfigSchema: z.ZodObject<{
-    accountId: z.ZodString;
+    accountId: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
     enabled: z.ZodDefault<z.ZodBoolean>;
     botToken: z.ZodDefault<z.ZodString>;
@@ -45,37 +89,81 @@ export declare const TelegramAccountConfigSchema: z.ZodObject<{
         all: "all";
     }>>;
     groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        groupId: z.ZodString;
+        groupId: z.ZodOptional<z.ZodString>;
         requireMention: z.ZodOptional<z.ZodBoolean>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
         topics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            topicId: z.ZodString;
+            topicId: z.ZodOptional<z.ZodString>;
             requireMention: z.ZodOptional<z.ZodBoolean>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>>;
+            agentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
     historyLimit: z.ZodDefault<z.ZodNumber>;
     textChunkLimit: z.ZodDefault<z.ZodNumber>;
-    streamMode: z.ZodDefault<z.ZodEnum<{
-        off: "off";
-        partial: "partial";
-        block: "block";
-    }>>;
+    streaming: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            partial: "partial";
+            block: "block";
+        }>>;
+        preview: z.ZodOptional<z.ZodObject<{
+            toolProgress: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        block: z.ZodOptional<z.ZodObject<{
+            coalesce: z.ZodOptional<z.ZodObject<{
+                minChars: z.ZodDefault<z.ZodNumber>;
+                idleMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     proxy: z.ZodOptional<z.ZodString>;
     apiRoot: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const TelegramConfigSchema: z.ZodPreprocess<z.ZodObject<{
+    pollingStallThresholdMs: z.ZodOptional<z.ZodNumber>;
+    reactionLevel: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        ack: "ack";
+        extensive: "extensive";
+    }>>;
+    reactionNotifications: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        all: "all";
+        own: "own";
+    }>>;
+    ackReaction: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodObject<{
+        reactions: z.ZodDefault<z.ZodBoolean>;
+        sendMessage: z.ZodDefault<z.ZodBoolean>;
+        editMessage: z.ZodDefault<z.ZodBoolean>;
+        deleteMessage: z.ZodDefault<z.ZodBoolean>;
+        poll: z.ZodDefault<z.ZodBoolean>;
+        sticker: z.ZodDefault<z.ZodBoolean>;
+        createForumTopic: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    execApprovals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strict>>;
+    threadBindings: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxAgeMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const TelegramConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     allowFrom: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     groupAllowFrom: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
     apiRoot: z.ZodOptional<z.ZodString>;
     debug: z.ZodDefault<z.ZodBoolean>;
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        accountId: z.ZodString;
+        accountId: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         enabled: z.ZodDefault<z.ZodBoolean>;
         botToken: z.ZodDefault<z.ZodString>;
@@ -99,29 +187,73 @@ export declare const TelegramConfigSchema: z.ZodPreprocess<z.ZodObject<{
             all: "all";
         }>>;
         groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            groupId: z.ZodString;
+            groupId: z.ZodOptional<z.ZodString>;
             requireMention: z.ZodOptional<z.ZodBoolean>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
             topics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                topicId: z.ZodString;
+                topicId: z.ZodOptional<z.ZodString>;
                 requireMention: z.ZodOptional<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
                 systemPrompt: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>>;
+                agentId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
         historyLimit: z.ZodDefault<z.ZodNumber>;
         textChunkLimit: z.ZodDefault<z.ZodNumber>;
-        streamMode: z.ZodDefault<z.ZodEnum<{
-            off: "off";
-            partial: "partial";
-            block: "block";
-        }>>;
+        streaming: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                off: "off";
+                partial: "partial";
+                block: "block";
+            }>>;
+            preview: z.ZodOptional<z.ZodObject<{
+                toolProgress: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            block: z.ZodOptional<z.ZodObject<{
+                coalesce: z.ZodOptional<z.ZodObject<{
+                    minChars: z.ZodDefault<z.ZodNumber>;
+                    idleMs: z.ZodDefault<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
         proxy: z.ZodOptional<z.ZodString>;
         apiRoot: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
+        pollingStallThresholdMs: z.ZodOptional<z.ZodNumber>;
+        reactionLevel: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            ack: "ack";
+            extensive: "extensive";
+        }>>;
+        reactionNotifications: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            all: "all";
+            own: "own";
+        }>>;
+        ackReaction: z.ZodOptional<z.ZodString>;
+        actions: z.ZodOptional<z.ZodObject<{
+            reactions: z.ZodDefault<z.ZodBoolean>;
+            sendMessage: z.ZodDefault<z.ZodBoolean>;
+            editMessage: z.ZodDefault<z.ZodBoolean>;
+            deleteMessage: z.ZodDefault<z.ZodBoolean>;
+            poll: z.ZodDefault<z.ZodBoolean>;
+            sticker: z.ZodDefault<z.ZodBoolean>;
+            createForumTopic: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        execApprovals: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$strict>>;
+        threadBindings: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            maxAgeMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     dmPolicy: z.ZodDefault<z.ZodEnum<{
         pairing: "pairing";
         allowlist: "allowlist";
@@ -138,13 +270,31 @@ export declare const TelegramConfigSchema: z.ZodPreprocess<z.ZodObject<{
         first: "first";
         all: "all";
     }>>;
-    streamMode: z.ZodOptional<z.ZodEnum<{
-        off: "off";
-        partial: "partial";
-        block: "block";
-    }>>;
+    streaming: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            partial: "partial";
+            block: "block";
+        }>>;
+        preview: z.ZodOptional<z.ZodObject<{
+            toolProgress: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        block: z.ZodOptional<z.ZodObject<{
+            coalesce: z.ZodOptional<z.ZodObject<{
+                minChars: z.ZodDefault<z.ZodNumber>;
+                idleMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     historyLimit: z.ZodDefault<z.ZodNumber>;
     textChunkLimit: z.ZodDefault<z.ZodNumber>;
     proxy: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
+}, z.core.$strict>;
 export type TelegramConfig = z.infer<typeof TelegramConfigSchema>;
+export type TelegramStreamingConfig = z.infer<typeof TelegramStreamingConfigSchema>;
+/** Resolve effective streaming mode for an account. */
+export declare function resolveTelegramStreamingMode(account: {
+    streaming?: {
+        mode?: 'off' | 'partial' | 'block';
+    };
+}): 'off' | 'partial' | 'block';

package/dist/extensions/telegram/src/config-schema.js

@@ -1,48 +1,63 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region extensions/telegram/src/config-schema.ts
-/** Migrate legacy top-level `botToken` into `accounts.default`; implicit enable when `accounts.default.botToken` is set. */
-function preprocessTelegramConfigInput(raw) {
-	if (raw === null || raw === void 0) return raw;
-	if (typeof raw !== "object" || Array.isArray(raw)) return raw;
-	const o = { ...raw };
-	const legacyToken = typeof o.botToken === "string" ? o.botToken.trim() : "";
-	if (legacyToken) {
-		const acc = { ...o.accounts && typeof o.accounts === "object" && !Array.isArray(o.accounts) ? o.accounts : {} };
-		const rawDef = acc.default;
-		const def = rawDef && typeof rawDef === "object" && !Array.isArray(rawDef) ? { ...rawDef } : {};
-		if (!(typeof def.botToken === "string" ? def.botToken.trim() : "")) acc.default = {
-			...def,
-			accountId: "default",
-			botToken: legacyToken
-		};
-		o.accounts = acc;
-	}
-	delete o.botToken;
-	const defaultAcc = o.accounts?.default;
-	const token = defaultAcc && typeof defaultAcc === "object" && typeof defaultAcc.botToken === "string" ? defaultAcc.botToken : "";
-	if (o.enabled === void 0 && token.trim().length > 0) o.enabled = true;
-	return o;
+/** Resolve effective streaming mode for an account. */
+function resolveTelegramStreamingMode(account) {
+	return account.streaming?.mode ?? "partial";
 }
-var TelegramTopicConfigSchema, TelegramGroupConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchemaInner, TelegramConfigSchema;
+var TelegramStreamingBlockCoalesceSchema, TelegramStreamingPreviewSchema, TelegramStreamingConfigSchema, TelegramTopicConfigSchema, TelegramGroupConfigSchema, TelegramActionsConfigSchema, TelegramExecApprovalsConfigSchema, TelegramThreadBindingsConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema;
 var init_config_schema = __esmMin((() => {
+	TelegramStreamingBlockCoalesceSchema = z.object({
+		minChars: z.number().default(800),
+		idleMs: z.number().default(1e3)
+	}).strict();
+	TelegramStreamingPreviewSchema = z.object({ toolProgress: z.boolean().default(true) }).strict();
+	TelegramStreamingConfigSchema = z.object({
+		mode: z.enum([
+			"off",
+			"partial",
+			"block"
+		]).default("partial"),
+		preview: TelegramStreamingPreviewSchema.optional(),
+		block: z.object({ coalesce: TelegramStreamingBlockCoalesceSchema.optional() }).strict().optional()
+	}).strict();
 	TelegramTopicConfigSchema = z.object({
-		topicId: z.string(),
+		topicId: z.string().optional(),
 		requireMention: z.boolean().optional(),
 		enabled: z.boolean().optional(),
 		allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-		systemPrompt: z.string().optional()
-	});
+		systemPrompt: z.string().optional(),
+		agentId: z.string().optional()
+	}).strict();
 	TelegramGroupConfigSchema = z.object({
-		groupId: z.string(),
+		groupId: z.string().optional(),
 		requireMention: z.boolean().optional(),
 		enabled: z.boolean().optional(),
 		allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
 		systemPrompt: z.string().optional(),
+		agentId: z.string().optional(),
 		topics: z.record(z.string(), TelegramTopicConfigSchema).optional()
-	});
+	}).strict();
+	TelegramActionsConfigSchema = z.object({
+		reactions: z.boolean().default(true),
+		sendMessage: z.boolean().default(true),
+		editMessage: z.boolean().default(true),
+		deleteMessage: z.boolean().default(false),
+		poll: z.boolean().default(false),
+		sticker: z.boolean().default(false),
+		createForumTopic: z.boolean().default(false)
+	}).strict();
+	TelegramExecApprovalsConfigSchema = z.object({
+		enabled: z.boolean().default(false),
+		approvers: z.array(z.union([z.string(), z.number()])).optional()
+	}).strict();
+	TelegramThreadBindingsConfigSchema = z.object({
+		enabled: z.boolean().default(false),
+		idleTimeoutMs: z.number().optional(),
+		maxAgeMs: z.number().optional()
+	}).strict();
 	TelegramAccountConfigSchema = z.object({
-		accountId: z.string(),
+		accountId: z.string().optional(),
 		name: z.string().optional(),
 		enabled: z.boolean().default(true),
 		botToken: z.string().default(""),
@@ -68,15 +83,27 @@ var init_config_schema = __esmMin((() => {
 		groups: z.record(z.string(), TelegramGroupConfigSchema).optional(),
 		historyLimit: z.number().default(50),
 		textChunkLimit: z.number().default(4e3),
-		streamMode: z.enum([
-			"off",
-			"partial",
-			"block"
-		]).default("partial"),
+		streaming: TelegramStreamingConfigSchema.optional(),
 		proxy: z.string().optional(),
-		apiRoot: z.string().optional()
-	});
-	TelegramConfigSchemaInner = z.object({
+		apiRoot: z.string().optional(),
+		pollingStallThresholdMs: z.number().min(3e4).max(6e5).optional(),
+		reactionLevel: z.enum([
+			"off",
+			"ack",
+			"minimal",
+			"extensive"
+		]).default("ack"),
+		reactionNotifications: z.enum([
+			"off",
+			"own",
+			"all"
+		]).default("own"),
+		ackReaction: z.string().optional(),
+		actions: TelegramActionsConfigSchema.optional(),
+		execApprovals: TelegramExecApprovalsConfigSchema.optional(),
+		threadBindings: TelegramThreadBindingsConfigSchema.optional()
+	}).strict();
+	TelegramConfigSchema = z.object({
 		enabled: z.boolean().default(false),
 		allowFrom: z.array(z.union([z.string(), z.number()])).default([]),
 		groupAllowFrom: z.array(z.union([z.string(), z.number()])).default([]),
@@ -99,19 +126,14 @@ var init_config_schema = __esmMin((() => {
 			"first",
 			"all"
 		]).default("off"),
-		streamMode: z.enum([
-			"off",
-			"partial",
-			"block"
-		]).optional(),
+		streaming: TelegramStreamingConfigSchema.optional(),
 		historyLimit: z.number().default(50),
 		textChunkLimit: z.number().default(4e3),
 		proxy: z.string().optional()
-	});
-	TelegramConfigSchema = z.preprocess(preprocessTelegramConfigInput, TelegramConfigSchemaInner);
+	}).strict();
 }));
 //#endregion
 init_config_schema();
-export { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, init_config_schema };
+export { TelegramAccountConfigSchema, TelegramActionsConfigSchema, TelegramConfigSchema, TelegramExecApprovalsConfigSchema, TelegramGroupConfigSchema, TelegramStreamingBlockCoalesceSchema, TelegramStreamingConfigSchema, TelegramStreamingPreviewSchema, TelegramThreadBindingsConfigSchema, TelegramTopicConfigSchema, init_config_schema, resolveTelegramStreamingMode };
 
 //# sourceMappingURL=config-schema.js.map