@rnsk/toolkits 0.0.2 → 0.0.4

package/dist/runtime/meta-tools.d.ts

@@ -1,101 +0,0 @@
-import type { CredentialResolver, MetaToolHooks } from './credentials.js';
-import type { ToolRegistry } from './registry.js';
-export interface MetaToolsConfig {
-    registry: ToolRegistry;
-    credentials: CredentialResolver;
-    hooks?: MetaToolHooks;
-}
-export declare function createMetaTools({ registry, credentials, hooks }: MetaToolsConfig): {
-    searchTool: import("ai").Tool<{
-        pattern: string;
-        searchIn: "names" | "descriptions" | "both";
-    }, {
-        pattern: string;
-        searchIn: "names" | "descriptions" | "both";
-        matches: number;
-        tools: {
-            name: string;
-            description: string;
-            parameters: Record<string, unknown> | undefined;
-            requiredAuth: string | undefined;
-        }[];
-        error?: undefined;
-        message?: undefined;
-    } | {
-        error: string;
-        message: string;
-        pattern: string;
-        searchIn?: undefined;
-        matches?: undefined;
-        tools?: undefined;
-    }>;
-    checkAuthentication: import("ai").Tool<{
-        toolName: string;
-    }, {
-        error: string;
-        toolName: string;
-        availableTools: string[];
-        authenticated?: undefined;
-        reason?: undefined;
-        message?: undefined;
-        requiredAuth?: undefined;
-    } | {
-        authenticated: boolean;
-        toolName: string;
-        reason: string;
-        message: string | undefined;
-        error?: undefined;
-        availableTools?: undefined;
-        requiredAuth?: undefined;
-    } | {
-        authenticated: boolean;
-        toolName: string;
-        reason: string;
-        error?: undefined;
-        availableTools?: undefined;
-        message?: undefined;
-        requiredAuth?: undefined;
-    } | {
-        authenticated: boolean;
-        toolName: string;
-        requiredAuth: string;
-        reason: string;
-        error?: undefined;
-        availableTools?: undefined;
-        message?: undefined;
-    } | {
-        authenticated: boolean;
-        toolName: string;
-        error?: undefined;
-        availableTools?: undefined;
-        reason?: undefined;
-        message?: undefined;
-        requiredAuth?: undefined;
-    } | {
-        error: string;
-        toolName: string;
-        message: string;
-        availableTools?: undefined;
-        authenticated?: undefined;
-        reason?: undefined;
-        requiredAuth?: undefined;
-    }>;
-    initiateConnection: import("ai").Tool<{
-        provider: string;
-    }, {
-        link: string;
-        provider: string;
-        error?: undefined;
-        supportedProviders?: undefined;
-    } | {
-        error: string;
-        provider: string;
-        supportedProviders: string[];
-        link?: undefined;
-    }>;
-    executeTool: import("ai").Tool<{
-        args: Record<string, unknown>;
-        toolName: string;
-    }, Record<string, unknown>>;
-};
-//# sourceMappingURL=meta-tools.d.ts.map

package/dist/runtime/meta-tools.js

@@ -1,250 +0,0 @@
-import { tool } from 'ai';
-import { z } from 'zod';
-import { coerceArguments, extractParameterInfo, getToolInputZodSchema, resolveZodObjectShape, } from './schema-helpers.js';
-export function createMetaTools({ registry, credentials, hooks = {} }) {
-    const { checkToolPolicy, sanitizeToolResult = (r) => r, sanitizeToolPayload = (p) => p, isWebSearchEnabled = () => true, getAppUrl = () => process.env.APP_URL ?? 'http://localhost:3000', getProviderSlugs = () => [], isToolkitAvailable, } = hooks;
-    const searchTool = tool({
-        description: 'Search for available tools in the registry based on a regex pattern. Use this to discover tools that can help with a specific task. Returns detailed parameter information including types and descriptions.',
-        inputSchema: z.object({
-            pattern: z.string().describe('Regex pattern to search for in tool names and descriptions'),
-            searchIn: z
-                .enum(['names', 'descriptions', 'both'])
-                .optional()
-                .default('both')
-                .describe('Where to search: names, descriptions, or both'),
-        }),
-        execute: async ({ pattern, searchIn = 'both' }) => {
-            try {
-                const results = registry.search(pattern, searchIn);
-                return {
-                    pattern,
-                    searchIn,
-                    matches: results.length,
-                    tools: results.map((toolMetadata) => {
-                        const toolSchema = getToolInputZodSchema(toolMetadata.tool);
-                        const shape = resolveZodObjectShape(toolSchema);
-                        const parameters = {};
-                        if (shape) {
-                            for (const [paramName, paramSchema] of Object.entries(shape)) {
-                                parameters[paramName] = extractParameterInfo(paramSchema);
-                            }
-                        }
-                        return {
-                            name: toolMetadata.name,
-                            description: toolMetadata.description,
-                            parameters: Object.keys(parameters).length > 0 ? parameters : undefined,
-                            requiredAuth: toolMetadata.requiredAuth,
-                        };
-                    }),
-                };
-            }
-            catch (error) {
-                return {
-                    error: 'Failed to search tools',
-                    message: error instanceof Error ? error.message : 'Unknown error',
-                    pattern,
-                };
-            }
-        },
-    });
-    const checkAuthentication = tool({
-        description: 'Check whether the user is authenticated for a specific tool. Use this after searchTool when a tool has requiredAuth.',
-        inputSchema: z.object({
-            toolName: z.string().describe('Name of the tool to check authentication for'),
-        }),
-        execute: async ({ toolName }) => {
-            try {
-                const toolMetadata = registry.get(toolName);
-                if (!toolMetadata) {
-                    return {
-                        error: 'Tool not found',
-                        toolName,
-                        availableTools: registry.getToolNames(),
-                    };
-                }
-                if (isToolkitAvailable) {
-                    const availability = isToolkitAvailable(toolMetadata.toolkitId);
-                    if (!availability.available) {
-                        return {
-                            authenticated: false,
-                            toolName,
-                            reason: 'toolkit_unconfigured',
-                            message: availability.reason,
-                        };
-                    }
-                }
-                if (!toolMetadata.requiredAuth) {
-                    return {
-                        authenticated: true,
-                        toolName,
-                        reason: 'no_auth_required',
-                    };
-                }
-                const token = await credentials.getToken(toolMetadata.requiredAuth);
-                if (!token) {
-                    return {
-                        authenticated: false,
-                        toolName,
-                        requiredAuth: toolMetadata.requiredAuth,
-                        reason: 'token_missing',
-                    };
-                }
-                return {
-                    authenticated: true,
-                    toolName,
-                };
-            }
-            catch (error) {
-                return {
-                    error: 'Failed to check authentication',
-                    toolName,
-                    message: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
-    });
-    const initiateConnection = tool({
-        description: 'Get a link for the user to connect an external provider. Use when checkAuthentication returns not authenticated.',
-        inputSchema: z.object({
-            provider: z.string().describe('Provider to connect: e.g. "github" for githubToken'),
-        }),
-        execute: async ({ provider }) => {
-            const baseUrl = getAppUrl();
-            const slug = provider.toLowerCase().replace(/\s+/g, '-');
-            const supported = getProviderSlugs();
-            if (supported.includes(slug)) {
-                return {
-                    link: `${baseUrl}/auth/provider/${slug}`,
-                    provider: slug,
-                };
-            }
-            return {
-                error: 'Unknown provider',
-                provider,
-                supportedProviders: supported,
-            };
-        },
-    });
-    const executeTool = tool({
-        description: 'Execute any tool from the registry by providing its name and arguments. Use this after finding a suitable tool with searchTool.',
-        inputSchema: z.object({
-            toolName: z.string().describe('Name of the tool to execute'),
-            args: z.record(z.string(), z.unknown()).describe('Arguments to pass to the tool'),
-        }),
-        execute: async ({ toolName, args }) => {
-            try {
-                if ((toolName === 'webSearch' || toolName === 'webScrape') &&
-                    !isWebSearchEnabled()) {
-                    return {
-                        error: 'Web search is disabled',
-                        toolName,
-                        message: 'Firecrawl is turned off for this request.',
-                    };
-                }
-                if (checkToolPolicy) {
-                    const policy = checkToolPolicy(toolName);
-                    if (policy.allowed === false) {
-                        return {
-                            error: policy.error,
-                            toolName,
-                            reason: policy.reason,
-                        };
-                    }
-                }
-                const toolMetadata = registry.get(toolName);
-                if (!toolMetadata) {
-                    return {
-                        error: 'Tool not found',
-                        toolName,
-                        availableTools: registry.getToolNames(),
-                    };
-                }
-                if (isToolkitAvailable) {
-                    const availability = isToolkitAvailable(toolMetadata.toolkitId);
-                    if (!availability.available) {
-                        return {
-                            error: 'toolkit_unconfigured',
-                            toolName,
-                            toolkitId: toolMetadata.toolkitId,
-                            message: availability.reason ?? 'This toolkit is not configured on the server.',
-                        };
-                    }
-                }
-                const toolInstance = toolMetadata.tool;
-                const toolSchema = getToolInputZodSchema(toolMetadata.tool);
-                let authToken;
-                if (toolMetadata.requiredAuth) {
-                    const token = await credentials.getToken(toolMetadata.requiredAuth);
-                    if (!token) {
-                        return {
-                            error: 'Tool requires connection',
-                            toolName,
-                            requiredAuth: toolMetadata.requiredAuth,
-                            message: 'This tool requires a connected account. Use initiateConnection(provider) to get a link.',
-                        };
-                    }
-                    authToken = token;
-                }
-                const injectAuth = (payload) => {
-                    if (authToken != null && toolMetadata.requiredAuth) {
-                        return { ...payload, [toolMetadata.requiredAuth]: authToken };
-                    }
-                    return payload;
-                };
-                if (toolSchema) {
-                    try {
-                        const coercedArgs = coerceArguments(args, toolSchema);
-                        const parsedArgs = toolSchema.parse(coercedArgs);
-                        const argsWithToken = injectAuth(parsedArgs);
-                        const result = await toolInstance.execute(argsWithToken);
-                        return sanitizeToolPayload({
-                            toolName,
-                            toolkitId: toolMetadata.toolkitId,
-                            success: true,
-                            result: sanitizeToolResult(result),
-                        });
-                    }
-                    catch (validationError) {
-                        const shape = resolveZodObjectShape(toolSchema) ?? {};
-                        const paramDetails = {};
-                        for (const [paramName, paramSchema] of Object.entries(shape)) {
-                            paramDetails[paramName] = extractParameterInfo(paramSchema);
-                        }
-                        return {
-                            error: 'Invalid arguments for tool',
-                            toolName,
-                            message: validationError instanceof Error
-                                ? validationError.message
-                                : 'Schema validation failed',
-                            expectedParameters: paramDetails,
-                            providedParameters: Object.keys(args),
-                            providedValues: args,
-                        };
-                    }
-                }
-                const argsWithToken = injectAuth(args);
-                const result = await toolInstance.execute(argsWithToken);
-                return sanitizeToolPayload({
-                    toolName,
-                    toolkitId: toolMetadata.toolkitId,
-                    success: true,
-                    result: sanitizeToolResult(result),
-                });
-            }
-            catch (error) {
-                return {
-                    error: 'Failed to execute tool',
-                    toolName,
-                    message: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
-    });
-    return {
-        searchTool,
-        checkAuthentication,
-        initiateConnection,
-        executeTool,
-    };
-}
-//# sourceMappingURL=meta-tools.js.map

package/dist/runtime/registry.d.ts

@@ -1,20 +0,0 @@
-export interface ToolRegistryEntry {
-    name: string;
-    description: string;
-    tool: unknown;
-    requiredAuth?: string;
-    scope?: 'read' | 'write' | 'delete';
-    toolkitId: string;
-}
-export interface ToolRegistry {
-    register: (name: string, description: string, tool: unknown, options?: {
-        requiredAuth?: string;
-        scope?: 'read' | 'write' | 'delete';
-        toolkitId?: string;
-    }) => void;
-    get: (name: string) => ToolRegistryEntry | undefined;
-    getToolNames: () => string[];
-    search: (pattern: string, searchIn?: 'names' | 'descriptions' | 'both') => ToolRegistryEntry[];
-}
-export declare function createToolRegistry(): ToolRegistry;
-//# sourceMappingURL=registry.d.ts.map

package/dist/runtime/registry.js

@@ -1,35 +0,0 @@
-export function createToolRegistry() {
-    const tools = new Map();
-    return {
-        register(name, description, tool, options) {
-            if (tools.has(name)) {
-                throw new Error(`Duplicate tool registration: "${name}"`);
-            }
-            tools.set(name, {
-                name,
-                description,
-                tool,
-                requiredAuth: options?.requiredAuth,
-                scope: options?.scope ?? 'read',
-                toolkitId: options?.toolkitId ?? 'unknown',
-            });
-        },
-        get(name) {
-            return tools.get(name);
-        },
-        getToolNames() {
-            return Array.from(tools.keys());
-        },
-        search(pattern, searchIn = 'both') {
-            const regex = new RegExp(pattern, 'i');
-            return Array.from(tools.values()).filter((entry) => {
-                if (searchIn === 'names')
-                    return regex.test(entry.name);
-                if (searchIn === 'descriptions')
-                    return regex.test(entry.description);
-                return regex.test(entry.name) || regex.test(entry.description);
-            });
-        },
-    };
-}
-//# sourceMappingURL=registry.js.map