@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,144 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelGetTeam = tool({
+    description: 'Retrieves detailed information about a specific Vercel team by its ID or slug. Returns comprehensive team metadata including billing, membership, resource configuration, and settings. Use this to get team details before performing team-specific operations. The teamId parameter accepts either a team ID (e.g., \'team_xxx\') or team slug (e.g., \'my-team\').',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        slug: z.string().optional().describe('Optional team slug to scope the request. Used for authorization when accessing team-specific resources.'),
+        teamId: z.string().describe('The Team identifier or slug to retrieve information for. Can be either a team ID (e.g., \'team_RcupkAQdr25D0qQu2MmPu6Th\') or a team slug (e.g., \'my-team\').'),
+    }),
+    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/teams/${p.teamId}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Team Details failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetTeam', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetTeams = tool({
+    description: 'Tool to list all teams accessible to the authenticated user with detailed information. Use when you need comprehensive team data including membership, configuration, and settings.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        limit: z.number().optional().describe('Maximum number of Teams which may be returned.'),
+        since: z.number().optional().describe('Timestamp (in milliseconds) to only include Teams created since then.'),
+        until: z.number().optional().describe('Timestamp (in milliseconds) to only include Teams created until then.'),
+    }),
+    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/teams`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get All Teams failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetTeams', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelListTeamMembers = tool({
+    description: 'Tool to list all members of a Vercel team. Use when you need to retrieve team member information, check team access permissions, or audit team membership.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        role: z.string().optional().describe('Only return members with the specified team role.'),
+        limit: z.number().optional().describe('Maximum number of team members to return per request.'),
+        since: z.number().optional().describe('Timestamp in milliseconds to only include members added since then.'),
+        until: z.number().optional().describe('Timestamp in milliseconds to only include members added until then.'),
+        search: z.string().optional().describe('Search team members by their name, username, and email.'),
+        teamId: z.string().describe('The team\'s unique identifier. Required to specify which team\'s members to list.'),
+        excludeProject: z.string().optional().describe('Exclude members who belong to the specified project.'),
+        eligibleMembersForProjectId: z.string().optional().describe('Include team members who are eligible to be members of the specified project.'),
+    }),
+    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/teams/${p.teamId}/members`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Team Members failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelListTeamMembers', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelListTeams = tool({
+    description: 'DEPRECATED: Use VERCEL_VERCEL_GET_TEAMS instead. Tool to list all teams accessible to the authenticated user. Use after authentication to retrieve team IDs and slugs; resolve the correct teamId or slug here before passing it to other Vercel tools (e.g., VERCEL_GET_PROJECT, deployment queries) — an incorrect or missing teamId causes 404 or scoping errors.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        limit: z.number().optional().describe('Maximum number of teams to return (max 100)'),
+        since: z.number().optional().describe('Timestamp in milliseconds; include teams created since this time'),
+        until: z.number().optional().describe('Timestamp in milliseconds; include teams created until this time'),
+    }),
+    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/teams`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'List All Teams (Deprecated) failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelListTeams', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelUpdateTeam = tool({
+    description: 'Tool to update a Vercel team\'s configuration. Use when you need to modify team settings like name, description, security policies, or deployment settings.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        name: z.string().optional().describe('The name of the team.'),
+        saml: z.record(z.any()).optional().describe('SAML configuration for the team.'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        avatar: z.string().optional().describe('The hash value of an uploaded image.'),
+        teamId: z.string().describe('The Team identifier to perform the request on behalf of.'),
+        newSlug: z.string().optional().describe('A new slug for the team.'),
+        description: z.string().optional().describe('A short text that describes the team.'),
+        emailDomain: z.string().optional().describe('Email domain for the team.'),
+        remoteCaching: z.record(z.any()).optional().describe('Whether or not remote caching is enabled for the team'),
+        hideIpAddresses: z.boolean().optional().describe('Display or hide IP addresses in Monitoring queries.'),
+        regenerateInviteCode: z.boolean().optional().describe('Create a new invite code and replace the current one.'),
+        enablePreviewFeedback: z.string().optional().describe('Enable preview toolbar: one of on, off or default.'),
+        previewDeploymentSuffix: z.string().optional().describe('Suffix that will be used for all preview deployments.'),
+        enableProductionFeedback: z.string().optional().describe('Enable production toolbar: one of on, off or default.'),
+        defaultExpirationSettings: z.record(z.any()).optional().describe('Default deployment expiration settings for new projects.'),
+        hideIpAddressesInLogDrains: z.boolean().optional().describe('Display or hide IP addresses in Log Drains.'),
+        defaultDeploymentProtection: z.record(z.any()).optional().describe('Default deployment protection settings for new projects.'),
+        sensitiveEnvironmentVariablePolicy: z.string().optional().describe('Sensitive environment variable policy: one of on, off or default.'),
+    }),
+    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/teams/${p.teamId}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'PATCH', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Update Team failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelUpdateTeam', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=teams.js.map

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

@@ -0,0 +1,27 @@
+export declare const vercelCreateWebhook: import("ai").Tool<{
+    url: string;
+    events: ("deployment" | "budget.reached" | "domain.created" | "domain.dns.records.changed" | "domain.transfer-in.started" | "domain.transfer-in.completed" | "domain.transfer-in.failed" | "domain.certificate.add" | "domain.certificate.add.failed" | "domain.certificate.renew" | "domain.certificate.renew.failed" | "domain.certificate.deleted" | "domain.renewal" | "domain.renewal.failed" | "domain.auto-renew.changed" | "deployment.created" | "deployment.cleanup" | "deployment.error" | "deployment.canceled" | "deployment.succeeded" | "deployment.ready" | "deployment.check-rerequested" | "deployment.promoted" | "deployment.integration.action.start" | "deployment.integration.action.cancel" | "deployment.integration.action.cleanup" | "deployment.checkrun.start" | "deployment.checkrun.cancel" | "edge-config.created" | "edge-config.deleted" | "edge-config.items.updated" | "firewall.attack" | "firewall.system-rule-anomaly" | "firewall.custom-rule-anomaly" | "alerts.triggered" | "integration-configuration.permission-upgraded" | "integration-configuration.removed" | "integration-configuration.scope-change-confirmed" | "integration-configuration.transferred" | "integration-resource.project-connected" | "integration-resource.project-disconnected" | "project.created" | "project.removed" | "project.renamed" | "project.domain.created" | "project.domain.updated" | "project.domain.deleted" | "project.domain.verified" | "project.domain.unverified" | "project.domain.moved" | "project.rolling-release.started" | "project.rolling-release.aborted" | "project.rolling-release.completed" | "project.rolling-release.approved" | "deployment.checks.failed" | "deployment.checks.succeeded" | "deployment-checks-completed" | "deployment-ready" | "deployment-prepared" | "deployment-error" | "deployment-check-rerequested" | "deployment-canceled" | "project-created" | "project-removed" | "domain-created" | "integration-configuration-permission-updated" | "integration-configuration-removed" | "integration-configuration-scope-change-confirmed" | "marketplace.member.changed" | "marketplace.invoice.created" | "marketplace.invoice.paid" | "marketplace.invoice.notpaid" | "marketplace.invoice.refunded" | "observability.anomaly" | "observability.anomaly-error" | "observability.usage-anomaly" | "observability.error-anomaly" | "botid.anomaly" | "test-webhook")[];
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    projectIds?: string[] | undefined;
+}, unknown>;
+export declare const vercelDeleteWebhook: import("ai").Tool<{
+    id: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelGetWebhook: import("ai").Tool<{
+    id: string;
+    vercelToken: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+export declare const vercelListWebhooks: import("ai").Tool<{
+    vercelToken: string;
+    teamId?: string | undefined;
+    projectId?: string | undefined;
+    slug?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=webhooks.d.ts.map

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

@@ -0,0 +1,103 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { vercelFetch } from './client.js';
+export const vercelCreateWebhook = tool({
+    description: 'Tool to create a webhook for receiving notifications about Vercel events. Use when you need to set up automated responses to deployment, domain, project, or other Vercel events.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        url: z.string().describe('The URL to call when the webhook is triggered. Must start with http:// or https://'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of.'),
+        events: z.array(z.enum(['budget.reached', 'domain.created', 'domain.dns.records.changed', 'domain.transfer-in.started', 'domain.transfer-in.completed', 'domain.transfer-in.failed', 'domain.certificate.add', 'domain.certificate.add.failed', 'domain.certificate.renew', 'domain.certificate.renew.failed', 'domain.certificate.deleted', 'domain.renewal', 'domain.renewal.failed', 'domain.auto-renew.changed', 'deployment.created', 'deployment.cleanup', 'deployment.error', 'deployment.canceled', 'deployment.succeeded', 'deployment.ready', 'deployment.check-rerequested', 'deployment.promoted', 'deployment.integration.action.start', 'deployment.integration.action.cancel', 'deployment.integration.action.cleanup', 'deployment.checkrun.start', 'deployment.checkrun.cancel', 'edge-config.created', 'edge-config.deleted', 'edge-config.items.updated', 'firewall.attack', 'firewall.system-rule-anomaly', 'firewall.custom-rule-anomaly', 'alerts.triggered', 'integration-configuration.permission-upgraded', 'integration-configuration.removed', 'integration-configuration.scope-change-confirmed', 'integration-configuration.transferred', 'integration-resource.project-connected', 'integration-resource.project-disconnected', 'project.created', 'project.removed', 'project.renamed', 'project.domain.created', 'project.domain.updated', 'project.domain.deleted', 'project.domain.verified', 'project.domain.unverified', 'project.domain.moved', 'project.rolling-release.started', 'project.rolling-release.aborted', 'project.rolling-release.completed', 'project.rolling-release.approved', 'deployment.checks.failed', 'deployment.checks.succeeded', 'deployment-checks-completed', 'deployment-ready', 'deployment-prepared', 'deployment-error', 'deployment-check-rerequested', 'deployment-canceled', 'project-created', 'project-removed', 'domain-created', 'deployment', 'integration-configuration-permission-updated', 'integration-configuration-removed', 'integration-configuration-scope-change-confirmed', 'marketplace.member.changed', 'marketplace.invoice.created', 'marketplace.invoice.paid', 'marketplace.invoice.notpaid', 'marketplace.invoice.refunded', 'observability.anomaly', 'observability.anomaly-error', 'observability.usage-anomaly', 'observability.error-anomaly', 'botid.anomaly', 'test-webhook'])).describe('List of event types that should trigger this webhook. At least one event is required.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of.'),
+        projectIds: z.array(z.string()).optional().describe('Optional list of project IDs to scope the webhook to specific projects. Minimum 1, maximum 50 project IDs. Each project ID must contain only alphanumeric characters and underscores.'),
+    }),
+    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/webhooks`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'POST', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Create Webhook failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelCreateWebhook', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelDeleteWebhook = tool({
+    description: 'Delete a webhook by its unique ID to stop receiving event notifications. This action permanently removes the webhook configuration. Use VERCEL_GET_WEBHOOKS to find webhook IDs if needed. The deletion is idempotent - deleting an already deleted webhook returns a 404 error.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        id: z.string().describe('The unique identifier of the webhook to delete.'),
+        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/webhooks/${p.id}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'DELETE', teamId, slug, body: rest, query: undefined });
+            if (!res.ok)
+                return { error: 'Delete Vercel Webhook failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelDeleteWebhook', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelGetWebhook = tool({
+    description: 'Tool to retrieve details of a specific webhook by ID. Use when you need to inspect webhook configuration, events, or metadata.',
+    inputSchema: z.object({
+        vercelToken: z.string().describe('Vercel access token (Bearer).'),
+        id: z.string().describe('The unique identifier of the webhook to retrieve (e.g., \'account_hook_v3dYzpfkptKPBE483PIHvN0y\')'),
+        slug: z.string().optional().describe('The Team slug to perform the request on behalf of. Alternative to team_id.'),
+        teamId: z.string().optional().describe('The Team identifier to perform the request on behalf of. Required when accessing team webhooks.'),
+    }),
+    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/webhooks/${p.id}`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get Webhook failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelGetWebhook', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+export const vercelListWebhooks = tool({
+    description: 'Tool to retrieve a list of all webhooks for the authenticated account or team. Use this to discover configured webhooks and their event subscriptions.',
+    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.'),
+        projectId: z.string().optional().describe('Filter webhooks by 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/webhooks`; })();
+            const res = await vercelFetch(path, { vercelToken, method: 'GET', teamId, slug, body: undefined, query: rest });
+            if (!res.ok)
+                return { error: 'Get List of Webhooks failed', details: res.data };
+            return res.data;
+        }
+        catch (e) {
+            return { error: 'Error in vercelListWebhooks', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=webhooks.js.map

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

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

package/dist/toolkits/wise/icon.js

@@ -0,0 +1,15 @@
+const SVG = `<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 51.1 48.6" style="enable-background:new 0 0 51.1 48.6;" xml:space="preserve">
+ <style type="text/css">
+  .st0{fill:#163300;}
+ </style>
+ <metadata></metadata>
+ <g>
+  <path class="st0" d="M13.8,14.6L0,30.8h24.7l2.8-7.6H16.9l6.5-7.5l0-0.2l-4.2-7.2h18.9L23.4,48.6h10L51.1,0H5.4L13.8,14.6&#xA;&#x9;&#x9;L13.8,14.6z">
+  </path>
+ </g>
+</svg>`;
+export const WISE_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,30 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { WISE_ICON } from './icon.js';
+import { wiseTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'wise',
+    displayName: 'Wise',
+    shortDescription: 'Quotes, transfers, balances, recipients and exchange rates.',
+    category: 'Finance & Accounting',
+    icon: WISE_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'wiseApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect Wise with an API token. Create one at https://api.transferwise.com/oauth/applications (or sandbox https://api.sandbox.transferwise.tech) with at least transfer permissions. The token is sent as Authorization: Bearer <token>.',
+        },
+    },
+    allowedHosts: ['api.transferwise.com', 'api.wise.com', 'api.sandbox.transferwise.tech'],
+    tools: wiseTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: { since: '0.0.1' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/wise/tools/create-quote.d.ts

@@ -0,0 +1,86 @@
+export declare const wiseCreateQuote: import("ai").Tool<{
+    profileId: number;
+    sourceCurrency: string;
+    targetCurrency: string;
+    wiseApiKey?: string | undefined;
+    sourceAmount?: number | undefined;
+    targetAmount?: number | undefined;
+    preferredPayIn?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    quoteId?: undefined;
+    profileId?: undefined;
+    status?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    sourceAmount?: undefined;
+    targetAmount?: undefined;
+    rate?: undefined;
+    rateType?: undefined;
+    createdAt?: undefined;
+    rateExpiresAt?: undefined;
+    quoteExpiresAt?: undefined;
+    paymentOptions?: undefined;
+    notices?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    quoteId?: undefined;
+    profileId?: undefined;
+    status?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    sourceAmount?: undefined;
+    targetAmount?: undefined;
+    rate?: undefined;
+    rateType?: undefined;
+    createdAt?: undefined;
+    rateExpiresAt?: undefined;
+    quoteExpiresAt?: undefined;
+    paymentOptions?: undefined;
+    notices?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    quoteId: any;
+    profileId: any;
+    status: any;
+    sourceCurrency: any;
+    targetCurrency: any;
+    sourceAmount: any;
+    targetAmount: any;
+    rate: any;
+    rateType: any;
+    createdAt: any;
+    rateExpiresAt: any;
+    quoteExpiresAt: any;
+    paymentOptions: any;
+    notices: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    quoteId?: undefined;
+    profileId?: undefined;
+    status?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    sourceAmount?: undefined;
+    targetAmount?: undefined;
+    rate?: undefined;
+    rateType?: undefined;
+    createdAt?: undefined;
+    rateExpiresAt?: undefined;
+    quoteExpiresAt?: undefined;
+    paymentOptions?: undefined;
+    notices?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=create-quote.d.ts.map

package/dist/toolkits/wise/tools/create-quote.js

@@ -0,0 +1,64 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wiseFetch } from './utils.js';
+export const wiseCreateQuote = tool({
+    description: 'Create a transient Wise bank-transfer quote for a personal or business profile. The quote expires; this tool does not create or fund a transfer and does not move money.',
+    inputSchema: z.object({
+        wiseApiKey: z.string().optional().describe('Wise API token (Bearer). Injected via manifest.'),
+        profileId: z.number().describe('Wise profile ID from WISE_LIST_PROFILES; PERSONAL profiles are supported.'),
+        sourceCurrency: z.string().length(3).describe('Three-letter ISO currency code being sent, such as USD.'),
+        targetCurrency: z.string().length(3).describe('Three-letter ISO currency code being received, such as EUR.'),
+        sourceAmount: z.number().positive().optional().describe('Amount to send in sourceCurrency. Provide exactly one of sourceAmount or targetAmount.'),
+        targetAmount: z.number().positive().optional().describe('Amount the recipient should receive in targetCurrency. Provide exactly one of sourceAmount or targetAmount.'),
+        preferredPayIn: z.string().optional().describe('Pay-in method for this toolkit; BANK_TRANSFER is the live-verified option.'),
+    }),
+    execute: async ({ wiseApiKey, profileId, sourceCurrency, targetCurrency, sourceAmount, targetAmount, preferredPayIn }) => {
+        if (!wiseApiKey)
+            return { error: 'Wise API key is required. Connect Wise first.' };
+        if (!sourceAmount && !targetAmount)
+            return { error: 'Provide exactly one of sourceAmount or targetAmount.' };
+        if (sourceAmount && targetAmount)
+            return { error: 'Provide only one of sourceAmount or targetAmount, not both.' };
+        try {
+            const body = {
+                sourceCurrency,
+                targetCurrency,
+                preferredPayIn: preferredPayIn ?? 'BANK_TRANSFER',
+            };
+            if (sourceAmount !== undefined)
+                body.sourceAmount = sourceAmount;
+            if (targetAmount !== undefined)
+                body.targetAmount = targetAmount;
+            const res = await wiseFetch(`/v3/profiles/${profileId}/quotes`, {
+                wiseApiKey,
+                method: 'POST',
+                body,
+            });
+            if (!res.ok)
+                return { error: 'Failed to create quote', details: res.data };
+            const d = res.data;
+            return {
+                quoteId: d.id ?? d.quoteId,
+                profileId: d.profile ?? profileId,
+                status: d.status,
+                sourceCurrency: d.sourceCurrency,
+                targetCurrency: d.targetCurrency,
+                sourceAmount: d.sourceAmount,
+                targetAmount: d.targetAmount,
+                rate: d.rate,
+                rateType: d.rateType,
+                createdAt: d.createdTime ?? d.createdAt,
+                rateExpiresAt: d.rateExpirationTime ?? d.rateExpiresAt,
+                quoteExpiresAt: d.expirationTime ?? d.quoteExpiresAt ?? d.expiration,
+                paymentOptions: d.paymentOptions,
+                notices: d.notices,
+                raw: d,
+            };
+        }
+        catch (e) {
+            return { error: 'Error creating quote', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=create-quote.js.map

package/dist/toolkits/wise/tools/get-exchange-rate.d.ts

@@ -0,0 +1,42 @@
+export declare const wiseGetExchangeRate: import("ai").Tool<{
+    sourceCurrency: string;
+    targetCurrency: string;
+    wiseApiKey?: string | undefined;
+}, {
+    error: string;
+    details?: undefined;
+    rate?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    observedAt?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    rate?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    observedAt?: undefined;
+    raw?: undefined;
+    message?: undefined;
+} | {
+    rate: any;
+    sourceCurrency: any;
+    targetCurrency: any;
+    observedAt: any;
+    raw: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    rate?: undefined;
+    sourceCurrency?: undefined;
+    targetCurrency?: undefined;
+    observedAt?: undefined;
+    raw?: undefined;
+}>;
+//# sourceMappingURL=get-exchange-rate.d.ts.map

package/dist/toolkits/wise/tools/get-exchange-rate.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { wiseFetch } from './utils.js';
+export const wiseGetExchangeRate = tool({
+    description: "Get Wise's latest exchange rate for one source and target currency pair; this is an indicative rate, not a transfer quote.",
+    inputSchema: z.object({
+        wiseApiKey: z.string().optional().describe('Wise API token (Bearer).'),
+        sourceCurrency: z.string().length(3).describe('Three-letter ISO currency code to convert from, such as USD.'),
+        targetCurrency: z.string().length(3).describe('Three-letter ISO currency code to convert to, such as EUR.'),
+    }),
+    execute: async ({ wiseApiKey, sourceCurrency, targetCurrency }) => {
+        if (!wiseApiKey)
+            return { error: 'Wise API key is required. Connect Wise first.' };
+        try {
+            const res = await wiseFetch('/v1/rates', {
+                wiseApiKey,
+                method: 'GET',
+                query: {
+                    source: sourceCurrency,
+                    target: targetCurrency,
+                },
+            });
+            if (!res.ok)
+                return { error: 'Failed to get exchange rate', details: res.data };
+            const data = res.data;
+            // Wise returns array like [{ source, target, rate, time }] or single object
+            const rateObj = Array.isArray(data) ? data[0] : data;
+            if (!rateObj)
+                return { error: 'No rate returned', details: data };
+            return {
+                rate: rateObj.rate,
+                sourceCurrency: rateObj.source ?? sourceCurrency,
+                targetCurrency: rateObj.target ?? targetCurrency,
+                observedAt: rateObj.time ?? rateObj.observedAt ?? new Date().toISOString(),
+                raw: data,
+            };
+        }
+        catch (e) {
+            return { error: 'Error getting exchange rate', message: e instanceof Error ? e.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=get-exchange-rate.js.map