@blueberrybytes/webmcp 0.1.0

package/dist/tool-manager.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * ToolManager - Utility class for managing WebMCP tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolManager = void 0;
+/**
+ * ToolManager provides utilities for registering and managing WebMCP tools
+ */
+class ToolManager {
+    constructor(modelContext) {
+        this.modelContext = modelContext;
+    }
+    /**
+     * Creates a new tool with the specified parameters
+     * @param name - The name of the tool
+     * @param description - The description of the tool
+     * @param execute - The execute function for the tool
+     * @param options - Additional options for the tool
+     * @returns The created tool
+     */
+    createTool(name, description, execute, options) {
+        return {
+            name,
+            description,
+            execute,
+            inputSchema: options?.inputSchema,
+            annotations: options?.annotations
+        };
+    }
+    /**
+     * Registers a tool with the model context
+     * @param tool - The tool to register
+     * @returns The registered tool
+     */
+    registerTool(tool) {
+        try {
+            this.modelContext.registerTool(tool);
+            return tool;
+        }
+        catch (error) {
+            throw new Error(`Failed to register tool '${tool.name}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Unregisters a tool from the model context
+     * @param name - The name of the tool to unregister
+     */
+    unregisterTool(name) {
+        this.modelContext.unregisterTool(name);
+    }
+    /**
+     * Gets a tool by name
+     * @param name - The name of the tool to retrieve
+     * @returns The tool or undefined if not found
+     */
+    getTool(name) {
+        return this.modelContext.getTool(name);
+    }
+    /**
+     * Gets all registered tools
+     * @returns Array of all registered tools
+     */
+    getAllTools() {
+        return this.modelContext.getAllTools();
+    }
+    /**
+     * Gets tools filtered by category
+     * @param category - The category to filter by
+     * @returns Array of tools in the specified category
+     */
+    getToolsByCategory(category) {
+        return this.modelContext.getToolsByCategory(category);
+    }
+    /**
+     * Gets tools filtered by tags
+     * @param tags - The tags to filter by
+     * @returns Array of tools with the specified tags
+     */
+    getToolsByTags(tags) {
+        return this.modelContext.getToolsByTags(tags);
+    }
+    /**
+     * Creates a tool with category annotation
+     * @param name - The name of the tool
+     * @param description - The description of the tool
+     * @param category - The category of the tool
+     * @param execute - The execute function for the tool
+     * @param options - Additional options for the tool
+     * @returns The created tool
+     */
+    createCategorizedTool(name, description, category, execute, options) {
+        return this.createTool(name, description, execute, {
+            inputSchema: options?.inputSchema,
+            annotations: {
+                category,
+                tags: options?.tags
+            }
+        });
+    }
+    /**
+     * Creates a tool with authentication requirements
+     * @param name - The name of the tool
+     * @param description - The description of the tool
+     * @param execute - The execute function for the tool
+     * @param options - Additional options for the tool
+     * @returns The created tool
+     */
+    createAuthenticatedTool(name, description, execute, options) {
+        return this.createTool(name, description, execute, {
+            inputSchema: options?.inputSchema,
+            annotations: {
+                requiresAuth: true,
+                scopes: options?.scopes,
+                tags: options?.tags
+            }
+        });
+    }
+    /**
+     * Creates a read-only tool
+     * @param name - The name of the tool
+     * @param description - The description of the tool
+     * @param execute - The execute function for the tool
+     * @param options - Additional options for the tool
+     * @returns The created tool
+     */
+    createReadOnlyTool(name, description, execute, options) {
+        return this.createTool(name, description, execute, {
+            inputSchema: options?.inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                tags: options?.tags
+            }
+        });
+    }
+    /**
+     * Batch registers multiple tools
+     * @param tools - Array of tools to register
+     * @returns Array of successfully registered tools
+     */
+    registerTools(tools) {
+        const registeredTools = [];
+        const errors = [];
+        for (const tool of tools) {
+            try {
+                this.registerTool(tool);
+                registeredTools.push(tool);
+            }
+            catch (error) {
+                errors.push(`Failed to register tool '${tool.name}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        if (errors.length > 0) {
+            console.warn('Tool registration completed with errors:', errors.join('\n'));
+        }
+        return registeredTools;
+    }
+    /**
+     * Validates a tool before registration
+     * @param tool - The tool to validate
+     * @returns True if the tool is valid, false otherwise
+     */
+    validateTool(tool) {
+        // Check required fields
+        if (!tool.name || typeof tool.name !== 'string') {
+            console.error('Tool must have a valid name');
+            return false;
+        }
+        if (!tool.description || typeof tool.description !== 'string') {
+            console.error(`Tool '${tool.name}' must have a valid description`);
+            return false;
+        }
+        if (!tool.execute || typeof tool.execute !== 'function') {
+            console.error(`Tool '${tool.name}' must have a valid execute function`);
+            return false;
+        }
+        // Validate input schema if provided
+        if (tool.inputSchema) {
+            if (typeof tool.inputSchema !== 'object' || tool.inputSchema === null) {
+                console.error(`Tool '${tool.name}' has an invalid input schema`);
+                return false;
+            }
+        }
+        // Validate annotations if provided
+        if (tool.annotations) {
+            if (typeof tool.annotations !== 'object' || tool.annotations === null) {
+                console.error(`Tool '${tool.name}' has invalid annotations`);
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.ToolManager = ToolManager;

package/dist/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * WebMCP Types - TypeScript definitions for the Web Model Context Protocol
+ */
+/**
+ * Represents an AI agent that can interact with WebMCP tools
+ */
+export interface ModelContextClient {
+    /**
+     * Asynchronously requests user input during the execution of a tool
+     * @param callback - Function to perform the user interaction
+     * @returns Promise that resolves with the result of the callback
+     */
+    requestUserInteraction<T>(callback: () => Promise<T>): Promise<T>;
+}
+/**
+ * JSON Schema for tool input validation
+ */
+export interface JSONSchema {
+    type: string;
+    properties?: Record<string, any>;
+    required?: string[];
+    [key: string]: any;
+}
+/**
+ * Annotations providing additional metadata about a tool's behavior
+ */
+export interface ToolAnnotations {
+    /**
+     * If true, indicates that the tool does not modify any state and only reads data
+     */
+    readOnlyHint?: boolean;
+    /**
+     * Tool category for organization and filtering
+     */
+    category?: string;
+    /**
+     * Tags for tool discovery and filtering
+     */
+    tags?: string[];
+    /**
+     * Authentication requirements for the tool
+     */
+    requiresAuth?: boolean;
+    /**
+     * Scopes required for tool execution
+     */
+    scopes?: string[];
+}
+/**
+ * Represents a tool that can be invoked by agents
+ */
+export interface ModelContextTool {
+    /**
+     * Unique identifier for the tool
+     */
+    name: string;
+    /**
+     * Natural language description of the tool's functionality
+     */
+    description: string;
+    /**
+     * JSON Schema describing the expected input parameters for the tool
+     */
+    inputSchema?: JSONSchema;
+    /**
+     * Callback function that is invoked when an agent calls the tool
+     * @param input - Input parameters for the tool
+     * @param client - ModelContextClient representing the agent
+     * @returns Promise that resolves with the tool result
+     */
+    execute: (input: Record<string, any>, client: ModelContextClient) => Promise<any>;
+    /**
+     * Optional annotations providing additional metadata about the tool's behavior
+     */
+    annotations?: ToolAnnotations;
+}
+/**
+ * Options for providing context to the ModelContext
+ */
+export interface ModelContextOptions {
+    /**
+     * List of tools to register with the browser
+     */
+    tools?: ModelContextTool[];
+}
+/**
+ * Content types supported in tool results
+ */
+export type ToolResultContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+    alt?: string;
+} | {
+    type: "html";
+    html: string;
+} | {
+    type: "link";
+    url: string;
+    title?: string;
+} | {
+    type: "table";
+    headers: string[];
+    rows: any[][];
+} | {
+    type: "error";
+    message: string;
+    code?: string;
+} | {
+    type: "resource";
+    uri: string;
+};
+/**
+ * Result returned by a tool execution
+ */
+export interface ToolResult {
+    content?: ToolResultContent[];
+    [key: string]: any;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * WebMCP Types - TypeScript definitions for the Web Model Context Protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@blueberrybytes/webmcp",
+  "version": "0.1.0",
+  "description": "TypeScript library for WebMCP - Web Model Context Protocol",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "test": "jest",
+    "prepublishOnly": "npm run build",
+    "pub": "npm publish --access public",
+    "pub:beta": "npm publish --access public --tag beta"
+  },
+  "keywords": [
+    "webmcp",
+    "mcp",
+    "ai",
+    "agent",
+    "tools",
+    "typescript"
+  ],
+  "author": "BlueberryBytes",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^18.0.0"
+  },
+  "dependencies": {
+    "json-rpc-2.0": "^1.0.0"
+  }
+}