@rnsk/toolkits 0.0.10 → 0.0.11

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

@@ -1,8 +1,8 @@
 export declare const slackAddEnterpriseUserToWorkspace: import("ai").Tool<{
     teamId: string;
     userId: string;
-    slackToken?: string | undefined;
     channelIds?: string | undefined;
+    slackToken?: string | undefined;
     isRestricted?: boolean | undefined;
     isUltraRestricted?: boolean | undefined;
 }, any>;

package/dist/toolkits/slack/tools/slack-lists.d.ts

@@ -1,8 +1,8 @@
 export declare const slackCreateList: import("ai").Tool<{
     name: string;
+    schema?: Record<string, any>[] | undefined;
     slackToken?: string | undefined;
     descriptionBlocks?: string | Record<string, any> | Record<string, any>[] | undefined;
-    schema?: Record<string, any>[] | undefined;
     todoMode?: boolean | undefined;
     copyFromListId?: string | undefined;
     includeCopiedListRecords?: boolean | undefined;
@@ -52,14 +52,14 @@ export declare const slackDeleteListItems: import("ai").Tool<{
 export declare const slackSetListAccess: import("ai").Tool<{
     listId: string;
     accessLevel: string;
+    channelIds?: string[] | undefined;
     slackToken?: string | undefined;
     userIds?: string[] | undefined;
-    channelIds?: string[] | undefined;
 }, any>;
 export declare const slackDeleteListAccess: import("ai").Tool<{
     listId: string;
+    channelIds?: string[] | undefined;
     slackToken?: string | undefined;
     userIds?: string[] | undefined;
-    channelIds?: string[] | undefined;
 }, any>;
 //# sourceMappingURL=slack-lists.d.ts.map

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

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

package/dist/toolkits/snowflake/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" fill="#29b5e8"><path d="M9.86 15.298l13.008 7.8a3.72 3.72 0 0 0 4.589-.601 4.01 4.01 0 0 0 1.227-2.908V3.956a3.81 3.81 0 0 0-1.861-3.42 3.81 3.81 0 0 0-3.893 0 3.81 3.81 0 0 0-1.861 3.42v8.896l-7.387-4.43a3.79 3.79 0 0 0-2.922-.4c-.986.265-1.818.94-2.3 1.844-1.057 1.9-.44 4.28 1.4 5.422m31.27 7.8l13.008-7.8c1.84-1.143 2.458-3.533 1.4-5.424a3.75 3.75 0 0 0-5.22-1.452l-7.3 4.37v-8.84a3.81 3.81 0 1 0-7.615 0v15.323a4.08 4.08 0 0 0 .494 2.367c.482.903 1.314 1.57 2.3 1.844a3.71 3.71 0 0 0 2.922-.4M29.552 31.97c.013-.25.108-.5.272-.68l1.52-1.58a1.06 1.06 0 0 1 .658-.282h.057a1.05 1.05 0 0 1 .656.282l1.52 1.58a1.12 1.12 0 0 1 .272.681v.06a1.13 1.13 0 0 1-.272.683l-1.52 1.58a1.04 1.04 0 0 1-.656.284h-.057c-.246-.014-.48-.115-.658-.284l-1.52-1.58a1.13 1.13 0 0 1-.272-.683zm-4.604-.65v1.364a1.54 1.54 0 0 0 .372.93l5.16 5.357a1.42 1.42 0 0 0 .895.386h1.312a1.42 1.42 0 0 0 .895-.386l5.16-5.357a1.54 1.54 0 0 0 .372-.93V31.32a1.54 1.54 0 0 0-.372-.93l-5.16-5.357a1.42 1.42 0 0 0-.895-.386h-1.312a1.42 1.42 0 0 0-.895.386L25.32 30.4a1.55 1.55 0 0 0-.372.93M3.13 27.62l7.365 4.417L3.13 36.45a4.06 4.06 0 0 0-1.399 5.424 3.75 3.75 0 0 0 2.3 1.844c.986.274 2.042.133 2.922-.392l13.008-7.8c1.2-.762 1.9-2.078 1.9-3.492a4.16 4.16 0 0 0-1.9-3.492l-13.008-7.8a3.79 3.79 0 0 0-2.922-.4c-.986.265-1.818.94-2.3 1.844-1.057 1.9-.44 4.278 1.4 5.422m38.995 4.442a4 4 0 0 0 1.91 3.477l13 7.8c.88.524 1.934.666 2.92.392s1.817-.94 2.3-1.843a4.05 4.05 0 0 0-1.4-5.424L53.5 32.038l7.365-4.417c1.84-1.143 2.457-3.53 1.4-5.422a3.74 3.74 0 0 0-2.3-1.844c-.987-.274-2.042-.134-2.92.4l-13 7.8a4 4 0 0 0-1.91 3.507M25.48 40.508a3.7 3.7 0 0 0-2.611.464l-13.008 7.8c-1.84 1.143-2.456 3.53-1.4 5.422.483.903 1.314 1.57 2.3 1.843a3.75 3.75 0 0 0 2.922-.392l7.387-4.43v8.83a3.81 3.81 0 1 0 7.614 0V44.4a3.91 3.91 0 0 0-3.205-3.903m28.66 8.276l-13.008-7.8a3.75 3.75 0 0 0-2.922-.392 3.74 3.74 0 0 0-2.3 1.843 4.09 4.09 0 0 0-.494 2.37v15.25a3.81 3.81 0 1 0 7.614 0V51.28l7.287 4.37a3.79 3.79 0 0 0 2.922.4c.986-.265 1.818-.94 2.3-1.844 1.057-1.9.44-4.28-1.4-5.422"/></svg>`;
+export const SNOWFLAKE_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,32 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { SNOWFLAKE_ICON } from './icon.js';
+import { snowflakeTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'snowflake',
+    displayName: 'Snowflake',
+    shortDescription: 'Execute SQL, browse catalog objects, and check service status.',
+    category: 'Developer Tools & DevOps',
+    icon: SNOWFLAKE_ICON,
+    auth: {
+        type: 'service_account',
+        tokenField: 'snowflakeCredentials',
+        provider: {
+            fields: ['accountHost', 'token'],
+            connectDescription: 'Connect Snowflake with your account host (e.g. org-account, a full host, or https URL) and an access token. The token is sent as Authorization: Bearer on the SQL API v2. Use an OAuth access token from your Snowflake OAuth integration (recommended), a programmatic access token (PAT), or a key-pair JWT. OAuth authorize/token URLs are account-specific, so paste a token rather than an OAuth client flow. Status-page tools are public and need no credentials.',
+        },
+    },
+    tools: snowflakeTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.10',
+        homepage: 'https://www.snowflake.com',
+        docsUrl: 'https://docs.snowflake.com/en/developer-guide/sql-api/intro',
+    },
+});
+//# sourceMappingURL=manifest.js.map

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

@@ -0,0 +1,56 @@
+export declare const showDatabases: import("ai").Tool<{
+    limit?: number | undefined;
+    timeout?: number | undefined;
+    startsWith?: string | undefined;
+    role?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    warehouse?: string | undefined;
+    terse?: boolean | undefined;
+    history?: boolean | undefined;
+    likePattern?: string | undefined;
+    fromName?: string | undefined;
+}, any>;
+export declare const showSchemas: import("ai").Tool<{
+    limit?: number | undefined;
+    timeout?: number | undefined;
+    startsWith?: string | undefined;
+    role?: string | undefined;
+    database?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    warehouse?: string | undefined;
+    terse?: boolean | undefined;
+    history?: boolean | undefined;
+    likePattern?: string | undefined;
+    fromName?: string | undefined;
+    inScope?: string | undefined;
+}, any>;
+export declare const showTables: import("ai").Tool<{
+    limit?: number | undefined;
+    timeout?: number | undefined;
+    startsWith?: string | undefined;
+    role?: string | undefined;
+    database?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    warehouse?: string | undefined;
+    terse?: boolean | undefined;
+    history?: boolean | undefined;
+    likePattern?: string | undefined;
+    fromName?: string | undefined;
+    inScope?: string | undefined;
+    schema?: string | undefined;
+}, any>;
+export declare const dropWarehouse: import("ai").Tool<{
+    name: string;
+    timeout?: number | undefined;
+    role?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    ifExists?: boolean | undefined;
+}, any>;
+export declare const fetchCatalogIntegration: import("ai").Tool<{
+    name: string;
+    timeout?: number | undefined;
+    role?: string | undefined;
+    snowflakeCredentials?: string | undefined;
+    warehouse?: string | undefined;
+}, any>;
+//# sourceMappingURL=catalog.d.ts.map

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

@@ -0,0 +1,123 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildShow, parseCredentials, quoteIdent, snowflakeCredentialsField, submitStatement } from './client.js';
+const showContext = {
+    role: z.string().optional().describe('Role for the SHOW statement'),
+    warehouse: z.string().optional().describe('Warehouse (SHOW works without a running warehouse)'),
+    timeout: z.number().int().optional().describe('Timeout seconds'),
+};
+const showFilters = {
+    terse: z.boolean().optional().describe('Subset of columns only'),
+    history: z.boolean().optional().describe('Include dropped objects within Time Travel retention'),
+    likePattern: z.string().optional().describe("SQL wildcard filter (% and _), e.g. '%test%' (case-insensitive)"),
+    startsWith: z.string().optional().describe("Prefix filter, e.g. 'PROD' (case-sensitive)"),
+    limit: z.number().int().min(1).max(10000).optional().describe('Max rows (<= 10000)'),
+    fromName: z.string().optional().describe('With limit: start pagination at names matching this string'),
+};
+export const showDatabases = tool({
+    description: 'Lists accessible databases (name, created date, owner, retention). Supports LIKE/prefix filters, history, and limit/from pagination.',
+    inputSchema: z.object({ snowflakeCredentials: snowflakeCredentialsField, ...showContext, ...showFilters }),
+    execute: async ({ snowflakeCredentials, terse, history, likePattern, startsWith, limit, fromName, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        return submitStatement(creds, { statement: buildShow('DATABASES', undefined, { terse, history, likePattern, startsWith, limit, fromName }), ...ctx }, 'show databases');
+    },
+});
+export const showSchemas = tool({
+    description: 'Lists accessible schemas (name, database, owner, retention). Scope via in_scope: ACCOUNT, DATABASE (+database), or a database name.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        database: z.string().optional().describe('Database context (used with in_scope DATABASE)'),
+        inScope: z.string().optional().describe("Scope: 'ACCOUNT', 'DATABASE', or a database name"),
+        ...showContext,
+        ...showFilters,
+    }),
+    execute: async ({ snowflakeCredentials, database, inScope, terse, history, likePattern, startsWith, limit, fromName, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        let scope;
+        if (inScope) {
+            const upper = inScope.toUpperCase();
+            if (upper === 'ACCOUNT')
+                scope = 'IN ACCOUNT';
+            else if (upper === 'DATABASE')
+                scope = database ? `IN DATABASE ${quoteIdent(database)}` : 'IN DATABASE';
+            else
+                scope = `IN DATABASE ${quoteIdent(inScope)}`;
+        }
+        else if (database) {
+            scope = `IN DATABASE ${quoteIdent(database)}`;
+        }
+        return submitStatement(creds, { statement: buildShow('SCHEMAS', scope, { terse, history, likePattern, startsWith, limit, fromName }), database, ...ctx }, 'show schemas');
+    },
+});
+export const showTables = tool({
+    description: 'Lists accessible tables (rows, bytes, clustering, retention). Scope with database/schema or in_scope; supports LIKE/prefix/history/pagination.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        database: z.string().optional().describe('Database context'),
+        schema: z.string().optional().describe('Schema context (with database → IN SCHEMA db.schema)'),
+        inScope: z.string().optional().describe("Scope: 'ACCOUNT', 'DATABASE', 'SCHEMA', or a qualified name"),
+        ...showContext,
+        ...showFilters,
+    }),
+    execute: async ({ snowflakeCredentials, database, schema, inScope, terse, history, likePattern, startsWith, limit, fromName, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        let scope;
+        if (database && schema)
+            scope = `IN SCHEMA ${quoteIdent(database)}.${quoteIdent(schema)}`;
+        else if (inScope) {
+            const upper = inScope.toUpperCase();
+            if (upper === 'ACCOUNT')
+                scope = 'IN ACCOUNT';
+            else if (upper === 'DATABASE')
+                scope = database ? `IN DATABASE ${quoteIdent(database)}` : 'IN DATABASE';
+            else if (upper === 'SCHEMA')
+                scope = database && schema ? `IN SCHEMA ${quoteIdent(database)}.${quoteIdent(schema)}` : 'IN SCHEMA';
+            else
+                scope = `IN ${inScope}`;
+        }
+        else if (database) {
+            scope = `IN DATABASE ${quoteIdent(database)}`;
+        }
+        return submitStatement(creds, { statement: buildShow('TABLES', scope, { terse, history, likePattern, startsWith, limit, fromName }), database, schema, ...ctx }, 'show tables');
+    },
+});
+export const dropWarehouse = tool({
+    description: 'Permanently drops a warehouse (irreversible). Requires appropriate privileges; use if_exists to skip errors when absent.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        name: z.string().describe('Warehouse name to drop'),
+        ifExists: z.boolean().optional().describe('Skip error when the warehouse does not exist'),
+        role: z.string().optional(),
+        timeout: z.number().int().optional(),
+    }),
+    execute: async ({ snowflakeCredentials, name, ifExists, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        return submitStatement(creds, { statement: `DROP WAREHOUSE ${ifExists ? 'IF EXISTS ' : ''}${quoteIdent(name)}`, ...ctx }, 'drop warehouse');
+    },
+});
+export const fetchCatalogIntegration = tool({
+    description: 'Describes a catalog integration (Iceberg: AWS Glue, Open Catalog/Polaris, REST) — configuration and metadata.',
+    inputSchema: z.object({
+        snowflakeCredentials: snowflakeCredentialsField,
+        name: z.string().describe('Catalog integration name'),
+        role: z.string().optional(),
+        warehouse: z.string().optional(),
+        timeout: z.number().int().optional(),
+    }),
+    execute: async ({ snowflakeCredentials, name, ...ctx }) => {
+        const creds = parseCredentials(snowflakeCredentials);
+        if (creds?.error)
+            return creds;
+        return submitStatement(creds, { statement: `DESCRIBE CATALOG INTEGRATION ${quoteIdent(name)}`, ...ctx }, 'describe catalog integration');
+    },
+});
+//# sourceMappingURL=catalog.js.map

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const STATUSPAGE_BASE = "https://status.snowflake.com/api/v2";
+/** Credential JSON: { accountHost, token }. Token is an OAuth access token (or PAT / key-pair JWT). */
+export interface SnowflakeCredentials {
+    accountHost: string;
+    token: string;
+}
+export declare const snowflakeCredentialsField: z.ZodOptional<z.ZodString>;
+export declare function missingCredentials(): {
+    error: string;
+};
+export declare function parseCredentials(raw: string | undefined): SnowflakeCredentials | {
+    error: string;
+};
+/** Normalize account host: accepts bare locator, full host, or URL. */
+export declare function normalizeHost(accountHost: string): string;
+export interface SnowflakeRequestOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    /** Idempotency key sent as requestId for statement submission. */
+    requestId?: string;
+}
+export declare function snowflakeSqlApi(creds: SnowflakeCredentials, path: string, options?: SnowflakeRequestOptions): Promise<any>;
+/** Submit a statement (sync by default) and return the raw API response. */
+export declare function submitStatement(creds: SnowflakeCredentials, input: {
+    statement: string;
+    role?: string;
+    warehouse?: string;
+    database?: string;
+    schema?: string;
+    timeout?: number;
+    bindings?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+    async?: boolean;
+    requestId?: string;
+}, action?: string): Promise<any>;
+declare function quoteIdent(value: string): string;
+declare function quoteLiteral(value: string): string;
+export interface ShowOptions {
+    terse?: boolean;
+    history?: boolean;
+    likePattern?: string;
+    startsWith?: string;
+    limit?: number;
+    fromName?: string;
+}
+/** Build SHOW <objects> SQL from common filter options. */
+export declare function buildShow(objects: 'DATABASES' | 'SCHEMAS' | 'TABLES', scope: string | undefined, opts: ShowOptions): string;
+export { quoteIdent, quoteLiteral };
+/** Public Snowflake status page (Statuspage API, no auth). */
+export declare function statusPage(path: string, action?: string): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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