@rnsk/toolkits 0.0.3 → 0.0.4

package/dist/runtime/credentials.d.ts

@@ -1,28 +0,0 @@
-import type { ToolkitManifest } from '../core/types.js';
-import type { ToolRegistry } from './registry.js';
-export interface CredentialResolver {
-    getToken: (tokenField: string) => Promise<string | null>;
-    getServiceEnv: (envName: string) => string | undefined;
-}
-export interface MetaToolPolicyResult {
-    allowed: boolean;
-    error?: string;
-    reason?: string;
-}
-export interface MetaToolHooks {
-    checkToolPolicy?: (toolName: string) => MetaToolPolicyResult;
-    sanitizeToolResult?: (result: unknown) => unknown;
-    sanitizeToolPayload?: (payload: Record<string, unknown>) => Record<string, unknown>;
-    isWebSearchEnabled?: () => boolean;
-    getAppUrl?: () => string;
-    getProviderSlugs?: () => string[];
-    isToolkitAvailable?: (toolkitId: string) => {
-        available: boolean;
-        reason?: string;
-    };
-}
-export declare function registerAllToolsFromManifests(registry: ToolRegistry, manifests: ToolkitManifest[], options?: {
-    skipUnavailable?: boolean;
-    isToolkitAvailable?: (id: string) => boolean;
-}): void;
-//# sourceMappingURL=credentials.d.ts.map

package/dist/runtime/credentials.js

@@ -1,15 +0,0 @@
-export function registerAllToolsFromManifests(registry, manifests, options) {
-    for (const manifest of manifests) {
-        if (options?.skipUnavailable && options.isToolkitAvailable && !options.isToolkitAvailable(manifest.id)) {
-            continue;
-        }
-        for (const toolDef of manifest.tools) {
-            registry.register(toolDef.name, toolDef.description ?? toolDef.tool.description ?? '', toolDef.tool, {
-                requiredAuth: toolDef.requiredAuth,
-                scope: toolDef.scope,
-                toolkitId: manifest.id,
-            });
-        }
-    }
-}
-//# sourceMappingURL=credentials.js.map

package/dist/runtime/index.d.ts

@@ -1,5 +0,0 @@
-export { getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, TOOL_OUTPUT_JSON_SCHEMA, type ParameterInfo, } from './schema-helpers.js';
-export { createToolRegistry, type ToolRegistry, type ToolRegistryEntry } from './registry.js';
-export { registerAllToolsFromManifests, type CredentialResolver, type MetaToolHooks, type MetaToolPolicyResult, } from './credentials.js';
-export { createMetaTools } from './meta-tools.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -1,5 +0,0 @@
-export { getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, TOOL_OUTPUT_JSON_SCHEMA, } from './schema-helpers.js';
-export { createToolRegistry } from './registry.js';
-export { registerAllToolsFromManifests, } from './credentials.js';
-export { createMetaTools } from './meta-tools.js';
-//# sourceMappingURL=index.js.map

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

package/dist/runtime/schema-helpers.d.ts

@@ -1,20 +0,0 @@
-export declare const TOOL_OUTPUT_JSON_SCHEMA: Record<string, unknown>;
-export declare function getToolInputZodSchema(tool: any): any | null;
-export declare function resolveZodObjectShape(schema: {
-    shape?: Record<string, unknown>;
-    _def?: {
-        shape?: Record<string, unknown> | (() => Record<string, unknown>);
-    };
-} | null | undefined): Record<string, unknown> | null;
-export declare function toolInputToJsonSchema(tool: any, requiredAuth?: string): Record<string, unknown>;
-export interface ParameterInfo {
-    type: string;
-    required: boolean;
-    description?: string;
-    itemType?: string;
-    options?: string[];
-    values?: string[];
-}
-export declare function extractParameterInfo(zodType: any): ParameterInfo | Record<string, unknown>;
-export declare function coerceArguments(args: Record<string, unknown>, schema: any): Record<string, unknown>;
-//# sourceMappingURL=schema-helpers.d.ts.map

package/dist/runtime/schema-helpers.js

@@ -1,157 +0,0 @@
-import { zodToJsonSchema } from 'zod-to-json-schema';
-export const TOOL_OUTPUT_JSON_SCHEMA = {
-    type: 'object',
-    description: 'JSON object returned by the tool. May include result data or an error field.',
-    additionalProperties: true,
-};
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getToolInputZodSchema(tool) {
-    if (!tool || typeof tool !== 'object')
-        return null;
-    return tool.inputSchema ?? tool._def?.parameters ?? null;
-}
-export function resolveZodObjectShape(schema) {
-    if (!schema)
-        return null;
-    if (schema.shape)
-        return schema.shape;
-    const defShape = schema._def?.shape;
-    if (typeof defShape === 'function')
-        return defShape();
-    if (defShape && typeof defShape === 'object')
-        return defShape;
-    return null;
-}
-function flattenJsonSchema(schema) {
-    if (schema.$ref && typeof schema.$ref === 'string' && schema.definitions) {
-        const refName = schema.$ref.replace('#/definitions/', '');
-        const definitions = schema.definitions;
-        const resolved = definitions[refName];
-        if (resolved) {
-            return {
-                ...resolved,
-                ...(schema.$schema ? { $schema: schema.$schema } : {}),
-            };
-        }
-    }
-    return schema;
-}
-function stripAuthFromJsonSchema(schema, requiredAuth) {
-    const properties = schema.properties;
-    if (!properties)
-        return schema;
-    const filtered = { ...properties };
-    for (const key of Object.keys(filtered)) {
-        if (key === requiredAuth || key.endsWith('Token')) {
-            delete filtered[key];
-        }
-    }
-    const required = Array.isArray(schema.required)
-        ? schema.required.filter((key) => key !== requiredAuth && !key.endsWith('Token'))
-        : undefined;
-    return {
-        ...schema,
-        properties: filtered,
-        ...(required && required.length > 0 ? { required } : {}),
-    };
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function toolInputToJsonSchema(tool, requiredAuth) {
-    const zodSchema = getToolInputZodSchema(tool);
-    if (!zodSchema) {
-        return { type: 'object', properties: {} };
-    }
-    const jsonSchema = zodToJsonSchema(zodSchema, {
-        $refStrategy: 'none',
-    });
-    return stripAuthFromJsonSchema(flattenJsonSchema(jsonSchema), requiredAuth);
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function extractParameterInfo(zodType) {
-    const typeName = zodType._def?.typeName;
-    const info = {
-        type: typeName?.replace('Zod', '').toLowerCase() || 'unknown',
-        required: !(zodType?.isOptional?.() ?? false),
-        description: zodType.description || undefined,
-    };
-    switch (typeName) {
-        case 'ZodNumber':
-            info.type = 'number';
-            break;
-        case 'ZodString':
-            info.type = 'string';
-            break;
-        case 'ZodBoolean':
-            info.type = 'boolean';
-            break;
-        case 'ZodArray':
-            info.type = 'array';
-            info.itemType = extractParameterInfo(zodType._def.type).type;
-            break;
-        case 'ZodObject':
-            info.type = 'object';
-            break;
-        case 'ZodUnion':
-            info.type = 'union';
-            info.options =
-                zodType._def.options?.map(
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                (opt) => extractParameterInfo(opt).type) || [];
-            break;
-        case 'ZodEnum':
-            info.type = 'enum';
-            info.values = zodType._def.values || [];
-            break;
-        case 'ZodOptional': {
-            const innerInfo = extractParameterInfo(zodType._def.innerType);
-            return { ...innerInfo, required: false };
-        }
-        default:
-            info.type = typeName?.replace('Zod', '').toLowerCase() || 'any';
-    }
-    return info;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function coerceArguments(args, schema) {
-    const shape = resolveZodObjectShape(schema);
-    if (!shape)
-        return args;
-    const coercedArgs = {};
-    for (const [key, value] of Object.entries(args)) {
-        const fieldSchema = shape[key];
-        if (!fieldSchema) {
-            coercedArgs[key] = value;
-            continue;
-        }
-        let typeName = fieldSchema._def?.typeName;
-        let actualSchema = fieldSchema;
-        if (typeName === 'ZodOptional') {
-            actualSchema = fieldSchema._def?.innerType;
-            typeName = actualSchema?._def?.typeName;
-        }
-        try {
-            switch (typeName) {
-                case 'ZodNumber':
-                    coercedArgs[key] = typeof value === 'string' ? parseFloat(value) : Number(value);
-                    break;
-                case 'ZodString':
-                    coercedArgs[key] = String(value);
-                    break;
-                case 'ZodBoolean':
-                    coercedArgs[key] =
-                        typeof value === 'string' ? value.toLowerCase() === 'true' : Boolean(value);
-                    break;
-                case 'ZodArray':
-                    coercedArgs[key] = Array.isArray(value) ? value : [value];
-                    break;
-                default:
-                    coercedArgs[key] = value;
-            }
-        }
-        catch {
-            coercedArgs[key] = value;
-        }
-    }
-    return coercedArgs;
-}
-//# sourceMappingURL=schema-helpers.js.map