@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,145 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const STATUSPAGE_BASE = 'https://status.snowflake.com/api/v2';
+export const snowflakeCredentialsField = z
+    .string()
+    .optional()
+    .describe('Snowflake credential JSON {accountHost, token}. Injected at runtime.');
+export function missingCredentials() {
+    return { error: 'Snowflake credentials are required. Connect Snowflake first with your account host and access token.' };
+}
+export function parseCredentials(raw) {
+    if (!raw)
+        return missingCredentials();
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed.accountHost || !parsed.token) {
+            return { error: 'Snowflake credentials must be JSON with accountHost and token, e.g. {"accountHost":"org-account","token":"..."}' };
+        }
+        return parsed;
+    }
+    catch {
+        return { error: 'Snowflake credentials must be valid JSON with accountHost and token.' };
+    }
+}
+/** Normalize account host: accepts bare locator, full host, or URL. */
+export function normalizeHost(accountHost) {
+    let host = accountHost.trim().replace(/^https?:\/\//, '').replace(/\/+$/, '');
+    if (!host.includes('.'))
+        host = `${host}.snowflakecomputing.com`;
+    return `https://${host}`;
+}
+export async function snowflakeSqlApi(creds, path, options) {
+    const base = normalizeHost(creds.accountHost);
+    let url = `${base}/api/v2${path}`;
+    const search = new URLSearchParams();
+    for (const [k, v] of Object.entries(options?.query ?? {})) {
+        if (v !== undefined)
+            search.set(k, String(v));
+    }
+    if (options?.requestId)
+        search.set('requestId', options.requestId);
+    const qs = search.toString();
+    if (qs)
+        url += `?${qs}`;
+    try {
+        const response = await fetch(url, {
+            method: options?.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${creds.token}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'X-Snowflake-Authorization-Token-Type': 'OAUTH',
+                'User-Agent': 'rnsk-toolkits/1.0',
+            },
+            body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await response.text();
+        let data = {};
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = { raw: text };
+            }
+        }
+        if (!response.ok)
+            return { error: 'Snowflake SQL API request failed', status: response.status, details: data };
+        return data;
+    }
+    catch (error) {
+        return { error: 'Error calling Snowflake SQL API', message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+/** Submit a statement (sync by default) and return the raw API response. */
+export async function submitStatement(creds, input, action = 'execute SQL statement') {
+    try {
+        const body = { statement: input.statement };
+        if (input.timeout !== undefined)
+            body.timeout = input.timeout;
+        if (input.database)
+            body.database = input.database;
+        if (input.schema)
+            body.schema = input.schema;
+        if (input.warehouse)
+            body.warehouse = input.warehouse;
+        if (input.role)
+            body.role = input.role;
+        if (input.bindings)
+            body.bindings = input.bindings;
+        if (input.parameters)
+            body.parameters = input.parameters;
+        if (input.async !== undefined)
+            body.async = input.async;
+        const result = await snowflakeSqlApi(creds, '/statements', { method: 'POST', body, requestId: input.requestId });
+        if (result?.error)
+            return { error: `Failed to ${action}`, ...result };
+        return result;
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+function quoteIdent(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function quoteLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/** Build SHOW <objects> SQL from common filter options. */
+export function buildShow(objects, scope, opts) {
+    const parts = ['SHOW'];
+    if (opts.terse)
+        parts.push('TERSE');
+    parts.push(objects);
+    if (opts.history)
+        parts.push('HISTORY');
+    if (opts.likePattern)
+        parts.push(`LIKE ${quoteLiteral(opts.likePattern)}`);
+    if (scope)
+        parts.push(scope);
+    if (opts.startsWith)
+        parts.push(`STARTS WITH ${quoteLiteral(opts.startsWith)}`);
+    if (opts.limit !== undefined) {
+        parts.push(`LIMIT ${opts.limit}`);
+        if (opts.fromName)
+            parts.push(`FROM ${quoteLiteral(opts.fromName)}`);
+    }
+    return parts.join(' ');
+}
+export { quoteIdent, quoteLiteral };
+/** Public Snowflake status page (Statuspage API, no auth). */
+export async function statusPage(path, action = 'query Snowflake status page') {
+    try {
+        const response = await fetch(`${STATUSPAGE_BASE}${path}`, { headers: { Accept: 'application/json' } });
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok)
+            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/snowflake/tools/index.d.ts

@@ -0,0 +1,14 @@
+import { dropWarehouse, fetchCatalogIntegration, showDatabases, showSchemas, showTables } from './catalog.js';
+import { cancelStatementExecution, checkStatementStatus, executeSql, validateCredential } from './statements.js';
+import { getActiveScheduledMaintenances, getAllScheduledMaintenances, getComponentStatus, getStatusRollup, getStatusSummary, getUnresolvedIncidents, getUpcomingScheduledMaintenances } from './status.js';
+export { executeSql, checkStatementStatus, cancelStatementExecution, validateCredential, showDatabases, showSchemas, showTables, dropWarehouse, fetchCatalogIntegration, getStatusSummary, getStatusRollup, getComponentStatus, getUnresolvedIncidents, getActiveScheduledMaintenances, getUpcomingScheduledMaintenances, getAllScheduledMaintenances, };
+declare const auth: "snowflakeCredentials";
+type Scope = 'read' | 'write' | 'delete';
+export declare const snowflakeTools: {
+    name: string;
+    description: string;
+    tool: any;
+    requiredAuth?: typeof auth;
+    scope: Scope;
+}[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { dropWarehouse, fetchCatalogIntegration, showDatabases, showSchemas, showTables, } from './catalog.js';
+import { cancelStatementExecution, checkStatementStatus, executeSql, validateCredential, } from './statements.js';
+import { getActiveScheduledMaintenances, getAllScheduledMaintenances, getComponentStatus, getStatusRollup, getStatusSummary, getUnresolvedIncidents, getUpcomingScheduledMaintenances, } from './status.js';
+export { executeSql, checkStatementStatus, cancelStatementExecution, validateCredential, showDatabases, showSchemas, showTables, dropWarehouse, fetchCatalogIntegration, getStatusSummary, getStatusRollup, getComponentStatus, getUnresolvedIncidents, getActiveScheduledMaintenances, getUpcomingScheduledMaintenances, getAllScheduledMaintenances, };
+const auth = 'snowflakeCredentials';
+function entry(name, description, toolRef, scope, noAuth = false) {
+    return noAuth ? { name, description, tool: toolRef, scope } : { name, description, tool: toolRef, requiredAuth: auth, scope };
+}
+export const snowflakeTools = [
+    entry('snowflakeExecuteSql', 'Executes SQL synchronously and returns rows (SELECT, DDL, DML, batches).', executeSql, 'write'),
+    entry('snowflakeCheckStatementStatus', 'Polls an async statement by handle; follows result partitions.', checkStatementStatus, 'read'),
+    entry('snowflakeCancelStatementExecution', 'Cancels a running statement by handle.', cancelStatementExecution, 'delete'),
+    entry('snowflakeValidateCredential', 'Validates credentials with a lightweight session query.', validateCredential, 'read'),
+    entry('snowflakeShowDatabases', 'Lists accessible databases with filters and pagination.', showDatabases, 'read'),
+    entry('snowflakeShowSchemas', 'Lists accessible schemas with scope and filters.', showSchemas, 'read'),
+    entry('snowflakeShowTables', 'Lists accessible tables with scope and filters.', showTables, 'read'),
+    entry('snowflakeDropWarehouse', 'Permanently drops a warehouse (irreversible).', dropWarehouse, 'delete'),
+    entry('snowflakeFetchCatalogIntegration', 'Describes an Iceberg catalog integration.', fetchCatalogIntegration, 'read'),
+    entry('snowflakeGetStatusSummary', 'Reads the public status summary (overall + regions + incidents).', getStatusSummary, 'read', true),
+    entry('snowflakeGetStatusRollup', 'Reads the public page rollup (indicator + description).', getStatusRollup, 'read', true),
+    entry('snowflakeGetComponentStatus', 'Lists per-component status (public, limit applied locally).', getComponentStatus, 'read', true),
+    entry('snowflakeGetUnresolvedIncidents', 'Lists unresolved incidents (public).', getUnresolvedIncidents, 'read', true),
+    entry('snowflakeGetActiveScheduledMaintenances', 'Lists in-progress/verifying maintenances (public).', getActiveScheduledMaintenances, 'read', true),
+    entry('snowflakeGetUpcomingScheduledMaintenances', 'Lists scheduled (not started) maintenances (public).', getUpcomingScheduledMaintenances, 'read', true),
+    entry('snowflakeGetAllScheduledMaintenances', 'Lists the 50 most recent maintenances (public).', getAllScheduledMaintenances, 'read', true),
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/snowflake/tools/statements.d.ts

@@ -0,0 +1,27 @@
+export declare const executeSql: import("ai").Tool<{
+    statement: string;
+    timeout?: number | undefined;
+    parameters?: Record<string, any> | undefined;
+    role?: string | undefined;
+    database?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    schemaName?: string | undefined;
+    bindings?: Record<string, any> | undefined;
+    requestId?: string | undefined;
+    warehouse?: string | undefined;
+}, any>;
+export declare const checkStatementStatus: import("ai").Tool<{
+    statementHandle: string;
+    snowflakeCredentials?: string | undefined;
+    requestId?: string | undefined;
+    partition?: number | undefined;
+}, any>;
+export declare const cancelStatementExecution: import("ai").Tool<{
+    statementHandle: string;
+    snowflakeCredentials?: string | undefined;
+    requestId?: string | undefined;
+}, any>;
+export declare const validateCredential: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=statements.d.ts.map

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

@@ -0,0 +1,84 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { parseCredentials, snowflakeCredentialsField, snowflakeSqlApi, submitStatement } from './client.js';
+const executionContext = {
+    role: z.string().optional().describe("Role (case-sensitive; default the token user's DEFAULT_ROLE)"),
+    warehouse: z.string().optional().describe('Warehouse (case-sensitive; required for compute; default DEFAULT_WAREHOUSE)'),
+    database: z.string().optional().describe("Database (case-sensitive; default DEFAULT_NAMESPACE)"),
+    timeout: z.number().int().optional().describe('Timeout seconds (0 = max 604800; default server default)'),
+};
+export const executeSql = tool({
+    description: 'Executes SQL synchronously (SELECT, DDL, DML; semicolon-separated batches run in sequence) and returns rows. For INFORMATION_SCHEMA filter on table_schema + table_catalog and parenthesize mixed AND/OR.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        statement: z.string().min(1).describe("SQL text, e.g. 'SELECT * FROM my_table;'"),
+        schemaName: z.string().optional().describe('Schema context (maps to SQL API schema)'),
+        bindings: z.record(z.any()).optional().describe('Bind variables for parameterized queries (prevents SQL injection)'),
+        parameters: z.record(z.any()).optional().describe('Session parameters, e.g. STATEMENT_TIMEOUT_IN_SECONDS'),
+        requestId: z.string().optional().describe('Idempotency key (UUID) — safe retries reuse the same statement'),
+        ...executionContext,
+    }),
+    execute: async ({ snowflakeCredentials, statement, schemaName, bindings, parameters, requestId, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        return submitStatement(creds, { statement, schema: schemaName, bindings, parameters, requestId, ...ctx });
+    },
+});
+export const checkStatementStatus = tool({
+    description: 'Polls an async statement by handle until no longer pending; follows partition pages for large result sets. Pair with executeSql async batches or the deprecated submit flow.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        statementHandle: z.string().describe('Statement handle UUID from submission'),
+        partition: z.number().int().min(0).optional().describe('Result partition index (0-based) for paged fetches'),
+        requestId: z.string().optional().describe('Idempotency key echoed on the request'),
+    }),
+    execute: async ({ snowflakeCredentials, statementHandle, partition, requestId }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        try {
+            const result = await snowflakeSqlApi(creds, `/statements/${statementHandle}`, { query: { partition }, requestId });
+            if (result?.error)
+                return { error: 'Failed to check statement status', ...result };
+            return result;
+        }
+        catch (error) {
+            return { error: 'Error checking statement status', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const cancelStatementExecution = tool({
+    description: 'Cancels a running statement by handle. Use to stop long-running queries.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        statementHandle: z.string().describe('Handle of the running statement to cancel'),
+        requestId: z.string().optional().describe('Idempotency key echoed on the request'),
+    }),
+    execute: async ({ snowflakeCredentials, statementHandle, requestId }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        try {
+            const result = await snowflakeSqlApi(creds, `/statements/${statementHandle}/cancel`, { method: 'POST', requestId });
+            if (result?.error)
+                return { error: 'Failed to cancel statement', ...result };
+            return result;
+        }
+        catch (error) {
+            return { error: 'Error canceling statement', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const validateCredential = tool({
+    description: 'Validates credentials with a lightweight session query. Returns user/role/warehouse/database/schema/version on success, auth details on failure.',
+    inputSchema: z.object({ snowflakeCredentials: snowflakeCredentialsField }),
+    execute: async ({ snowflakeCredentials }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        return submitStatement(creds, { statement: 'SELECT CURRENT_USER() AS "user", CURRENT_ROLE() AS "role", CURRENT_WAREHOUSE() AS "warehouse", CURRENT_DATABASE() AS "database", CURRENT_SCHEMA() AS "schema", CURRENT_VERSION() AS "version"' }, 'validate credentials');
+    },
+});
+//# sourceMappingURL=statements.js.map

package/dist/toolkits/snowflake/tools/status.d.ts

@@ -0,0 +1,22 @@
+export declare const getStatusSummary: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+export declare const getStatusRollup: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+export declare const getComponentStatus: import("ai").Tool<{
+    limit?: number | undefined;
+}, any>;
+export declare const getUnresolvedIncidents: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+export declare const getActiveScheduledMaintenances: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+export declare const getUpcomingScheduledMaintenances: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+export declare const getAllScheduledMaintenances: import("ai").Tool<{
+    snowflakeCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=status.d.ts.map

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