@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/servicenow/tools/sdon.d.ts

@@ -0,0 +1,48 @@
+export declare const createSdwanTicket: import("ai").Tool<{
+    ticketType: string;
+    description?: string | undefined;
+    priority?: string | undefined;
+    category?: string | undefined;
+    servicenowCredentials?: string | undefined;
+    workNotes?: string | undefined;
+    assignedTo?: string | undefined;
+    subcategory?: string | undefined;
+    assignmentGroup?: string | undefined;
+    shortDescription?: string | undefined;
+    sysparmFields?: string | undefined;
+    sysparmDisplayValue?: "true" | "all" | "false" | undefined;
+    sysparmExcludeReferenceLink?: boolean | undefined;
+    sysparmInputDisplayValue?: boolean | undefined;
+    callerId?: string | undefined;
+}, any>;
+export declare const updateSdwanTicket: import("ai").Tool<{
+    id: string;
+    description?: string | undefined;
+    priority?: string | undefined;
+    state?: string | undefined;
+    comments?: string | undefined;
+    category?: string | undefined;
+    servicenowCredentials?: string | undefined;
+    impact?: string | undefined;
+    cmdbCi?: string | undefined;
+    workNotes?: string | undefined;
+    assignedTo?: string | undefined;
+    closeNotes?: string | undefined;
+    subcategory?: string | undefined;
+    assignmentGroup?: string | undefined;
+    shortDescription?: string | undefined;
+    sysparmFields?: string | undefined;
+    sysparmDisplayValue?: "true" | "all" | "false" | undefined;
+    sysparmExcludeReferenceLink?: boolean | undefined;
+    urgency?: string | undefined;
+    callerId?: string | undefined;
+    closeCode?: string | undefined;
+    escalation?: string | undefined;
+    holdReason?: string | undefined;
+    resolvedAt?: string | undefined;
+    resolvedBy?: string | undefined;
+    ticketType?: "Case" | "Incident" | "Problem" | "ChangeRequest" | undefined;
+    resolutionNotes?: string | undefined;
+    businessResolution?: string | undefined;
+}, any>;
+//# sourceMappingURL=sdon.d.ts.map

package/dist/toolkits/servicenow/tools/sdon.js

@@ -0,0 +1,81 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { snRequest, toServerKeys } from './client.js';
+export const createSdwanTicket = tool({
+    description: "Creates a new trouble ticket in ServiceNow using the Service Operations Workspace Trouble Ticket Open API. Use this action when you need to create a new SD-WAN or network-related trouble ticket for tracking and resolution. This action sends a POST request to the sn_ind_tsm_sdwan trouble ticket API, creating a record in the Case or other configured ticket table. After creation, the ticket will have a unique sys_id and number that can be used to retrieve, update, or close it in subsequent operations. This action is specifically for the Service Operations Workspace / Service Management SD-WAN integration's trouble ticket creation functionality.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        category: z.string().optional().describe("Category or classification of the trouble ticket. Example categories: 'Network', 'Hardware', 'Software', 'Security'. The exact categories depend on your ServiceNow configuration."),
+        priority: z.string().optional().describe("Priority level of the trouble ticket. Typical values: 1 = Critical (service down), 2 = High (major impact), 3 = Medium (moderate impact), 4 = Low (minor impact). The exact priority values depend on your ServiceNow configuration."),
+        callerId: z.string().optional().describe("Sys_id of the user who reported or initiated the trouble ticket. This is the 32-character hexadecimal string that identifies the user. Example: 'usr123abc456def789ghi012jkl345'"),
+        workNotes: z.string().optional().describe("Internal work notes about the trouble ticket. These notes are only visible to users with appropriate roles and are not visible to end users or customers. Use this for technical details and updates. Example: 'Investigated the issue and identified root cause as faulty switch'"),
+        assignedTo: z.string().optional().describe("Sys_id of the user assigned to handle the trouble ticket. This is the 32-character hexadecimal string that identifies the user. Example: 'usr789xyz012abc345def678ghi901'"),
+        description: z.string().optional().describe("Full detailed description of the trouble ticket, including symptoms, impact, and any relevant background information. Example: 'Users unable to access the corporate network since 9 AM'"),
+        subcategory: z.string().optional().describe("Subcategory of the trouble ticket for more specific classification. Example subcategories: 'Firewall', 'Router', 'Switch', 'VPN'. The exact subcategories depend on your ServiceNow configuration."),
+        ticketType: z.string().describe("The type of trouble ticket to create. Common values include 'case', 'incident', or other ticket types supported by your ServiceNow Service Operations Workspace SD-WAN configuration. Example: 'case'"),
+        sysparmFields: z.string().optional().describe("Comma-separated list of fields to return in the response. Invalid fields are ignored. If not specified, all fields are returned. Example: 'number,short_description,state,assigned_to'"),
+        assignmentGroup: z.string().optional().describe("Sys_id of the group assigned to handle the trouble ticket. This is the 32-character hexadecimal string that identifies the group. Example: 'grp456def789ghi012jkl345mno678'"),
+        shortDescription: z.string().optional().describe("Brief summary or title of the trouble ticket. This describes the issue or request in a concise manner. Example: 'Network connectivity issue in DC1'"),
+        sysparmDisplayValue: z.enum(['true', 'false', 'all']).optional().describe("Determines the type of data returned in the response. 'false': Returns actual database values (sys_ids for references, numeric values for choices). 'true': Returns display values (names for references, text labels for choices). 'all': Returns both display and actual values."),
+        sysparmInputDisplayValue: z.boolean().optional().describe("Set to true if providing display values (e.g., user names) instead of sys_ids in record_data for reference fields. When false (default), reference fields must contain sys_ids."),
+        sysparmExcludeReferenceLink: z.boolean().optional().describe("Set to true to exclude Table API links for reference fields in the response. Use this to reduce response size when reference links are not needed."),
+    }),
+    execute: async ({ servicenowCredentials, category, priority, callerId, workNotes, assignedTo, description, subcategory, ticketType, sysparmFields, assignmentGroup, shortDescription, sysparmDisplayValue, sysparmInputDisplayValue, sysparmExcludeReferenceLink }) => {
+        return snRequest(servicenowCredentials, '/api/sn_ind_tsm_sdwan/ticket/troubleTicket', {
+            method: 'POST',
+            query: {
+                sysparm_fields: sysparmFields,
+                sysparm_display_value: sysparmDisplayValue,
+                sysparm_input_display_value: sysparmInputDisplayValue,
+                sysparm_exclude_reference_link: sysparmExcludeReferenceLink,
+            },
+            body: toServerKeys({ ticketType, shortDescription, description, category, subcategory, priority, callerId, assignedTo, assignmentGroup, workNotes }),
+        });
+    },
+});
+export const updateSdwanTicket = tool({
+    description: "Updates an existing trouble ticket in ServiceNow using the Service Operations Workspace Trouble Ticket Open API. Use this action when you need to modify an existing trouble ticket, such as updating its state, changing assignments, adding notes, or modifying the resolution details. This action sends a PATCH request to the sn_ind_tsm_sdwan trouble ticket API, allowing partial updates of the record fields. Only include the fields you want to update in the request. Fields not included will retain their current values. This modifies the record data, but changes can be reverted by calling this action again with corrected values. This action is specifically for the Service Operations Workspace / Service Management SD-WAN integration's trouble ticket management functionality.",
+    inputSchema: z.object({
+        servicenowCredentials: z.string().optional().describe('Injected auth JSON {baseUrl, username, password} — do not provide'),
+        id: z.string().describe("The unique identifier (sys_id or record ID) of the trouble ticket to update. This is a 32-character hexadecimal string that uniquely identifies the trouble ticket record. Example: '1c741bd70b2322007518478d83673af3'"),
+        state: z.string().optional().describe("Current state of the trouble ticket. Common values vary by workflow but typically include: 'Open', 'In Progress', 'On Hold', 'Resolved', 'Closed', 'Cancelled'. The exact state values depend on your ServiceNow configuration."),
+        category: z.string().optional().describe("Category or classification of the trouble ticket. Example categories: 'Network', 'Hardware', 'Software', 'Security'. The exact categories depend on your ServiceNow configuration."),
+        priority: z.string().optional().describe("Priority level of the trouble ticket. Typical values: 1 = Critical (service down), 2 = High (major impact), 3 = Medium (moderate impact), 4 = Low (minor impact). The exact priority values depend on your ServiceNow configuration."),
+        closeCode: z.string().optional().describe("The resolution code for closing the trouble ticket. Common values: 'Resolved', 'Closed/Resolved', 'Closed/Cancelled', 'Not Resolved', 'Escalated'. The exact values depend on your configuration."),
+        workNotes: z.string().optional().describe("Internal work notes about the trouble ticket. These notes are only visible to users with appropriate roles and are not visible to end users or customers. Use this for technical details and updates. Example: 'Investigated the issue and identified root cause as faulty switch'"),
+        assignedTo: z.string().optional().describe("Sys_id of the user assigned to handle the trouble ticket. This is the 32-character hexadecimal string that identifies the user. Example: 'usr789xyz012abc345def678ghi901'"),
+        description: z.string().optional().describe("Full detailed description of the trouble ticket, including symptoms, impact, and any relevant background information. Example: 'Users unable to access the corporate network since 9 AM'"),
+        subcategory: z.string().optional().describe("Subcategory of the trouble ticket for more specific classification. Example subcategories: 'Firewall', 'Router', 'Switch', 'VPN'. The exact subcategories depend on your ServiceNow configuration."),
+        sysparmFields: z.string().optional().describe("Comma-separated list of fields to return in the response. Invalid fields are ignored. If not specified, all fields are returned. Example: 'number,short_description,state,assigned_to'"),
+        assignmentGroup: z.string().optional().describe("Sys_id of the group assigned to handle the trouble ticket. This is the 32-character hexadecimal string that identifies the group. Example: 'grp456def789ghi012jkl345mno678'"),
+        resolutionNotes: z.string().optional().describe("Notes documenting how the trouble ticket was resolved. These are typically added when closing the ticket and describe the solution. Example: 'Replaced faulty switch and connectivity restored'"),
+        shortDescription: z.string().optional().describe("Brief summary or title of the trouble ticket. This describes the issue or request in a concise manner. Example: 'Network connectivity issue in DC1'"),
+        sysparmDisplayValue: z.enum(['true', 'false', 'all']).optional().describe("Determines the type of data returned in the response. 'false': Returns actual database values (sys_ids for references, numeric values for choices). 'true': Returns display values (names for references, text labels for choices). 'all': Returns both display and actual values."),
+        sysparmExcludeReferenceLink: z.boolean().optional().describe("Set to true to exclude Table API links for reference fields in the response. Use this to reduce response size when reference links are not needed."),
+        impact: z.string().optional().describe("Impact level of the trouble ticket. Typical values: 1=High, 2=Medium, 3=Low. Use the numeric string value corresponding to the impact level."),
+        urgency: z.string().optional().describe("Urgency level of the trouble ticket. Typical values: 1=High, 2=Medium, 3=Low. Use the numeric string value corresponding to the urgency level."),
+        callerId: z.string().optional().describe("Sys_id of the user who reported the issue"),
+        comments: z.string().optional().describe("Comments visible to end users regarding the trouble ticket"),
+        escalation: z.string().optional().describe("Escalation status of the trouble ticket"),
+        cmdbCi: z.string().optional().describe("Sys_id of the Configuration Item associated with the trouble ticket"),
+        closeNotes: z.string().optional().describe("Notes added when closing the trouble ticket"),
+        holdReason: z.string().optional().describe("Reason for placing the trouble ticket on hold"),
+        resolvedAt: z.string().optional().describe("Timestamp when the trouble ticket was resolved (format: YYYY-MM-DD HH:MM:SS)"),
+        resolvedBy: z.string().optional().describe("Sys_id of the user who resolved the trouble ticket"),
+        ticketType: z.enum(['Case', 'Incident', 'Problem', 'ChangeRequest']).optional().describe("The type of trouble ticket to update. Valid values: 'Case', 'Incident', 'Problem', 'ChangeRequest'. Example: 'Case'"),
+        businessResolution: z.string().optional().describe("Business resolution description"),
+    }),
+    execute: async ({ servicenowCredentials, id, state, category, priority, closeCode, workNotes, assignedTo, description, subcategory, sysparmFields, assignmentGroup, resolutionNotes, shortDescription, sysparmDisplayValue, sysparmExcludeReferenceLink, impact, urgency, callerId, comments, escalation, cmdbCi, closeNotes, holdReason, resolvedAt, resolvedBy, businessResolution }) => {
+        return snRequest(servicenowCredentials, `/api/sn_ind_tsm_sdwan/ticket/troubleTicket/${encodeURIComponent(id)}`, {
+            method: 'PUT',
+            query: {
+                sysparm_fields: sysparmFields,
+                sysparm_display_value: sysparmDisplayValue,
+                sysparm_exclude_reference_link: sysparmExcludeReferenceLink,
+            },
+            body: toServerKeys({ state, category, priority, closeCode, workNotes, assignedTo, description, subcategory, assignmentGroup, resolutionNotes, shortDescription, impact, urgency, callerId, comments, escalation, cmdbCi, closeNotes, holdReason, resolvedAt, resolvedBy, businessResolution }),
+        });
+    },
+});
+//# sourceMappingURL=sdon.js.map

package/dist/toolkits/slack/tools/admin-conversations.d.ts

@@ -1,13 +1,13 @@
 export declare const slackAdminSearchConversations: import("ai").Tool<{
     query?: string | undefined;
-    sort?: "created" | "name" | "relevant" | "member_count" | undefined;
+    sort?: "name" | "created" | "relevant" | "member_count" | undefined;
     limit?: number | undefined;
     cursor?: string | undefined;
+    sortDir?: "asc" | "desc" | undefined;
     slackToken?: string | undefined;
     teamIds?: string | undefined;
     connectedTeamIds?: string | undefined;
     searchChannelTypes?: "private" | "public" | "archived" | "private_exclude" | "im" | "mpim" | "ext_shared" | "org_shared" | "exclude_archived" | "multi_workspace" | "org_wide" | "external_shared" | undefined;
-    sortDir?: "asc" | "desc" | undefined;
     totalCountOnly?: boolean | undefined;
 }, any>;
 export declare const slackAdminCreateConversation: import("ai").Tool<{

package/dist/toolkits/slack/tools/emoji.d.ts

@@ -1,6 +1,6 @@
 export declare const slackAddEmoji: import("ai").Tool<{
-    url: string;
     name: string;
+    url: string;
     slackToken?: string | undefined;
 }, any>;
 export declare const slackAddEmojiAlias: import("ai").Tool<{

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

@@ -69,8 +69,8 @@ export declare const slackSendMeMessage: import("ai").Tool<{
 export declare const slackSendEphemeralMessage: import("ai").Tool<{
     user: string;
     channel: string;
-    blocks?: string | undefined;
     username?: string | undefined;
+    blocks?: string | undefined;
     text?: string | undefined;
     parse?: string | undefined;
     slackToken?: string | undefined;
@@ -90,8 +90,8 @@ export declare const slackListUnreadChannelMessages: import("ai").Tool<{
     includeAllMetadata?: boolean | undefined;
 }, any>;
 export declare const slackGetUnreadMessagesFromUser: import("ai").Tool<{
-    limit: number;
     userId: string;
+    limit: number;
     slackToken?: string | undefined;
 }, {
     error: string;

package/dist/toolkits/slack/tools/reactions-stars-pins.d.ts

@@ -13,21 +13,21 @@ export declare const slackRemoveReaction: import("ai").Tool<{
     fileComment?: string | undefined;
 }, any>;
 export declare const slackGetReactions: import("ai").Tool<{
+    full?: boolean | undefined;
     file?: string | undefined;
     timestamp?: string | undefined;
     channel?: string | undefined;
-    full?: boolean | undefined;
     slackToken?: string | undefined;
     fileComment?: string | undefined;
 }, any>;
 export declare const slackListUserReactions: import("ai").Tool<{
     count?: number | undefined;
     teamId?: string | undefined;
+    full?: boolean | undefined;
     user?: string | undefined;
     limit?: number | undefined;
     page?: number | undefined;
     cursor?: string | undefined;
-    full?: boolean | undefined;
     slackToken?: string | undefined;
 }, any>;
 export declare const slackAddStar: import("ai").Tool<{

package/dist/toolkits/slack/tools/search.d.ts

@@ -4,8 +4,8 @@ export declare const slackSearchAll: import("ai").Tool<{
     count?: number | undefined;
     teamId?: string | undefined;
     page?: number | undefined;
-    slackToken?: string | undefined;
     sortDir?: string | undefined;
+    slackToken?: string | undefined;
     highlight?: boolean | undefined;
 }, any>;
 export declare const slackSearchMessages: import("ai").Tool<{
@@ -15,8 +15,8 @@ export declare const slackSearchMessages: import("ai").Tool<{
     teamId?: string | undefined;
     page?: number | undefined;
     cursor?: string | undefined;
-    slackToken?: string | undefined;
     sortDir?: string | undefined;
+    slackToken?: string | undefined;
     highlight?: boolean | undefined;
     autoPaginate?: boolean | undefined;
 }, any>;
@@ -27,8 +27,8 @@ export declare const slackAssistantSearch: import("ai").Tool<{
     before?: number | undefined;
     after?: number | undefined;
     cursor?: string | undefined;
-    slackToken?: string | undefined;
     sortDir?: string | undefined;
+    slackToken?: string | undefined;
     includeBots?: boolean | undefined;
     highlight?: boolean | undefined;
     contentTypes?: string | undefined;

package/dist/toolkits/slack/tools/users.d.ts

@@ -33,9 +33,9 @@ export declare const slackGetUserProfile: import("ai").Tool<{
 }, any>;
 export declare const slackSetUserProfile: import("ai").Tool<{
     value?: string | undefined;
-    user?: string | undefined;
     name?: string | undefined;
     profile?: string | undefined;
+    user?: string | undefined;
     slackToken?: string | undefined;
 }, any>;
 export declare const slackGetUserPresence: import("ai").Tool<{

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

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

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelCreateAuthToken = tool({
+    description: 'Tool to create a new authentication token. Use when you need to programmatically generate a new auth token with optional expiration. Returns both token metadata and the bearer token value (only provided once).',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        name: z.string().describe('The human-readable name of the token.'),
+        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.'),
+        expiresAt: z.number().optional().describe('Timestamp (in milliseconds) of when the token expires. Must be within 2 years from now. If not provided, the token will not expire.'),
+    }),
+    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 `/v3/user/tokens`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Create Auth Token failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelCreateAuthToken', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelDeleteAuthToken = tool({
+    description: 'Tool to delete an authentication token. Use when you need to revoke a token programmatically after confirming its validity. Example: "Delete auth token with id abc123"',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        tokenId: z.string().describe('The identifier of the token to invalidate. Use \'current\' to invalidate the token used for this request.'),
+    }),
+    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 `/v3/user/tokens/${p.tokenId}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'DELETE', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Delete Auth Token failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelDeleteAuthToken', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetAuthToken = tool({
+    description: 'Tool to retrieve metadata for an authentication token. Use when you need to inspect details of a specific token or get information about the current token being used.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        tokenId: z.string().describe('The identifier of the token to retrieve. The special value \'current\' may be supplied, which returns the metadata for the token that the current HTTP request is authenticated with.'),
+    }),
+    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 `/v5/user/tokens/${p.tokenId}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Auth Token Metadata failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetAuthToken', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetAuthUser = tool({
+    description: 'Tool to get the authenticated user\'s profile. Use when you need to retrieve details about the currently authenticated user.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+    }),
+    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/user`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Authenticated User failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetAuthUser', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelListAuthTokens = tool({
+    description: 'Tool to list authentication tokens. Use when you need to retrieve all tokens for the current user or an optional team.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        teamId: z.string().optional().describe('Team ID to list tokens for. If omitted, lists tokens for the current user.'),
+    }),
+    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 `/v3/user/tokens`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'List Auth Tokens failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelListAuthTokens', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=auth.js.map