@rnsk/toolkits 0.0.10 → 0.0.11

package/dist/toolkits/snowflake/tools/status.js

@@ -0,0 +1,54 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { snowflakeCredentialsField, statusPage } from './client.js';
+/** Statuspage is public; the optional field keeps the schema non-empty and is ignored. */
+const publicInput = {
+    snowflakeCredentials: snowflakeCredentialsField.describe('Optional (ignored — the status page is public)'),
+};
+export const getStatusSummary = tool({
+    description: 'Reads the public status summary (overall indicator plus regional components, unresolved incidents, upcoming maintenance). Public — no credentials.',
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/summary.json', 'get status summary'),
+});
+export const getStatusRollup = tool({
+    description: 'Reads the page rollup (blended indicator + human-readable description). Public — no credentials.',
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/status.json', 'get status rollup'),
+});
+export const getComponentStatus = tool({
+    description: 'Lists per-component status (AWS/Azure/GCP regions). Limit is applied locally. Public — no credentials.',
+    inputSchema: z.object({
+        limit: z.number().int().min(1).optional().describe('Max components to return'),
+    }),
+    execute: async ({ limit }) => {
+        const data = await statusPage('/components.json', 'get component status');
+        if (data?.error)
+            return data;
+        if (limit !== undefined && Array.isArray(data?.components)) {
+            return { ...data, components: data.components.slice(0, limit) };
+        }
+        return data;
+    },
+});
+export const getUnresolvedIncidents = tool({
+    description: 'Lists unresolved incidents (Investigating/Identified/Monitoring); empty when all clear. Public — no credentials.',
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/incidents/unresolved.json', 'get unresolved incidents'),
+});
+export const getActiveScheduledMaintenances = tool({
+    description: "Lists maintenances In Progress or Verifying. Public — no credentials.",
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/scheduled-maintenances/active.json', 'get active scheduled maintenances'),
+});
+export const getUpcomingScheduledMaintenances = tool({
+    description: "Lists maintenances still Scheduled (not started). Public — no credentials.",
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/scheduled-maintenances/upcoming.json', 'get upcoming scheduled maintenances'),
+});
+export const getAllScheduledMaintenances = tool({
+    description: 'Lists the 50 most recent maintenances including Completed. Public — no credentials.',
+    inputSchema: z.object({ ...publicInput }),
+    execute: async () => statusPage('/scheduled-maintenances.json', 'get all scheduled maintenances'),
+});
+//# sourceMappingURL=status.js.map

package/dist/toolkits/telegram/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const TELEGRAM_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/telegram/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg id="Livello_1" data-name="Livello 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 240 240"><defs><linearGradient id="linear-gradient" x1="120" y1="240" x2="120" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#1d93d2"/><stop offset="1" stop-color="#38b0e3"/></linearGradient></defs><title>Telegram_logo</title><circle cx="120" cy="120" r="120" fill="url(#linear-gradient)"/><path d="M81.229,128.772l14.237,39.406s1.78,3.687,3.686,3.687,30.255-29.492,30.255-29.492l31.525-60.89L81.737,118.6Z" fill="#c8daea"/><path d="M100.106,138.878l-2.733,29.046s-1.144,8.9,7.754,0,17.415-15.763,17.415-15.763" fill="#a9c6d8"/><path d="M81.486,130.178,52.2,120.636s-3.5-1.42-2.373-4.64c.232-.664.7-1.229,2.1-2.2,6.489-4.523,120.106-45.36,120.106-45.36s3.208-1.081,5.1-.362a2.766,2.766,0,0,1,1.885,2.055,9.357,9.357,0,0,1,.254,2.585c-.009.752-.1,1.449-.169,2.542-.692,11.165-21.4,94.493-21.4,94.493s-1.239,4.876-5.678,5.043A8.13,8.13,0,0,1,146.1,172.5c-8.711-7.493-38.819-27.727-45.472-32.177a1.27,1.27,0,0,1-.546-.9c-.093-.469.417-1.05.417-1.05s52.426-46.6,53.821-51.492c.108-.379-.3-.566-.848-.4-3.482,1.281-63.844,39.4-70.506,43.607A3.21,3.21,0,0,1,81.486,130.178Z" fill="#fff"/></svg>`;
+export const TELEGRAM_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/telegram/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/telegram/manifest.js

@@ -0,0 +1,34 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { TELEGRAM_ICON } from './icon.js';
+import { telegramTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'telegram',
+    displayName: 'Telegram',
+    shortDescription: 'Send messages and media, manage chats, and read updates via the Bot API.',
+    category: 'Collaboration & Communication',
+    icon: TELEGRAM_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'telegramBotToken',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            connectDescription: 'Connect Telegram with a bot token from @BotFather (format 123456:ABC-DEF...). The token is embedded in the Bot API request URL path (https://api.telegram.org/bot<token>/<method>), not sent as a header.',
+        },
+    },
+    allowedHosts: ['api.telegram.org'],
+    tools: telegramTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.10',
+        homepage: 'https://telegram.org',
+        docsUrl: 'https://core.telegram.org/bots/api',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/telegram/tools/bot.d.ts

@@ -0,0 +1,13 @@
+export declare const getMe: import("ai").Tool<{
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const setMyCommands: import("ai").Tool<{
+    commands: {
+        description: string;
+        command: string;
+    }[];
+    scope?: string | Record<string, any> | undefined;
+    languageCode?: string | undefined;
+    telegramBotToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=bot.d.ts.map

package/dist/toolkits/telegram/tools/bot.js

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { telegramBotTokenField, telegramCall } from './client.js';
+export const getMe = tool({
+    description: 'Returns bot identity (id, username, capabilities) and validates the token — ok=false means invalid/revoked token, fix before other calls. Name/bio are BotFather-only.',
+    inputSchema: z.object({ telegramBotToken: telegramBotTokenField }),
+    execute: async ({ telegramBotToken }) => telegramCall(telegramBotToken, 'getMe', undefined, 'get bot info'),
+});
+export const setMyCommands = tool({
+    description: "Replaces the bot command menu (max 100; names 1-32 lowercase/digits/underscores, descriptions 1-256 chars). Scoped commands override globals for matching users; omit scope for the global list.",
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        commands: z.array(z.object({
+            command: z.string().min(1).max(32).describe("Name, e.g. 'start' (lowercase, digits, underscores)"),
+            description: z.string().min(1).max(256).describe("Description, e.g. 'Start the bot'"),
+        })).max(100).describe('Command list (max 100)'),
+        scope: z.union([z.string(), z.record(z.any())]).optional().describe('JSON scope object (default: all users); serialized automatically'),
+        languageCode: z.string().optional().describe("ISO 639-1 code, e.g. 'en' (omit for all languages)"),
+    }),
+    execute: async ({ telegramBotToken, languageCode, ...rest }) => telegramCall(telegramBotToken, 'setMyCommands', { language_code: languageCode, ...rest }, 'set bot commands'),
+});
+//# sourceMappingURL=bot.js.map

package/dist/toolkits/telegram/tools/chats.d.ts

@@ -0,0 +1,22 @@
+export declare const getChat: import("ai").Tool<{
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const getChatAdministrators: import("ai").Tool<{
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const getChatMember: import("ai").Tool<{
+    userId: number;
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const getChatMembersCount: import("ai").Tool<{
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const createChatInviteLink: import("ai").Tool<{
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=chats.d.ts.map

package/dist/toolkits/telegram/tools/chats.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { chatIdField, telegramBotTokenField, telegramCall } from './client.js';
+export const getChat = tool({
+    description: "Reads current chat info (name, username, type, permissions). Bot must be a member; fails if never added/removed/blocked. Use getUpdates to discover reliable chat IDs.",
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField.describe("Chat ID (groups/channels are negative) or '@username' (plain names/URLs won't resolve)"),
+    }),
+    execute: async ({ telegramBotToken, chatId }) => telegramCall(telegramBotToken, 'getChat', { chat_id: chatId }, 'get chat'),
+});
+export const getChatAdministrators = tool({
+    description: 'Lists chat admins (except other bots) with privilege flags. Meaningful for supergroups/channels. Includes the bot itself when admin — use to verify rights before moderation.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+    }),
+    execute: async ({ telegramBotToken, chatId }) => telegramCall(telegramBotToken, 'getChatAdministrators', { chat_id: chatId }, 'get chat administrators'),
+});
+export const getChatMember = tool({
+    description: 'Reads one member status/role (creator/administrator/member/restricted/left/kicked). Query the bot itself to preflight membership and troubleshoot 403s.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        userId: z.number().int().describe('Target user ID'),
+    }),
+    execute: async ({ telegramBotToken, chatId, userId }) => telegramCall(telegramBotToken, 'getChatMember', { chat_id: chatId, user_id: userId }, 'get chat member'),
+});
+export const getChatMembersCount = tool({
+    description: 'Returns the member count. Bot must be an admin — permission failures surface as auth errors, not zero.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField.describe("Chat ID or '@username' (must start with '@')"),
+    }),
+    execute: async ({ telegramBotToken, chatId }) => telegramCall(telegramBotToken, 'getChatMemberCount', { chat_id: chatId }, 'get chat members count'),
+});
+export const createChatInviteLink = tool({
+    description: 'Generates a new primary invite link (revokes the previous primary link). Bot must be admin with invite rights.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField.describe('Target chat or @supergroup/@channel username'),
+    }),
+    execute: async ({ telegramBotToken, chatId }) => telegramCall(telegramBotToken, 'exportChatInviteLink', { chat_id: chatId }, 'export chat invite link'),
+});
+//# sourceMappingURL=chats.js.map

package/dist/toolkits/telegram/tools/client.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const TELEGRAM_API_BASE = "https://api.telegram.org";
+export declare const telegramBotTokenField: z.ZodOptional<z.ZodString>;
+export declare function missingToken(): {
+    error: string;
+};
+export declare const chatIdField: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+export declare const parseModeField: z.ZodOptional<z.ZodEnum<["Markdown", "MarkdownV2", "HTML"]>>;
+export declare const replyMarkupField: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+/** Call a Bot API method. Token goes in the URL path: POST /bot<token>/<method>. */
+export declare function telegramCall(botToken: string | undefined, method: string, params?: Record<string, unknown>, action?: string): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/telegram/tools/client.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const TELEGRAM_API_BASE = 'https://api.telegram.org';
+export const telegramBotTokenField = z
+    .string()
+    .optional()
+    .describe('Telegram bot token from @BotFather (format 123456:ABC-DEF...). Injected at runtime.');
+export function missingToken() {
+    return { error: 'Telegram bot token is required. Connect Telegram first.' };
+}
+export const chatIdField = z.union([z.number(), z.string()]).describe("Chat ID (numeric, negative for groups/channels) or @username, e.g. 123456789 or '@mychannel'");
+export const parseModeField = z.enum(['Markdown', 'MarkdownV2', 'HTML']).optional().describe("Entity parse mode ('MarkdownV2'/'HTML' preferred; omit for plain text)");
+export const replyMarkupField = z.union([z.string(), z.record(z.any())]).optional().describe('Inline keyboard as JSON string or object (will be serialized)');
+function normalizeParams(params) {
+    const out = {};
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined)
+            continue;
+        if ((k === 'reply_markup' || k === 'scope') && typeof v === 'object')
+            out[k] = JSON.stringify(v);
+        else
+            out[k] = v;
+    }
+    return out;
+}
+/** Call a Bot API method. Token goes in the URL path: POST /bot<token>/<method>. */
+export async function telegramCall(botToken, method, params, action = 'call Telegram Bot API') {
+    if (!botToken)
+        return missingToken();
+    try {
+        const response = await fetch(`${TELEGRAM_API_BASE}/bot${botToken}/${method}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(normalizeParams(params ?? {})),
+        });
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok || data?.ok === false) {
+            return { error: `Failed to ${action}`, details: data };
+        }
+        return data;
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/telegram/tools/index.d.ts

@@ -0,0 +1,15 @@
+import { createChatInviteLink, getChat, getChatAdministrators, getChatMember, getChatMembersCount } from './chats.js';
+import { getMe, setMyCommands } from './bot.js';
+import { deleteMessage, editMessage, forwardMessage, sendDocument, sendLocation, sendMessage, sendPhoto, sendPoll } from './messages.js';
+import { answerCallbackQuery, getChatHistory, getUpdates } from './updates.js';
+export { sendMessage, forwardMessage, editMessage, deleteMessage, sendPhoto, sendDocument, sendLocation, sendPoll, getChat, getChatAdministrators, getChatMember, getChatMembersCount, createChatInviteLink, getUpdates, getChatHistory, answerCallbackQuery, getMe, setMyCommands, };
+declare const auth: "telegramBotToken";
+type Scope = 'read' | 'write' | 'delete';
+export declare const telegramTools: {
+    name: string;
+    description: string;
+    tool: any;
+    requiredAuth: typeof auth;
+    scope: Scope;
+}[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/telegram/tools/index.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { createChatInviteLink, getChat, getChatAdministrators, getChatMember, getChatMembersCount, } from './chats.js';
+import { getMe, setMyCommands } from './bot.js';
+import { deleteMessage, editMessage, forwardMessage, sendDocument, sendLocation, sendMessage, sendPhoto, sendPoll, } from './messages.js';
+import { answerCallbackQuery, getChatHistory, getUpdates } from './updates.js';
+export { sendMessage, forwardMessage, editMessage, deleteMessage, sendPhoto, sendDocument, sendLocation, sendPoll, getChat, getChatAdministrators, getChatMember, getChatMembersCount, createChatInviteLink, getUpdates, getChatHistory, answerCallbackQuery, getMe, setMyCommands, };
+const auth = 'telegramBotToken';
+function entry(name, description, toolRef, scope) {
+    return { name, description, tool: toolRef, requiredAuth: auth, scope };
+}
+export const telegramTools = [
+    entry('telegramSendMessage', 'Sends a text message to a chat.', sendMessage, 'write'),
+    entry('telegramForwardMessage', 'Forwards a message to another chat.', forwardMessage, 'write'),
+    entry('telegramEditMessage', 'Edits a bot-authored text message.', editMessage, 'write'),
+    entry('telegramDeleteMessage', 'Deletes a message.', deleteMessage, 'delete'),
+    entry('telegramSendPhoto', 'Sends a photo by file_id or public URL.', sendPhoto, 'write'),
+    entry('telegramSendDocument', 'Sends a file preserving original format.', sendDocument, 'write'),
+    entry('telegramSendLocation', 'Sends a map point (static or live).', sendLocation, 'write'),
+    entry('telegramSendPoll', 'Sends a native poll (regular or quiz).', sendPoll, 'write'),
+    entry('telegramGetChat', 'Reads current chat info.', getChat, 'read'),
+    entry('telegramGetChatAdministrators', 'Lists chat admins with privilege flags.', getChatAdministrators, 'read'),
+    entry('telegramGetChatMember', 'Reads one member status/role.', getChatMember, 'read'),
+    entry('telegramGetChatMembersCount', 'Returns the member count (admin required).', getChatMembersCount, 'read'),
+    entry('telegramCreateChatInviteLink', 'Generates a new primary invite link.', createChatInviteLink, 'write'),
+    entry('telegramGetUpdates', 'Long-polls incoming updates.', getUpdates, 'read'),
+    entry('telegramGetChatHistory', 'Reads recent chat messages via the updates queue (composite).', getChatHistory, 'read'),
+    entry('telegramAnswerCallbackQuery', 'Answers an inline-keyboard callback query.', answerCallbackQuery, 'write'),
+    entry('telegramGetMe', 'Returns bot identity and validates the token.', getMe, 'read'),
+    entry('telegramSetMyCommands', 'Replaces the bot command menu.', setMyCommands, 'write'),
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/telegram/tools/messages.d.ts

@@ -0,0 +1,86 @@
+export declare const sendMessage: import("ai").Tool<{
+    text: string;
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+    parseMode?: "Markdown" | "MarkdownV2" | "HTML" | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    replyToMessageId?: number | undefined;
+    disableNotification?: boolean | undefined;
+    disableWebPagePreview?: boolean | undefined;
+}, any>;
+export declare const forwardMessage: import("ai").Tool<{
+    messageId: number;
+    chatId: string | number;
+    fromChatId: string | number;
+    telegramBotToken?: string | undefined;
+    disableNotification?: boolean | undefined;
+}, any>;
+export declare const editMessage: import("ai").Tool<{
+    text: string;
+    messageId?: number | undefined;
+    telegramBotToken?: string | undefined;
+    chatId?: string | number | undefined;
+    parseMode?: "Markdown" | "MarkdownV2" | "HTML" | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    disableWebPagePreview?: boolean | undefined;
+    inlineMessageId?: string | undefined;
+}, any>;
+export declare const deleteMessage: import("ai").Tool<{
+    messageId: number;
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const sendPhoto: import("ai").Tool<{
+    photo: string;
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+    parseMode?: "Markdown" | "MarkdownV2" | "HTML" | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    replyToMessageId?: number | undefined;
+    disableNotification?: boolean | undefined;
+    caption?: string | undefined;
+}, any>;
+export declare const sendDocument: import("ai").Tool<{
+    chatId: string | number;
+    document: string;
+    telegramBotToken?: string | undefined;
+    parseMode?: "Markdown" | "MarkdownV2" | "HTML" | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    replyToMessageId?: number | undefined;
+    disableNotification?: boolean | undefined;
+    caption?: string | undefined;
+    thumbnail?: string | undefined;
+    disableContentTypeDetection?: boolean | undefined;
+}, any>;
+export declare const sendLocation: import("ai").Tool<{
+    latitude: number;
+    longitude: number;
+    chatId: string | number;
+    telegramBotToken?: string | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    replyToMessageId?: number | undefined;
+    disableNotification?: boolean | undefined;
+    livePeriod?: number | undefined;
+    heading?: number | undefined;
+    horizontalAccuracy?: number | undefined;
+    proximityAlertRadius?: number | undefined;
+}, any>;
+export declare const sendPoll: import("ai").Tool<{
+    options: string[];
+    chatId: string | number;
+    question: string;
+    type?: "regular" | "quiz" | undefined;
+    telegramBotToken?: string | undefined;
+    replyMarkup?: string | Record<string, any> | undefined;
+    replyToMessageId?: number | undefined;
+    disableNotification?: boolean | undefined;
+    isAnonymous?: boolean | undefined;
+    allowsMultipleAnswers?: boolean | undefined;
+    correctOptionId?: number | undefined;
+    explanation?: string | undefined;
+    explanationParseMode?: "Markdown" | "MarkdownV2" | "HTML" | undefined;
+    openPeriod?: number | undefined;
+    closeDate?: number | undefined;
+    isClosed?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=messages.d.ts.map

package/dist/toolkits/telegram/tools/messages.js

@@ -0,0 +1,134 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { chatIdField, parseModeField, replyMarkupField, telegramBotTokenField, telegramCall } from './client.js';
+const silentField = z.boolean().optional().describe('Silent send (no sound)');
+const replyToField = z.number().int().optional().describe('Reply to this message ID');
+export const sendMessage = tool({
+    description: 'Sends a text message (1-4096 chars; split longer text). Bot must be a member with post rights; cannot DM users who never messaged first. ~1 msg/sec per chat, ~30/sec globally — honor 429 retry_after.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        text: z.string().min(1).max(4096).describe('Message text, 1-4096 chars after parsing'),
+        parseMode: parseModeField,
+        replyMarkup: replyMarkupField,
+        replyToMessageId: replyToField,
+        disableNotification: silentField,
+        disableWebPagePreview: z.boolean().optional().describe('Disable link previews'),
+    }),
+    execute: async ({ telegramBotToken, chatId, ...rest }) => telegramCall(telegramBotToken, 'sendMessage', { chat_id: chatId, ...rest }, 'send message'),
+});
+export const forwardMessage = tool({
+    description: "Forwards any message kind to another chat. Service messages can't be forwarded.",
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField.describe('Target chat'),
+        fromChatId: z.union([z.number(), z.string()]).describe('Source chat (ID or @channelusername)'),
+        messageId: z.number().int().describe('Message ID in the source chat'),
+        disableNotification: silentField,
+    }),
+    execute: async ({ telegramBotToken, chatId, fromChatId, messageId, disableNotification }) => telegramCall(telegramBotToken, 'forwardMessage', { chat_id: chatId, from_chat_id: fromChatId, message_id: messageId, disable_notification: disableNotification }, 'forward message'),
+});
+export const editMessage = tool({
+    description: 'Edits a bot-authored text message (1-4096 chars). Provide chat_id + message_id, or inline_message_id for inline messages.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        text: z.string().min(1).max(4096).describe('New message text'),
+        chatId: chatIdField.optional().describe('Required unless inline_message_id is given'),
+        messageId: z.number().int().optional().describe('Required unless inline_message_id is given'),
+        inlineMessageId: z.string().optional().describe('Inline message ID (alternative to chat+message IDs)'),
+        parseMode: parseModeField,
+        replyMarkup: replyMarkupField,
+        disableWebPagePreview: z.boolean().optional(),
+    }),
+    execute: async ({ telegramBotToken, chatId, messageId, inlineMessageId, ...rest }) => {
+        if (!inlineMessageId && (chatId === undefined || messageId === undefined)) {
+            return { error: 'Provide chatId + messageId, or inlineMessageId' };
+        }
+        return telegramCall(telegramBotToken, 'editMessageText', { chat_id: chatId, message_id: messageId, inline_message_id: inlineMessageId, ...rest }, 'edit message');
+    },
+});
+export const deleteMessage = tool({
+    description: "Deletes a message (bot must have delete rights; groups: only bot-authored, <48h). Linked channel/discussion pairs need separate calls per chat. Honor 429 retry_after.",
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        messageId: z.number().int().describe('Message ID to delete'),
+    }),
+    execute: async ({ telegramBotToken, chatId, messageId }) => telegramCall(telegramBotToken, 'deleteMessage', { chat_id: chatId, message_id: messageId }, 'delete message'),
+});
+export const sendPhoto = tool({
+    description: 'Sends a photo by file_id (preferred) or public HTTPS URL (Telegram-compressed; use sendDocument to preserve quality). No album support — one post per call.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        photo: z.string().describe('file_id or public HTTPS URL (no auth/signed links, no base64)'),
+        caption: z.string().max(1024).optional().describe('Caption, 0-1024 chars'),
+        parseMode: parseModeField.describe('Caption parse mode'),
+        replyMarkup: replyMarkupField,
+        replyToMessageId: replyToField,
+        disableNotification: silentField,
+    }),
+    execute: async ({ telegramBotToken, chatId, ...rest }) => telegramCall(telegramBotToken, 'sendPhoto', { chat_id: chatId, ...rest }, 'send photo'),
+});
+export const sendDocument = tool({
+    description: 'Sends a file by file_id (preferred) or public URL. Preserves original format/resolution unlike sendPhoto. ~1 msg/sec per chat; honor 429 retry_after.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        document: z.string().describe('file_id or HTTP URL for Telegram to fetch'),
+        caption: z.string().max(1024).optional().describe('Caption, 0-1024 chars'),
+        parseMode: parseModeField.describe('Caption parse mode'),
+        thumbnail: z.string().optional().describe('Thumbnail file_id/URL (skipped if server-side generation works)'),
+        replyMarkup: replyMarkupField,
+        replyToMessageId: replyToField,
+        disableNotification: silentField,
+        disableContentTypeDetection: z.boolean().optional().describe('Disable server-side content-type detection'),
+    }),
+    execute: async ({ telegramBotToken, chatId, ...rest }) => telegramCall(telegramBotToken, 'sendDocument', { chat_id: chatId, ...rest }, 'send document'),
+});
+export const sendLocation = tool({
+    description: 'Sends a map point (static or live location with update period and proximity alerts).',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        latitude: z.number().min(-90).max(90),
+        longitude: z.number().min(-180).max(180),
+        livePeriod: z.number().int().min(60).max(86400).optional().describe('Live-update seconds (60-86400)'),
+        heading: z.number().int().min(1).max(360).optional().describe('Live-location movement direction degrees'),
+        horizontalAccuracy: z.number().min(0).max(1500).optional().describe('Uncertainty radius meters (0-1500)'),
+        proximityAlertRadius: z.number().int().min(1).max(100000).optional().describe('Live-location proximity alert meters'),
+        replyMarkup: replyMarkupField,
+        replyToMessageId: replyToField,
+        disableNotification: silentField,
+    }),
+    execute: async ({ telegramBotToken, chatId, livePeriod, proximityAlertRadius, horizontalAccuracy, ...rest }) => telegramCall(telegramBotToken, 'sendLocation', { chat_id: chatId, live_period: livePeriod, proximity_alert_radius: proximityAlertRadius, horizontal_accuracy: horizontalAccuracy, ...rest }, 'send location'),
+});
+export const sendPoll = tool({
+    description: "Sends a native poll (regular or quiz). 2-10 options of 1-100 chars; question 1-300 chars. Quiz mode needs correct_option_id. open_period and close_date are mutually exclusive.",
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        question: z.string().min(1).max(300).describe('Poll question'),
+        options: z.array(z.string().min(1).max(100)).min(2).max(10).describe('2-10 answer options'),
+        type: z.enum(['regular', 'quiz']).optional().describe("Poll type (default 'regular')"),
+        isAnonymous: z.boolean().optional().describe('Anonymous voting (default true)'),
+        allowsMultipleAnswers: z.boolean().optional().describe('Multi-select (regular polls only)'),
+        correctOptionId: z.number().int().min(0).optional().describe('0-based correct option (quiz mode required)'),
+        explanation: z.string().max(200).optional().describe('Quiz explanation shown on wrong answers (max 2 line feeds)'),
+        explanationParseMode: z.enum(['Markdown', 'MarkdownV2', 'HTML']).optional(),
+        openPeriod: z.number().int().min(5).max(600).optional().describe('Auto-close seconds after creation (5-600)'),
+        closeDate: z.number().int().optional().describe('Auto-close Unix timestamp (5-600s in future)'),
+        isClosed: z.boolean().optional().describe('Close immediately (preview)'),
+        replyMarkup: replyMarkupField,
+        replyToMessageId: replyToField,
+        disableNotification: silentField,
+    }),
+    execute: async ({ telegramBotToken, chatId, isAnonymous, allowsMultipleAnswers, correctOptionId, explanationParseMode, openPeriod, closeDate, isClosed, ...rest }) => {
+        if (openPeriod !== undefined && closeDate !== undefined) {
+            return { error: 'openPeriod and closeDate are mutually exclusive' };
+        }
+        return telegramCall(telegramBotToken, 'sendPoll', { chat_id: chatId, is_anonymous: isAnonymous, allows_multiple_answers: allowsMultipleAnswers, correct_option_id: correctOptionId, explanation_parse_mode: explanationParseMode, open_period: openPeriod, close_date: closeDate, is_closed: isClosed, ...rest }, 'send poll');
+    },
+});
+//# sourceMappingURL=messages.js.map

package/dist/toolkits/telegram/tools/updates.d.ts

@@ -0,0 +1,23 @@
+export declare const getUpdates: import("ai").Tool<{
+    limit?: number | undefined;
+    timeout?: number | undefined;
+    offset?: number | undefined;
+    telegramBotToken?: string | undefined;
+    allowedUpdates?: string[] | undefined;
+}, any>;
+export declare const getChatHistory: import("ai").Tool<{
+    chatId: string | number;
+    messageId?: number | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    telegramBotToken?: string | undefined;
+}, any>;
+export declare const answerCallbackQuery: import("ai").Tool<{
+    callbackQueryId: string;
+    url?: string | undefined;
+    text?: string | undefined;
+    telegramBotToken?: string | undefined;
+    showAlert?: boolean | undefined;
+    cacheTime?: number | undefined;
+}, any>;
+//# sourceMappingURL=updates.d.ts.map

package/dist/toolkits/telegram/tools/updates.js

@@ -0,0 +1,54 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { chatIdField, telegramBotTokenField, telegramCall } from './client.js';
+export const getUpdates = tool({
+    description: 'Long-polls incoming updates (messages, edits, callbacks). Mutually exclusive with webhooks — 409 means delete the webhook first. Empty result is valid (no new updates). Poll ~1/sec; honor 429 retry_after.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        offset: z.number().int().optional().describe('First update ID (last seen + 1) to avoid duplicates'),
+        limit: z.number().int().min(1).max(100).optional().describe('Max updates (1-100, default 100)'),
+        timeout: z.number().int().min(0).optional().describe('Long-poll seconds (0 = short poll)'),
+        allowedUpdates: z.array(z.string()).optional().describe("Types to receive, e.g. ['message','callback_query'] (empty = all except chat_member)"),
+    }),
+    execute: async ({ telegramBotToken, ...rest }) => telegramCall(telegramBotToken, 'getUpdates', rest, 'get updates'),
+});
+function updateChatId(update) {
+    const msg = update?.message ?? update?.edited_message ?? update?.channel_post ?? update?.edited_channel_post ?? update?.callback_query?.message;
+    return msg?.chat?.id;
+}
+export const getChatHistory = tool({
+    description: 'Reads recent chat messages via the getUpdates queue filtered to one chat. Only unacknowledged updates from the last ~24h are visible (nothing before the bot joined); empty result means no accessible messages, not failure. No webhook may be active (409 otherwise).',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        chatId: chatIdField,
+        limit: z.number().int().min(1).max(100).optional().describe('Max messages (1-100, default 100)'),
+        offset: z.number().int().optional().describe('Skip this many filtered messages (pagination)'),
+        messageId: z.number().int().optional().describe('Start from this message ID in the chat'),
+    }),
+    execute: async ({ telegramBotToken, chatId, limit, offset, messageId }) => {
+        const fetched = await telegramCall(telegramBotToken, 'getUpdates', { limit: 100 }, 'get updates');
+        if (fetched?.error)
+            return fetched;
+        const updates = (fetched?.result ?? []).filter((u) => String(updateChatId(u)) === String(chatId));
+        const messages = updates
+            .map((u) => u.message ?? u.edited_message ?? u.channel_post ?? u.edited_channel_post ?? u.callback_query?.message)
+            .filter((m) => m && (messageId === undefined || m.message_id >= messageId));
+        const start = offset && offset > 0 ? offset : 0;
+        const sliced = messages.slice(start, start + (limit ?? 100));
+        return { ok: true, result: sliced };
+    },
+});
+export const answerCallbackQuery = tool({
+    description: 'Answers an inline-keyboard callback query (notification toast or alert popup). Answer promptly — IDs expire quickly and delays leave stuck spinners.',
+    inputSchema: z.object({
+        telegramBotToken: telegramBotTokenField,
+        callbackQueryId: z.string().describe('Callback query ID from the update'),
+        text: z.string().max(200).optional().describe('Notification text, 0-200 chars (omit for silent ack)'),
+        showAlert: z.boolean().optional().describe('Alert dialog instead of top toast (default false)'),
+        url: z.string().optional().describe('Game URL (callback_game buttons from @BotFather games only)'),
+        cacheTime: z.number().int().min(0).optional().describe('Client-side cache seconds (default 0)'),
+    }),
+    execute: async ({ telegramBotToken, callbackQueryId, showAlert, cacheTime, ...rest }) => telegramCall(telegramBotToken, 'answerCallbackQuery', { callback_query_id: callbackQueryId, show_alert: showAlert, cache_time: cacheTime, ...rest }, 'answer callback query'),
+});
+//# sourceMappingURL=updates.js.map

package/dist/toolkits/youtube/tools/get-channel-activities.d.ts

@@ -1,6 +1,6 @@
 export declare const getChannelActivities: import("ai").Tool<{
-    youtubeToken: string;
     channelId: string;
+    youtubeToken: string;
     maxResults?: number | undefined;
     pageToken?: string | undefined;
     part?: string | undefined;