@rnsk/toolkits 0.0.10 → 0.0.12

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/vercel/icon.d.ts

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

package/dist/toolkits/vercel/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg fill="currentColor" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Vercel</title><path d="M12 2.5L2.5 19.5h19L12 2.5z"/></svg>`;
+export const VERCEL_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/vercel/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/vercel/manifest.js

@@ -0,0 +1,35 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { VERCEL_ICON } from './icon.js';
+import { vercelTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'vercel',
+    displayName: 'Vercel',
+    shortDescription: 'Projects, deployments, domains, env vars, edge config and teams.',
+    category: 'Developer Tools & DevOps',
+    icon: VERCEL_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'vercelToken',
+        provider: {
+            slug: 'vercel',
+            env: { clientId: 'VERCEL_CLIENT_ID', clientSecret: 'VERCEL_CLIENT_SECRET' },
+            authorizeUrl: 'https://vercel.com/oauth/authorize',
+            tokenUrl: 'https://api.vercel.com/v2/oauth/access_token',
+            scopes: [],
+            exchangeStyle: 'json',
+            connectDescription: 'Connect Vercel to manage deployments, projects, domains and environment variables.',
+            callbackPath: '/api/auth/vercel/callback',
+            stateCookie: 'vercel_oauth_state',
+        },
+    },
+    allowedHosts: ['api.vercel.com'],
+    tools: vercelTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: { since: '0.0.10' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/vercel/tools/aliases.d.ts

@@ -0,0 +1,47 @@
+export declare const vercelAssignAlias: import("ai").Tool<{
+    id: string;
+    alias: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    redirect?: string | undefined;
+}, unknown>;
+export declare const vercelDeleteAlias: import("ai").Tool<{
+    vercelToken: string;
+    aliasId: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetAlias: import("ai").Tool<{
+    vercelToken: string;
+    idOrAlias: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    projectId?: string | undefined;
+    from?: number | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetPromoteAliases: import("ai").Tool<{
+    projectId: string;
+    vercelToken: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    failedOnly?: boolean | undefined;
+}, unknown>;
+export declare const vercelListAliases: import("ai").Tool<{
+    vercelToken: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    projectId?: string | undefined;
+    from?: number | undefined;
+    limit?: number | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    domain?: string | undefined;
+    rollbackDeploymentId?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=aliases.d.ts.map

package/dist/toolkits/vercel/tools/aliases.js

@@ -0,0 +1,141 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelAssignAlias = tool({
+    description: 'Tool to assign an alias to a specific Vercel deployment. Use when you need to associate a custom domain or subdomain with a deployment.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        id: z.string().describe('The ID of the deployment to assign the alias to'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of'),
+        alias: z.string().describe('The alias we want to assign to the deployment'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of'),
+        redirect: z.string().optional().describe('The redirect property will take precedence over the deployment id from the URL and consists of a hostname (like test.com) to which the alias should redirect using status code 307'),
+    }),
+    execute: async (params) => {
+        const { vercelToken, teamId, slug, ...rest } = params;
+        if (!vercelToken)
+            return { error: 'Vercel token is required. Connect Vercel first.' };
+        try {
+            const path = (() => { const p = rest; return `/v2/deployments/${p.id}/aliases`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Assign Alias to Deployment failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelAssignAlias', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelDeleteAlias = tool({
+    description: 'Tool to delete an alias from Vercel. Use when you need to remove a deployment alias or custom domain alias after confirming the alias ID.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        aliasId: z.string().describe('The ID or alias that will be removed. This is the unique identifier of the alias to delete.'),
+    }),
+    execute: async (params) => {
+        const { vercelToken, teamId, slug, ...rest } = params;
+        if (!vercelToken)
+            return { error: 'Vercel token is required. Connect Vercel first.' };
+        try {
+            const path = (() => { const p = rest; return `/v2/aliases/${p.aliasId}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'DELETE', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Delete Vercel Alias failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelDeleteAlias', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetAlias = tool({
+    description: 'Tool to retrieve information about a Vercel alias by ID or alias name. Use when you need to get details of a specific alias.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        from: z.number().optional().describe('Get the alias only if it was created after the provided timestamp (milliseconds).'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        since: z.number().optional().describe('Get the alias only if it was created after this JavaScript timestamp (milliseconds).'),
+        until: z.number().optional().describe('Get the alias only if it was created before this JavaScript timestamp (milliseconds).'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        idOrAlias: z.string().describe('The alias or alias ID to be retrieved.'),
+        projectId: z.string().optional().describe('Get the alias only if it is assigned to the provided project ID.'),
+    }),
+    execute: async (params) => {
+        const { vercelToken, teamId, slug, ...rest } = params;
+        if (!vercelToken)
+            return { error: 'Vercel token is required. Connect Vercel first.' };
+        try {
+            const path = (() => { const p = rest; return `/v2/aliases/${p.idOrAlias}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Vercel Alias failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetAlias', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetPromoteAliases = tool({
+    description: 'Tool to get a list of aliases with status for the current promote operation. Use when you need to check the status of aliases during a promotion process for a specific project.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        limit: z.number().optional().describe('Maximum number of aliases to list from a request (max 100).'),
+        since: z.number().optional().describe('Get aliases created after this epoch timestamp in milliseconds.'),
+        until: z.number().optional().describe('Get aliases created before this epoch timestamp in milliseconds.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        projectId: z.string().describe('The unique identifier of the project.'),
+        failedOnly: z.boolean().optional().describe('Filter results down to aliases that failed to map to the requested deployment.'),
+    }),
+    execute: async (params) => {
+        const { vercelToken, teamId, slug, ...rest } = params;
+        if (!vercelToken)
+            return { error: 'Vercel token is required. Connect Vercel first.' };
+        try {
+            const path = (() => { const p = rest; return `/v1/projects/${p.projectId}/promote/aliases`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'List Promote Aliases failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetPromoteAliases', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelListAliases = tool({
+    description: 'Tool to list aliases from Vercel API. Use when you need to retrieve aliases with optional filtering by domain, project, or time range. Results are paginated; use `limit` with `since`/`until` to iterate pages. Without filters, results span all projects and the personal account scope.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        from: z.number().optional().describe('Get only aliases created after the provided timestamp (milliseconds).'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        limit: z.number().optional().describe('Maximum number of aliases to list from a request.'),
+        since: z.number().optional().describe('Get aliases created after this JavaScript timestamp (milliseconds).'),
+        until: z.number().optional().describe('Get aliases created before this JavaScript timestamp (milliseconds).'),
+        domain: z.string().optional().describe('Get only aliases of the given domain name.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        projectId: z.string().optional().describe('Filter aliases from the given projectId.'),
+        rollbackDeploymentId: z.string().optional().describe('Get aliases that would be rolled back for the given deployment.'),
+    }),
+    execute: async (params) => {
+        const { vercelToken, teamId, slug, ...rest } = params;
+        if (!vercelToken)
+            return { error: 'Vercel token is required. Connect Vercel first.' };
+        try {
+            const path = (() => { const p = rest; return `/v2/aliases`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'List Vercel Aliases failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelListAliases', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=aliases.js.map

package/dist/toolkits/vercel/tools/auth.d.ts

@@ -0,0 +1,23 @@
+export declare const vercelCreateAuthToken: import("ai").Tool<{
+    name: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    expiresAt?: number | undefined;
+}, unknown>;
+export declare const vercelDeleteAuthToken: import("ai").Tool<{
+    vercelToken: string;
+    tokenId: string;
+}, unknown>;
+export declare const vercelGetAuthToken: import("ai").Tool<{
+    vercelToken: string;
+    tokenId: string;
+}, unknown>;
+export declare const vercelGetAuthUser: import("ai").Tool<{
+    vercelToken: string;
+}, unknown>;
+export declare const vercelListAuthTokens: import("ai").Tool<{
+    vercelToken: string;
+    teamId?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=auth.d.ts.map