@rnsk/toolkits 0.0.10 → 0.0.12

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

package/dist/toolkits/vercel/tools/cache-artifacts.d.ts

@@ -0,0 +1,57 @@
+export declare const vercelCheckCacheArtifactExists: import("ai").Tool<{
+    vercelToken: string;
+    hash: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelDeleteDataCachePurgeAll: import("ai").Tool<{
+    vercelToken: string;
+    projectIdOrName: string;
+    teamId?: string | undefined;
+}, unknown>;
+export declare const vercelDownloadArtifact: import("ai").Tool<{
+    vercelToken: string;
+    hash: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    xArtifactClientCi?: string | undefined;
+    xArtifactClientInteractive?: number | undefined;
+}, unknown>;
+export declare const vercelGetArtifactInfo: import("ai").Tool<{
+    vercelToken: string;
+    hashes: string[];
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetCacheStatus: import("ai").Tool<{
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelInvalidateCacheBySrcImages: import("ai").Tool<{
+    vercelToken: string;
+    srcImages: string[];
+    projectIdOrName: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelInvalidateCacheByTags: import("ai").Tool<{
+    tags: string;
+    vercelToken: string;
+    projectIdOrName: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    target?: string | undefined;
+}, unknown>;
+export declare const vercelUploadArtifact: import("ai").Tool<{
+    artifact: Record<string, any>;
+    vercelToken: string;
+    hash: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    xArtifactClientCi?: string | undefined;
+    xArtifactClientInteractive?: number | undefined;
+    xArtifactTag?: string | undefined;
+    xArtifactDuration?: number | undefined;
+}, unknown>;
+//# sourceMappingURL=cache-artifacts.d.ts.map

package/dist/toolkits/vercel/tools/cache-artifacts.js

@@ -0,0 +1,205 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelCheckCacheArtifactExists = tool({
+    description: 'Tool to check if a cache artifact exists by its hash. Use when verifying whether a cache artifact is already stored before upload or when validating artifact availability.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        hash: z.string().describe('The artifact hash to check for existence.'),
+        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.'),
+    }),
+    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 `/v8/artifacts/${p.hash}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'HEAD', teamId, slug, body: undefined, query: undefined });
+            if (!res.ok)
+                return { error: 'Check Artifact Exists failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelCheckCacheArtifactExists', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelDeleteDataCachePurgeAll = tool({
+    description: 'Tool to purge all data cache entries for a specific project. Use when you need to clear the entire data cache for a project.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        teamId: z.string().optional().describe('Optional team identifier to perform the request on behalf of.'),
+        projectIdOrName: z.string().describe('The project ID or name for which to purge all data cache entries.'),
+    }),
+    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.projectIdOrName}/data-cache`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'DELETE', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Purge All Data Cache failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelDeleteDataCachePurgeAll', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelDownloadArtifact = tool({
+    description: 'Download a cache artifact from Vercel\'s Remote Cache by its hash. Use this to retrieve previously cached build artifacts generated by Turborepo or other build systems. Remote Caching must be enabled for the team. Returns a tar.gz compressed file.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        hash: z.string().describe('The unique artifact hash identifier generated by the build system (e.g., Turborepo). This hash uniquely identifies the cached build artifact to download.'),
+        slug: z.string().optional().describe('The Team URL slug to perform the request on behalf of. Can be used as an alternative to teamId.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of. Required to access team-level cached artifacts.'),
+        xArtifactClientCi: z.string().optional().describe('The CI/CD environment where this artifact is being downloaded (e.g., \'VERCEL\', \'GITHUB_ACTIONS\', \'CIRCLECI\'). Max 50 characters.'),
+        xArtifactClientInteractive: z.number().optional().describe('Indicates if the client is an interactive shell. Set to 1 for interactive, 0 for non-interactive (CI environments).'),
+    }),
+    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 `/v8/artifacts/${p.hash}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Download Cache Artifact failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelDownloadArtifact', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetArtifactInfo = tool({
+    description: 'Tool to query information about artifacts by their hashes. Use when you need to retrieve metadata about one or more artifacts, including size, processing duration, and tags.',
+    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'),
+        hashes: z.array(z.string()).describe('List of artifact hashes to query information for'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of'),
+    }),
+    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 `/v8/artifacts`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Query Artifact Information failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetArtifactInfo', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetCacheStatus = tool({
+    description: 'Tool to get the status of Remote Caching for the principal. Use when you need to check if Remote Caching is enabled, disabled, over limit, or paused.',
+    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.'),
+    }),
+    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/cache/status`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Remote Caching Status failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetCacheStatus', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelInvalidateCacheBySrcImages = tool({
+    description: 'Tool to invalidate edge cache by source image URLs. Use when you need to mark cached images as stale for specific source images. Invalidated images are revalidated in the background on the next request, ensuring zero latency impact for users.',
+    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.'),
+        srcImages: z.array(z.string()).describe('List of source image URLs to invalidate from edge cache. Must contain 1-8 URLs, each up to 8192 characters. Invalidated images will be revalidated in the background on next request.'),
+        projectIdOrName: z.string().describe('The project ID or name to invalidate cache for. This is required and must be a valid project identifier.'),
+    }),
+    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.projectIdOrName}/cache/invalidate/images`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Invalidate Cache By Source Images failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelInvalidateCacheBySrcImages', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelInvalidateCacheByTags = tool({
+    description: 'Tool to invalidate edge cache by tags. Use when you need to mark cached content as stale for specific cache tags. Invalidated content is revalidated in the background on the next request, ensuring zero latency impact for users.',
+    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.'),
+        tags: z.string().describe('Cache tags to invalidate. Can be a single tag string or a list of tag strings (1-16 elements, max 256 chars per tag). Invalidated content will be revalidated in the background on next request.'),
+        target: z.string().optional().describe('Target environment to invalidate cache from. Either \'production\' or \'preview\'.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        projectIdOrName: z.string().describe('The project ID or name to invalidate cache for. This is required and must be a valid project identifier.'),
+    }),
+    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.projectIdOrName}/cache/invalidate/tags`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Invalidate Cache By Tags failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelInvalidateCacheByTags', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelUploadArtifact = tool({
+    description: 'Tool to upload a cache artifact to Vercel. Use when you need to store build artifacts in Vercel\'s remote cache.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        hash: z.string().describe('The artifact hash identifier'),
+        slug: z.string().optional().describe('Team slug to perform the request on behalf of'),
+        teamId: z.string().optional().describe('Team identifier to perform the request on behalf of'),
+        artifact: z.record(z.any()).describe('The artifact file to upload.'),
+        xArtifactTag: z.string().optional().describe('The base64 encoded tag for this artifact.'),
+        xArtifactDuration: z.number().optional().describe('The time taken to generate the uploaded artifact in milliseconds'),
+        xArtifactClientCi: z.string().optional().describe('The continuous integration or delivery environment where this artifact was generated'),
+        xArtifactClientInteractive: z.number().optional().describe('1 if the client is an interactive shell, otherwise 0'),
+    }),
+    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 `/v8/artifacts/${p.hash}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Upload Cache Artifact failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelUploadArtifact', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=cache-artifacts.js.map

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

@@ -0,0 +1,9 @@
+export declare const vercelGetCerts: import("ai").Tool<{
+    vercelToken: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=certs.d.ts.map

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelGetCerts = tool({
+    description: 'Tool to retrieve SSL/TLS certificates for the authenticated user or team. Use after authentication to list active certificates.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        slug: z.string().optional().describe('Team slug to perform the request on behalf of'),
+        limit: z.number().optional().describe('Maximum number of certificates to return (max 100)'),
+        since: z.number().optional().describe('Timestamp in milliseconds; include certificates created since this time'),
+        until: z.number().optional().describe('Timestamp in milliseconds; include certificates created until this time'),
+        teamId: z.string().optional().describe('Team identifier to perform the request on behalf of. Omit for personal account.'),
+    }),
+    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/certs`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get SSL/TLS Certificates failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetCerts', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=certs.js.map

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

@@ -0,0 +1,17 @@
+export declare const VERCEL_API_BASE = "https://api.vercel.com";
+export declare function buildTeamQuery(teamId?: string, slug?: string): string;
+export declare function appendTeamQuery(url: string, teamId?: string, slug?: string): string;
+export declare function vercelFetch(path: string, opts: {
+    vercelToken: string;
+    method?: string;
+    query?: Record<string, string | undefined>;
+    body?: unknown;
+    teamId?: string;
+    slug?: string;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: unknown;
+    error?: unknown;
+}>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,53 @@
+// @ts-nocheck
+export const VERCEL_API_BASE = 'https://api.vercel.com';
+export function buildTeamQuery(teamId, slug) {
+    if (teamId)
+        return `teamId=${encodeURIComponent(teamId)}`;
+    if (slug)
+        return `teamId=${encodeURIComponent(slug)}`;
+    // Vercel also supports ?slug= but teamId is canonical; fallback to slug param
+    return '';
+}
+export function appendTeamQuery(url, teamId, slug) {
+    const q = buildTeamQuery(teamId, slug);
+    if (!q)
+        return url;
+    return url.includes('?') ? `${url}&${q}` : `${url}?${q}`;
+}
+export async function vercelFetch(path, opts) {
+    const method = opts.method || 'GET';
+    let url = `${VERCEL_API_BASE}${path}`;
+    const params = new URLSearchParams();
+    if (opts.query) {
+        for (const [k, v] of Object.entries(opts.query))
+            if (v)
+                params.set(k, v);
+    }
+    const teamQ = buildTeamQuery(opts.teamId, opts.slug);
+    if (teamQ)
+        params.append(teamQ.split('=')[0], teamQ.split('=')[1]);
+    const qs = params.toString();
+    if (qs)
+        url += (url.includes('?') ? '&' : '?') + qs;
+    const headers = {
+        Authorization: `Bearer ${opts.vercelToken}`,
+    };
+    let bodyStr;
+    if (opts.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        bodyStr = JSON.stringify(opts.body);
+    }
+    const res = await fetch(url, { method, headers, body: bodyStr });
+    const text = await res.text().catch(() => '');
+    let data;
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = text;
+    }
+    if (!res.ok)
+        return { ok: false, status: res.status, data, error: data };
+    return { ok: true, status: res.status, data };
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,169 @@
+export declare const vercelCreateDeployment: import("ai").Tool<{
+    name: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    files?: any[] | undefined;
+    slug?: string | undefined;
+    project?: string | undefined;
+    target?: string | undefined;
+    meta?: Record<string, any> | undefined;
+    forceNew?: string | undefined;
+    gitSource?: Record<string, any> | undefined;
+    gitMetadata?: Record<string, any> | undefined;
+    deploymentId?: string | undefined;
+    monorepoManager?: string | undefined;
+    projectSettings?: Record<string, any> | undefined;
+    withLatestCommit?: boolean | undefined;
+    customEnvironmentSlugOrId?: string | undefined;
+    skipAutoDetectionConfirmation?: string | undefined;
+}, unknown>;
+export declare const vercelCreateNewDeployment: import("ai").Tool<{
+    name: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    files?: Record<string, any>[] | undefined;
+    slug?: string | undefined;
+    project?: string | undefined;
+    target?: string | undefined;
+    meta?: Record<string, any> | undefined;
+    forceNew?: string | undefined;
+    gitSource?: Record<string, any> | undefined;
+    gitMetadata?: Record<string, any> | undefined;
+    deploymentId?: string | undefined;
+    projectSettings?: Record<string, any> | undefined;
+    skipAutoDetectionConfirmation?: string | undefined;
+}, unknown>;
+export declare const vercelDeleteDeployment: import("ai").Tool<{
+    id: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    url?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetDeployment: import("ai").Tool<{
+    vercelToken: string;
+    idOrUrl: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    withGitRepoInfo?: string | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentDetails: import("ai").Tool<{
+    vercelToken: string;
+    idOrUrl: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    withGitRepoInfo?: boolean | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentEvents: import("ai").Tool<{
+    vercelToken: string;
+    idOrUrl: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    follow?: number | undefined;
+    name?: string | undefined;
+    limit?: number | undefined;
+    direction?: string | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    statusCode?: string | undefined;
+    builds?: number | undefined;
+    delimiter?: number | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentEvents2: import("ai").Tool<{
+    vercelToken: string;
+    idOrUrl: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    follow?: number | undefined;
+    name?: string | undefined;
+    limit?: number | undefined;
+    direction?: string | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    statusCode?: string | undefined;
+    builds?: number | undefined;
+    delimiter?: number | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentFileContents: import("ai").Tool<{
+    id: string;
+    fileId: string;
+    vercelToken: string;
+    path?: string | undefined;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentLogs: import("ai").Tool<{
+    vercelToken: string;
+    idOrUrl: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    follow?: number | undefined;
+    limit?: number | undefined;
+    direction?: string | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    statusCode?: string | undefined;
+    builds?: number | undefined;
+}, unknown>;
+export declare const vercelGetDeploymentLogs2: import("ai").Tool<{
+    projectId: string;
+    vercelToken: string;
+    deploymentId: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    maxLogs?: number | undefined;
+}, unknown>;
+export declare const vercelGetDeployments: import("ai").Tool<{
+    vercelToken: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    projectId?: string | undefined;
+    from?: number | undefined;
+    to?: number | undefined;
+    limit?: number | undefined;
+    users?: string | undefined;
+    state?: string | undefined;
+    sha?: string | undefined;
+    branch?: string | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    target?: string | undefined;
+    app?: string | undefined;
+    projectIds?: string[] | undefined;
+    rollbackCandidate?: boolean | undefined;
+}, unknown>;
+export declare const vercelListAllDeployments: import("ai").Tool<{
+    vercelToken: string;
+    since?: number | undefined;
+    teamId?: string | undefined;
+    projectId?: string | undefined;
+    limit?: number | undefined;
+    users?: string | undefined;
+    state?: string | undefined;
+    sha?: string | undefined;
+    branch?: string | undefined;
+    until?: number | undefined;
+    slug?: string | undefined;
+    target?: string | undefined;
+    app?: string | undefined;
+    rollbackCandidate?: boolean | undefined;
+}, unknown>;
+export declare const vercelListDeploymentAliases: import("ai").Tool<{
+    id: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelListDeploymentChecks: import("ai").Tool<{
+    vercelToken: string;
+    deploymentId: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelListDeploymentFiles: import("ai").Tool<{
+    id: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=deployments.d.ts.map