@rnsk/toolkits 0.0.7 → 0.0.9

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

@@ -0,0 +1,38 @@
+export declare const slackStartCall: import("ai").Tool<{
+    externalUniqueId: string;
+    joinUrl: string;
+    title?: string | undefined;
+    users?: string | undefined;
+    slackToken?: string | undefined;
+    createdBy?: string | undefined;
+    dateStart?: number | undefined;
+    externalDisplayId?: string | undefined;
+    desktopAppJoinUrl?: string | undefined;
+}, any>;
+export declare const slackGetCallInfo: import("ai").Tool<{
+    id: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUpdateCallInfo: import("ai").Tool<{
+    id: string;
+    title?: string | undefined;
+    slackToken?: string | undefined;
+    joinUrl?: string | undefined;
+    desktopAppJoinUrl?: string | undefined;
+}, any>;
+export declare const slackEndCall: import("ai").Tool<{
+    id: string;
+    duration?: number | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackAddCallParticipants: import("ai").Tool<{
+    id: string;
+    users: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRemoveCallParticipants: import("ai").Tool<{
+    id: string;
+    users: string;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=calls.d.ts.map

package/dist/toolkits/slack/tools/calls.js

@@ -0,0 +1,141 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackStartCall = tool({
+    description: 'Register a third-party call in Slack (calls.add). Requires a provider join_url and unique external_unique_id. Returns the Slack call ID for later updates.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        externalUniqueId: z.string().describe('Provider-unique call ID'),
+        joinUrl: z.string().describe('Web join URL (third-party, not a Slack URL)'),
+        title: z.string().optional().describe('Call title shown in Slack'),
+        users: z.string().optional().describe('JSON array of participants, e.g. [{"slack_id":"U123"}]'),
+        createdBy: z.string().optional().describe('Creator user ID (required without a user token)'),
+        dateStart: z.number().optional().describe('Start time as UTC Unix timestamp'),
+        externalDisplayId: z.string().optional().describe('Human-friendly meeting label, e.g. CONF-7890'),
+        desktopAppJoinUrl: z.string().optional().describe('Deep link to launch the calling app'),
+    }),
+    execute: async ({ slackToken, externalUniqueId, joinUrl, title, users, createdBy, dateStart, externalDisplayId, desktopAppJoinUrl }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.add', {
+                external_unique_id: externalUniqueId,
+                join_url: joinUrl,
+                title,
+                users,
+                created_by: createdBy,
+                date_start: dateStart,
+                external_display_id: externalDisplayId,
+                desktop_app_join_url: desktopAppJoinUrl,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to start call');
+        }
+    },
+});
+export const slackGetCallInfo = tool({
+    description: 'Get a point-in-time snapshot of a call by its Slack call ID (from slackStartCall).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID, e.g. R1234567890'),
+    }),
+    execute: async ({ slackToken, id }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.info', { id });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get call info');
+        }
+    },
+});
+export const slackUpdateCallInfo = tool({
+    description: 'Update the title, join URL, or desktop app URL of an existing call by ID.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to update'),
+        title: z.string().optional().describe('New call title'),
+        joinUrl: z.string().optional().describe('New web join URL'),
+        desktopAppJoinUrl: z.string().optional().describe('New desktop app deep link'),
+    }),
+    execute: async ({ slackToken, id, title, joinUrl, desktopAppJoinUrl }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.update', {
+                id,
+                title,
+                join_url: joinUrl,
+                desktop_app_join_url: desktopAppJoinUrl,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update call');
+        }
+    },
+});
+export const slackEndCall = tool({
+    description: 'End an ongoing call by ID, optionally recording its duration in seconds.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to end'),
+        duration: z.number().optional().describe('Call duration in seconds'),
+    }),
+    execute: async ({ slackToken, id, duration }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.end', { id, duration });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to end call');
+        }
+    },
+});
+export const slackAddCallParticipants = tool({
+    description: 'Add participants to an ongoing call. Users is a JSON array string of {"slack_id":"U..."} objects.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID from slackStartCall'),
+        users: z.string().describe('JSON array, e.g. [{"slack_id":"U1H77"},{"slack_id":"U2ABC123"}]'),
+    }),
+    execute: async ({ slackToken, id, users }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.participants.add', { id, users });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add call participants');
+        }
+    },
+});
+export const slackRemoveCallParticipants = tool({
+    description: 'Remove participants from an ongoing call. Users is a JSON array string with slack_id and/or external_id per user.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to update'),
+        users: z.string().describe('JSON array, e.g. [{"slack_id":"U1H77"}]'),
+    }),
+    execute: async ({ slackToken, id, users }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.participants.remove', { id, users });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove call participants');
+        }
+    },
+});
+//# sourceMappingURL=calls.js.map

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

@@ -0,0 +1,24 @@
+export declare const slackCreateCanvas: import("ai").Tool<{
+    title?: string | undefined;
+    channelId?: string | undefined;
+    slackToken?: string | undefined;
+    documentContent?: Record<string, any> | undefined;
+}, any>;
+export declare const slackEditCanvas: import("ai").Tool<{
+    operation: "delete" | "replace" | "insert_after" | "insert_before" | "insert_at_start" | "insert_at_end" | "rename";
+    canvasId: string;
+    slackToken?: string | undefined;
+    documentContent?: Record<string, any> | undefined;
+    sectionId?: string | undefined;
+    titleContent?: Record<string, any> | undefined;
+}, any>;
+export declare const slackDeleteCanvas: import("ai").Tool<{
+    canvasId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackLookupCanvasSections: import("ai").Tool<{
+    criteria: Record<string, any>;
+    canvasId: string;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/toolkits/slack/tools/canvas.js

@@ -0,0 +1,102 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackCreateCanvas = tool({
+    description: 'Create a Canvas with an optional title, markdown content, and channel tab. Returns the canvas_id.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        title: z.string().optional().describe('Canvas title (Slack defaults when omitted)'),
+        documentContent: z.record(z.any()).optional().describe('Initial content, e.g. {type:"markdown",markdown:"# Hi"}'),
+        channelId: z.string().optional().describe('Channel ID to add the canvas as a tab to'),
+    }),
+    execute: async ({ slackToken, title, documentContent, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.create', {
+                title,
+                document_content: documentContent,
+                channel_id: channelId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create canvas');
+        }
+    },
+});
+export const slackEditCanvas = tool({
+    description: 'Edit a Canvas: replace whole content or a section, insert before/after/at start/at end, delete a section, or rename. Use slackLookupCanvasSections to find section IDs for targeted edits.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID, e.g. F01234ABCDE'),
+        operation: z
+            .enum(['replace', 'insert_after', 'insert_before', 'insert_at_start', 'insert_at_end', 'delete', 'rename'])
+            .optional()
+            .default('replace')
+            .describe('Edit operation'),
+        sectionId: z.string().optional().describe('Target section (required for insert_after/before and delete)'),
+        documentContent: z.record(z.any()).optional().describe('Content in Slack document format (not for delete/rename)'),
+        titleContent: z.record(z.any()).optional().describe('New title in markdown format (rename only)'),
+    }),
+    execute: async ({ slackToken, canvasId, operation = 'replace', sectionId, documentContent, titleContent }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.edit', {
+                canvas_id: canvasId,
+                operation,
+                section_id: sectionId,
+                document_content: documentContent,
+                title_content: titleContent,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to edit canvas');
+        }
+    },
+});
+export const slackDeleteCanvas = tool({
+    description: 'Permanently delete a Canvas. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID to delete'),
+    }),
+    execute: async ({ slackToken, canvasId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.delete', { canvas_id: canvasId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete canvas');
+        }
+    },
+});
+export const slackLookupCanvasSections = tool({
+    description: 'Find section IDs in a Canvas by text criteria. Use the returned IDs with slackEditCanvas targeted operations.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        canvasId: z.string().describe('Canvas ID to search, e.g. F01234ABCDE'),
+        criteria: z.record(z.any()).describe('Search criteria, e.g. {contains_text:"Roadmap"}'),
+    }),
+    execute: async ({ slackToken, canvasId, criteria }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'canvases.sections.lookup', {
+                canvas_id: canvasId,
+                criteria,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to look up canvas sections');
+        }
+    },
+});
+//# sourceMappingURL=canvas.js.map

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

@@ -0,0 +1,22 @@
+export declare class SlackApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+/** Call a Slack Web API method. Throws SlackApiError when ok === false. */
+export declare function slackApi(slackToken: string, method: string, params?: Record<string, unknown>): Promise<any>;
+/** GET helper for non-Web-API hosts (Audit Logs, SCIM). */
+export declare function slackGet(slackToken: string, url: string, query?: Record<string, string | number | boolean | undefined>): Promise<any>;
+export declare function toSlackError(error: unknown, label: string): {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+};
+export declare function requireToken(slackToken: string | undefined): {
+    error: string;
+} | null;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,73 @@
+// @ts-nocheck
+const API_BASE = 'https://slack.com/api';
+export class SlackApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+function toForm(params) {
+    const form = new URLSearchParams();
+    if (!params)
+        return form;
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined)
+            continue;
+        form.set(key, typeof value === 'string' ? value : JSON.stringify(value));
+    }
+    return form;
+}
+/** Call a Slack Web API method. Throws SlackApiError when ok === false. */
+export async function slackApi(slackToken, method, params) {
+    const response = await fetch(`${API_BASE}/${method}`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${slackToken}`,
+            'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+        },
+        body: toForm(params).toString(),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.ok === false) {
+        throw new SlackApiError(`Slack ${method} failed${data?.error ? `: ${data.error}` : ''}`, response.status, data);
+    }
+    return data;
+}
+/** GET helper for non-Web-API hosts (Audit Logs, SCIM). */
+export async function slackGet(slackToken, url, query) {
+    const u = new URL(url);
+    if (query) {
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined)
+                continue;
+            u.searchParams.set(key, String(value));
+        }
+    }
+    const response = await fetch(u.toString(), {
+        headers: { Authorization: `Bearer ${slackToken}` },
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.ok === false) {
+        throw new SlackApiError(`Slack request failed${data?.error ? `: ${data.error}` : ''}`, response.status, data);
+    }
+    return data;
+}
+export function toSlackError(error, label) {
+    if (error?.details !== undefined) {
+        return { error: label, details: error.details };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+export function requireToken(slackToken) {
+    if (!slackToken) {
+        return { error: 'Slack token is required. Connect Slack first.' };
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,131 @@
+export declare const slackListAllChannels: import("ai").Tool<{
+    types?: string | undefined;
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    excludeArchived?: boolean | undefined;
+}, any>;
+export declare const slackFindChannels: import("ai").Tool<{
+    query: string;
+    types: string;
+    limit: number;
+    excludeArchived: boolean;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    exactMatch?: boolean | undefined;
+    memberOnly?: boolean | undefined;
+}, {
+    error: string;
+} | {
+    ok: boolean;
+    channels: any;
+    total_channels_searched: any;
+}>;
+export declare const slackListConversations: import("ai").Tool<{
+    types?: string | undefined;
+    teamId?: string | undefined;
+    user?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    excludeArchived?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationInfo: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+    includeNumMembers?: boolean | undefined;
+    includeLocale?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationMembers: import("ai").Tool<{
+    channel: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetConversationHistory: import("ai").Tool<{
+    limit: number;
+    channel: string;
+    inclusive?: boolean | undefined;
+    latest?: string | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: string | undefined;
+    includeAllMetadata?: boolean | undefined;
+}, any>;
+export declare const slackGetConversationReplies: import("ai").Tool<{
+    channel: string;
+    ts: string;
+    inclusive?: boolean | undefined;
+    limit?: number | undefined;
+    latest?: string | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: string | undefined;
+    includeAllMetadata?: boolean | undefined;
+}, any>;
+export declare const slackCreateChannel: import("ai").Tool<{
+    name: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    isPrivate?: boolean | undefined;
+}, any>;
+export declare const slackArchiveChannel: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUnarchiveChannel: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackCloseDm: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackJoinConversation: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackLeaveConversation: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRenameConversation: import("ai").Tool<{
+    name: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetConversationTopic: import("ai").Tool<{
+    channel: string;
+    topic: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetConversationPurpose: import("ai").Tool<{
+    channel: string;
+    purpose: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackMarkConversationRead: import("ai").Tool<{
+    channel: string;
+    ts: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackInviteUsersToChannel: import("ai").Tool<{
+    users: string;
+    channel: string;
+    force?: boolean | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRemoveUserFromConversation: import("ai").Tool<{
+    user: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackOpenDm: import("ai").Tool<{
+    users?: string | undefined;
+    channel?: string | undefined;
+    slackToken?: string | undefined;
+    returnIm?: boolean | undefined;
+    preventCreation?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=conversations.d.ts.map