npm - @mcp-b/global - Versions diffs - 1.0.5 → 1.0.6 - Mend

@mcp-b/global 1.0.5 → 1.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -3,450 +3,427 @@
 [![npm version](https://img.shields.io/npm/v/@mcp-b/global?style=flat-square)](https://www.npmjs.com/package/@mcp-b/global)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-**Add AI superpowers to any website with just one script tag!**
+**Empower your website with AI capabilities using a single script tag!**
-The `@mcp-b/global` package provides the simplest way to integrate MCP-B (Model Context Protocol for Browsers) into any website. No build tools, no complex setup - just add a script tag and start exposing AI tools.
+The `@mcp-b/global` package offers the easiest way to integrate MCP-B (Model Context Protocol for Browsers) into any website. It requires no build tools or complex configuration—just add a script tag to expose AI tools that leverage your site's existing functionality.
 ## ✨ Features
-- 🚀 **Zero Configuration** - Works immediately in any browser
-- 🏷️ **Script Tag Ready** - Perfect for CDN usage via unpkg
-- 🔧 **Global API** - Automatically creates `window.mcp` when loaded
-- 📦 **Multiple Formats** - Supports ESM, CommonJS, and UMD
-- 🎯 **TypeScript Support** - Full type definitions included
-- 🌐 **Framework Agnostic** - Works with vanilla JS, React, Vue, or any framework
+- 🚀 **Zero-Config Setup**: Works instantly in any modern browser.
+- 🏷️ **Script Tag Integration**: Ideal for CDN deployment via unpkg or similar services.
+- 🔧 **Global API Exposure**: Automatically creates `window.mcp` upon loading.
+- 📦 **Multi-Format Support**: Compatible with ESM, CommonJS, and UMD.
+- 🎯 **TypeScript-Ready**: Includes comprehensive type definitions.
+- 🌐 **Framework-Agnostic**: Seamlessly integrates with vanilla JS, React, Vue, Angular, or any other framework.
 ## 🚀 Quick Start
-### Option 1: Script Tag (Recommended)
+### Option 1: Script Tag (Easiest)
-The easiest way to get started - just add this to your HTML:
+Add this to your HTML for instant integration:
 ```html
 <!DOCTYPE html>
-<html>
-<head>
-  <title>My AI-Powered Website</title>
-</head>
-<body>
-  <h1>Hello World</h1>
-  <!-- The magic script tag -->
-  <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.js"></script>
-  <!-- Your app code -->
-  <script>
-    // Wait for MCP to initialize, then register tools
-    function setupAI() {
-      if (!window.mcp?.registerTool) {
-        setTimeout(setupAI, 100);
-        return;
-      }
-      // Register your first AI tool
-      window.mcp.registerTool('getPageInfo', {
-        title: 'Get Page Information',
-        description: 'Get information about the current page'
-      }, async () => {
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              title: document.title,
-              url: window.location.href,
-              timestamp: new Date().toISOString()
-            })
-          }]
-        };
-      });
+<html lang="en">
+  <head>
+    <title>My AI-Enabled Site</title>
+  </head>
+  <body>
+    <h1>Welcome</h1>
+    <!-- Load MCP-B via CDN -->
+    <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.js"></script>
+    <!-- Your custom script -->
+    <script>
+      // Wait for MCP to initialize
+      function initMCP() {
+        if (!window.mcp?.registerTool) {
+          return setTimeout(initMCP, 100);
+        }
-      console.log('🎉 AI tools ready!');
-    }
+        // Register a simple tool
+        window.mcp.registerTool(
+          "getPageDetails",
+          {
+            title: "Retrieve Page Details",
+            description: "Fetches information about the current webpage",
+          },
+          async () => {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    title: document.title,
+                    url: window.location.href,
+                    timestamp: new Date().toISOString(),
+                  }),
+                },
+              ],
+            };
+          }
+        );
+        console.log("AI tools initialized!");
+      }
-    // Start setup when page loads
-    document.addEventListener('DOMContentLoaded', setupAI);
-  </script>
-</body>
+      // Run on page load
+      document.addEventListener("DOMContentLoaded", initMCP);
+    </script>
+  </body>
 </html>
 ```
-### Option 2: npm Install
+### Option 2: NPM Installation (For Advanced Control)
-For TypeScript projects or when you need more control:
+For projects using module bundlers or TypeScript:
 ```bash
-npm install @mcp-b/global
+npm install @mcp-b/global zod
 ```
 ```typescript
-import '@mcp-b/global'; // For global type declarations
-import { z } from 'zod';
-// or
-import { initializeGlobalMCP } from '@mcp-b/global';
+import { initializeGlobalMCP } from "@mcp-b/global";
+import { z } from "zod";
-// Initialize MCP manually
+// Initialize the global MCP instance
 initializeGlobalMCP();
-// Wait for initialization then register tools
-function setupMCP() {
+// Wait for readiness and register tools
+function initMCP() {
   if (!window.mcp?.registerTool) {
-    setTimeout(setupMCP, 100);
-    return;
+    return setTimeout(initMCP, 100);
   }
-  window.mcp.registerTool('myTool', {
-    title: 'My Custom Tool',
-    description: 'Does something useful',
-    inputSchema: {
-      message: z.string().describe('Message to process')
+  window.mcp.registerTool(
+    "processMessage",
+    {
+      title: "Process User Message",
+      description: "Handles and responds to a message",
+      inputSchema: {
+        message: z.string().describe("The message to process"),
+      },
+    },
+    async ({ message }) => {
+      return {
+        content: [{ type: "text", text: `Processed: ${message}` }],
+      };
     }
-  }, async ({ message }) => {
-    return { content: [{ type: 'text', text: `Tool executed with: ${message}` }] };
-  });
+  );
 }
-setupMCP();
+initMCP();
 ```
 ## 🛠️ API Reference
-### Global Object
+### Global Interface
-When loaded, the package automatically creates `window.mcp` with the following interface:
+Loading the package attaches `mcp` to the window object:
 ```typescript
 interface Window {
-  mcp: McpServer; // The global MCP server instance
+  mcp: McpServer; // MCP server instance for tool registration
 }
 ```
-### Core Functions
+### Key Methods
-#### `window.mcp.registerTool(name, definition, handler)`
+#### `window.mcp.registerTool(name, config, handler)`
-Register a new AI tool that can be called by AI assistants.
+Registers an AI-callable tool.
-```typescript
-import { z } from 'zod';
+- **name**: Unique tool identifier (string).
+- **config**: Object with `title` (string), `description` (string), and optional `inputSchema` (Zod schema for inputs).
+- **handler**: Async function that executes the tool logic and returns `{ content: [{ type: 'text', text: string }] }`.
+Example:
-window.mcp.registerTool('toolName', {
-  title: 'Human-readable title',
-  description: 'What this tool does',
-  inputSchema: {
-    param1: z.string().describe('Parameter description')
+```typescript
+import { z } from "zod";
+window.mcp.registerTool(
+  "echoInput",
+  {
+    title: "Echo Tool",
+    description: "Echoes the provided input",
+    inputSchema: { input: z.string() },
+  },
+  async ({ input }) => {
+    return { content: [{ type: "text", text: `Echo: ${input}` }] };
   }
-}, async ({ param1 }) => {
-  // Your tool logic here
-  return {
-    content: [{
-      type: 'text',
-      text: `Tool result with ${param1}`
-    }]
-  };
-});
+);
 ```
-#### Manual Initialization (Optional)
+#### `initializeGlobalMCP()` (Optional)
-```typescript
-import { initializeGlobalMCP, cleanupGlobalMCP } from '@mcp-b/global';
+Manually initializes the global MCP instance (automatic in script tag mode).
-// Initialize manually (automatic in script tag mode)
-initializeGlobalMCP();
+#### `cleanupGlobalMCP()` (Optional)
-// Cleanup (useful for testing or hot reload)
-cleanupGlobalMCP();
-```
+Cleans up the global instance, useful for testing or single-page apps.
-### TypeScript Support
+### TypeScript Integration
-The package includes full TypeScript definitions:
+Import types for full autocompletion:
 ```typescript
-import '@mcp-b/global'; // Augments global Window interface
-import { z } from 'zod';
-declare global {
-  interface Window {
-    // Add your custom global tools
-    myCustomFunction: () => void;
-  }
-}
-// Use with full type safety
-window.mcp.registerTool('typedTool', {
-  title: 'Typed Tool',
-  description: 'A tool with proper typing',
-  inputSchema: {
-    value: z.number().describe('A numeric value to process')
+import "@mcp-b/global"; // Augments Window interface
+window.mcp.registerTool(
+  "mathOperation",
+  {
+    title: "Perform Math",
+    description: "Basic arithmetic",
+    inputSchema: { num1: z.number(), num2: z.number() },
+  },
+  async ({ num1, num2 }) => {
+    return { content: [{ type: "text", text: `${num1 + num2}` }] };
   }
-}, async ({ value }) => {
-  return { content: [{ type: 'text', text: `Typed result: ${value * 2}` }] };
-});
+);
 ```
-## 📖 Complete Example
+## 📖 Full Example: AI-Powered Todo App
-Here's a full working example that creates a simple todo app with AI tools:
+This complete HTML file creates a todo list with AI tools for adding, viewing, and deleting items:
 ```html
 <!DOCTYPE html>
 <html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>AI Todo App</title>
-  <style>
-    body { font-family: system-ui; max-width: 600px; margin: 50px auto; padding: 20px; }
-    .todo { padding: 10px; margin: 5px 0; background: #f0f0f0; border-radius: 5px; }
-    .ai-action { background: #4CAF50; color: white; padding: 15px; border-radius: 10px; margin: 10px 0; }
-  </style>
-</head>
-<body>
-  <h1>🤖 AI Todo App</h1>
-  <div id="status">Loading AI...</div>
-  <div id="todos"></div>
-  <!-- Load MCP-B Global -->
-  <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.js"></script>
-  <!-- Load Zod for schema validation -->
-  <script src="https://unpkg.com/zod@latest/lib/index.umd.js"></script>
-  <script>
-    // Access Zod from global
-    const { z } = window.Zod;
-    // Simple todo state
-    const todos = ['Learn MCP-B', 'Build awesome AI tools'];
-    // Show AI action feedback
-    function showAIAction(message) {
-      const div = document.createElement('div');
-      div.className = 'ai-action';
-      div.textContent = `🤖 ${message}`;
-      document.body.insertBefore(div, document.getElementById('todos'));
-      setTimeout(() => div.remove(), 3000);
-    }
-    // Render todos
-    function renderTodos() {
-      document.getElementById('todos').innerHTML = todos
-        .map((todo, i) => `<div class="todo">${i + 1}. ${todo}</div>`)
-        .join('');
-    }
+  <head>
+    <meta charset="UTF-8" />
+    <title>AI Todo List</title>
+    <style>
+      body {
+        font-family: sans-serif;
+        max-width: 600px;
+        margin: 2rem auto;
+        padding: 1rem;
+      }
+      .todo {
+        padding: 0.5rem;
+        margin: 0.25rem 0;
+        background: #f8f9fa;
+        border-radius: 0.25rem;
+      }
+      .ai-feedback {
+        background: #d4edda;
+        color: #155724;
+        padding: 0.75rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+      }
+    </style>
+  </head>
+  <body>
+    <h1>AI-Enabled Todo List</h1>
+    <div id="status">Initializing AI...</div>
+    <div id="todos"></div>
+    <!-- MCP-B Script -->
+    <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.js"></script>
+    <!-- Zod for Schemas -->
+    <script src="https://unpkg.com/zod@latest/lib/index.umd.js"></script>
+    <script>
+      const { z } = window.Zod;
+      const todos = ["Demo Todo 1", "Demo Todo 2"];
+      function showFeedback(message) {
+        const feedback = document.createElement("div");
+        feedback.className = "ai-feedback";
+        feedback.textContent = `AI Action: ${message}`;
+        document.body.insertBefore(feedback, document.getElementById("todos"));
+        setTimeout(() => feedback.remove(), 3000);
+      }
-    // Setup AI tools
-    function setupAI() {
-      if (!window.mcp?.registerTool) {
-        setTimeout(setupAI, 100);
-        return;
+      function updateTodos() {
+        document.getElementById("todos").innerHTML = todos
+          .map((todo, index) => `<div class="todo">${index + 1}. ${todo}</div>`)
+          .join("");
       }
-      // Add todo tool
-      window.mcp.registerTool('addTodo', {
-        title: 'Add Todo',
-        description: 'Add a new todo item',
-        inputSchema: {
-          text: z.string().describe('Todo text to add')
+      function initMCP() {
+        if (!window.mcp?.registerTool) {
+          return setTimeout(initMCP, 100);
         }
-      }, async ({ text }) => {
-        showAIAction(`Adding todo: "${text}"`);
-        todos.push(text);
-        renderTodos();
-        return { content: [{ type: 'text', text: `✅ Added: "${text}"` }] };
-      });
-      // Get todos tool
-      window.mcp.registerTool('getTodos', {
-        title: 'Get All Todos',
-        description: 'Get all current todo items'
-      }, async () => {
-        showAIAction('Getting all todos');
-        return {
-          content: [{
-            type: 'text',
-            text: `📋 Current todos: ${JSON.stringify(todos)}`
-          }]
-        };
-      });
+        window.mcp.registerTool(
+          "addTodoItem",
+          {
+            title: "Add Todo",
+            description: "Adds a new todo item",
+            inputSchema: { text: z.string().describe("Todo text") },
+          },
+          async ({ text }) => {
+            todos.push(text);
+            showFeedback(`Added "${text}"`);
+            updateTodos();
+            return { content: [{ type: "text", text: `Added: ${text}` }] };
+          }
+        );
+        window.mcp.registerTool(
+          "listTodos",
+          {
+            title: "List Todos",
+            description: "Retrieves all todos",
+          },
+          async () => {
+            showFeedback("Listing todos");
+            return { content: [{ type: "text", text: JSON.stringify(todos) }] };
+          }
+        );
+        window.mcp.registerTool(
+          "removeTodo",
+          {
+            title: "Remove Todo",
+            description: "Deletes a todo by index (1-based)",
+            inputSchema: { index: z.number().describe("Todo index") },
+          },
+          async ({ index }) => {
+            const i = index - 1;
+            if (i >= 0 && i < todos.length) {
+              const removed = todos.splice(i, 1)[0];
+              showFeedback(`Removed "${removed}"`);
+              updateTodos();
+              return {
+                content: [{ type: "text", text: `Removed: ${removed}` }],
+              };
+            }
+            return {
+              content: [{ type: "text", text: `Invalid index: ${index}` }],
+            };
+          }
+        );
+        document.getElementById("status").textContent =
+          "AI Ready! Tools available.";
+        document.getElementById("status").style.background = "#d4edda";
+        document.getElementById("status").style.color = "#155724";
+        document.getElementById("status").style.padding = "0.5rem";
+        document.getElementById("status").style.borderRadius = "0.25rem";
+      }
-      // Delete todo tool
-      window.mcp.registerTool('deleteTodo', {
-        title: 'Delete Todo',
-        description: 'Delete a todo by its number (1-based index)',
-        inputSchema: {
-          index: z.number().describe('Todo number to delete (1, 2, 3...)')
-        }
-      }, async ({ index }) => {
-        const i = index - 1; // Convert to 0-based
-        if (i >= 0 && i < todos.length) {
-          const deleted = todos.splice(i, 1)[0];
-          showAIAction(`Deleted todo: "${deleted}"`);
-          renderTodos();
-          return { content: [{ type: 'text', text: `🗑️ Deleted: "${deleted}"` }] };
-        } else {
-          return { content: [{ type: 'text', text: `❌ Todo ${index} not found` }] };
-        }
+      document.addEventListener("DOMContentLoaded", () => {
+        updateTodos();
+        initMCP();
       });
-      // Update status
-      document.getElementById('status').innerHTML = '✅ AI Ready! 3 tools available';
-      document.getElementById('status').style.background = '#d4edda';
-      document.getElementById('status').style.color = '#155724';
-      document.getElementById('status').style.padding = '10px';
-      document.getElementById('status').style.borderRadius = '5px';
-      console.log('🎉 AI tools registered successfully!');
-    }
-    // Initialize
-    document.addEventListener('DOMContentLoaded', () => {
-      renderTodos();
-      setupAI();
-    });
-  </script>
-</body>
+    </script>
+  </body>
 </html>
 ```
-## 🎯 Try It Out
-1. **Install the MCP-B Extension**: Get it from the [Chrome Web Store](https://chromewebstore.google.com/detail/mcp-b/daohopfhkdelnpemnhlekblhnikhdhfa)
+Save as `index.html` and open in a browser with the MCP-B extension installed.
-2. **Save the example above** as an HTML file and open it in Chrome
+## 🎯 Getting Started with the Extension
-3. **Chat with AI**: Open the extension and try commands like:
-   - *"Add a todo: Buy groceries"*
-   - *"Show me all my todos"*
-   - *"Delete todo number 2"*
+1. Install the [MCP-B Extension](https://chromewebstore.google.com/detail/mcp-b/daohopfhkdelnpemnhlekblhnikhdhfa) from the Chrome Web Store.
+2. Open your HTML file or site.
+3. Use the extension's chat: Try "Add a todo: Buy milk" or "List all todos".
-4. **Watch the magic**: See AI interact with your website directly!
+The AI interacts directly with your site's tools!
-## 🌟 When to Use This Package
+## 🌟 Use Cases
-**Perfect for:**
-- 🏃‍♂️ **Rapid Prototyping** - Get AI tools working in minutes
-- 🎯 **Landing Pages** - Add AI capabilities without build complexity
-- 🔄 **Legacy Sites** - Retrofit existing HTML with AI tools
-- 📚 **Learning** - Understand MCP-B concepts quickly
-- 🚀 **MVP Development** - Ship AI features fast
+- **Quick Prototypes**: Add AI to static sites or landing pages.
+- **Legacy Upgrades**: Enhance old HTML with AI without refactoring.
+- **MVPs**: Rapidly build AI features for demos.
+- **Learning MCP-B**: Experiment with concepts in a simple environment.
-**For larger applications**, consider the [TypeScript transport package](https://www.npmjs.com/package/@mcp-b/transports) with full build tool integration.
+For production apps, consider [@mcp-b/transports](https://www.npmjs.com/package/@mcp-b/transports) for deeper integration.
-## 📦 Package Formats
+## 📦 Distribution Formats
-This package is distributed in multiple formats for maximum compatibility:
+- **UMD**: `dist/index.umd.js` – For script tags/AMDs.
+- **ESM**: `dist/index.js` – Modern modules.
+- **CommonJS**: `dist/index.cjs` – Node.js compatibility.
+- **Types**: `dist/index.d.ts` – TypeScript support.
-- **UMD** (`dist/index.umd.js`) - For script tags and AMD loaders
-- **ESM** (`dist/index.js`) - For modern ES modules
-- **CommonJS** (`dist/index.cjs`) - For Node.js and older bundlers
-- **TypeScript** (`dist/index.d.ts`) - Full type definitions
+Examples:
 ```html
-<!-- UMD via CDN -->
+<!-- UMD CDN -->
 <script src="https://unpkg.com/@mcp-b/global@latest/dist/index.js"></script>
-<!-- ESM via CDN -->
-<script type="module">
-  import '@mcp-b/global';
-  // window.mcp is now available
-</script>
 ```
 ```javascript
-// CommonJS
-const { initializeGlobalMCP } = require('@mcp-b/global');
-const { z } = require('zod');
 // ESM
-import { initializeGlobalMCP } from '@mcp-b/global';
-import { z } from 'zod';
+import { initializeGlobalMCP } from "@mcp-b/global";
 ```
-## 🔧 Advanced Usage
+## 🔧 Advanced Features
-### Custom Initialization
+### Error Management
-```typescript
-import { initializeGlobalMCP, cleanupGlobalMCP } from '@mcp-b/global';
-import { z } from 'zod';
-// Initialize with custom configuration
-initializeGlobalMCP();
-// Later, cleanup if needed (useful for SPA route changes)
-cleanupGlobalMCP();
-```
-### Error Handling
+Handle failures gracefully:
 ```javascript
-window.mcp.registerTool('riskyOperation', {
-  title: 'Risky Operation',
-  description: 'An operation that might fail',
-  inputSchema: {
-    data: z.string().describe('Data to process')
-  }
-}, async ({ data }) => {
-  try {
-    const result = await doSomethingRisky(data);
-    return { content: [{ type: 'text', text: `Success: ${result}` }] };
-  } catch (error) {
-    return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+window.mcp.registerTool(
+  "riskyTask",
+  {
+    title: "Risky Task",
+    description: "May fail",
+  },
+  async () => {
+    try {
+      // Logic here
+      return { content: [{ type: "text", text: "Success!" }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Failed: ${err.message}` }],
+        isError: true,
+      };
+    }
   }
-});
+);
 ```
-### Dynamic Tool Registration
+### User-Specific Tools
+Register tools dynamically:
 ```javascript
-function registerUserSpecificTools(user) {
+function addUserTools(user) {
   if (user.isAdmin) {
-    window.mcp.registerTool('adminAction', {
-      title: 'Admin Action',
-      description: 'Administrative function',
-      inputSchema: {
-        action: z.string().describe('Admin action to perform')
-      }
-    }, async ({ action }) => {
-      return { content: [{ type: 'text', text: `Admin action executed: ${action}` }] };
-    });
-  }
-  if (user.isPremium) {
-    window.mcp.registerTool('premiumFeature', {
-      title: 'Premium Feature',
-      description: 'Premium user functionality',
-      inputSchema: {
-        feature: z.string().describe('Premium feature to activate')
+    window.mcp.registerTool(
+      "adminTool",
+      {
+        title: "Admin Tool",
+        description: "Admin-only",
+      },
+      async () => {
+        /* ... */
       }
-    }, async ({ feature }) => {
-      return { content: [{ type: 'text', text: `Premium feature activated: ${feature}` }] };
-    });
+    );
   }
 }
 ```
-## 🚨 Important Notes
+## 🚨 Key Considerations
-- **Browser Only**: This package is designed for browser environments only
-- **Extension Required**: Users need the MCP-B browser extension to interact with your tools
-- **Security**: Tools run in your website's context with the same permissions as your JavaScript
-- **Initialization**: Always wait for `window.mcp` to be available before registering tools
+- **Browser-Only**: Designed exclusively for web environments.
+- **Extension Needed**: Users require the MCP-B extension for AI interactions.
+- **Security**: Tools inherit your site's permissions—expose only safe operations.
+- **Readiness Check**: Always verify `window.mcp` before use.
-## 🔗 Related Packages
+## 🔗 Related Resources
-- **[@mcp-b/transports](https://www.npmjs.com/package/@mcp-b/transports)** - Core transport layer for advanced usage
-- **[@modelcontextprotocol/sdk](https://www.npmjs.com/package/@modelcontextprotocol/sdk)** - Official MCP SDK
-- **[MCP-B Extension](https://chromewebstore.google.com/detail/mcp-b/daohopfhkdelnpemnhlekblhnikhdhfa)** - Browser extension for interacting with tools
+- [@mcp-b/transports](https://www.npmjs.com/package/@mcp-b/transports): Advanced transport layer.
+- [@modelcontextprotocol/sdk](https://www.npmjs.com/package/@modelcontextprotocol/sdk): Core MCP SDK.
+- [MCP-B Extension](https://chromewebstore.google.com/detail/mcp-b/daohopfhkdelnpemnhlekblhnikhdhfa): Browser extension for tool interaction.
+- [Documentation](https://mcp-b.ai): Full guides and specs.
 ## 📄 License
-MIT - see [LICENSE](https://github.com/MiguelsPizza/WebMCP/blob/main/LICENSE)
+MIT – See [LICENSE](https://github.com/MiguelsPizza/WebMCP/blob/main/LICENSE).
 ## 🤝 Contributing
-Contributions welcome! See the [main repository](https://github.com/MiguelsPizza/WebMCP) for guidelines.
+Welcome! Check the [main repo](https://github.com/MiguelsPizza/WebMCP) for guidelines.
 ---
-**Ready to give your website AI superpowers?** Just add the script tag and start building! 🚀
+**Unlock AI for your site today—start with a script tag!** 🚀

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-b/global",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Global bundle for MCP-B with window.mcp API for script tag usage",
   "license": "MIT",
   "author": "Alex Nahas",

package/README DELETED Viewed

@@ -1,167 +0,0 @@
-# @mcp-b/global
-Global bundle for MCP-B (Model Context Protocol - Browser) that provides a polyfill exposing `window.mcp` for easy script tag or CDN usage in browser environments.
-This package creates a global MCP server instance, allowing seamless integration of Model Context Protocol capabilities directly in the browser. It's designed for scenarios where you want a drop-in polyfill without module bundlers, while also supporting modern ESM/CJS imports.
-## Features
-- Auto-initializes on script load in browsers.
-- Exposes `window.mcp` as an instance of `McpServer` from `@modelcontextprotocol/sdk`.
-- Registers a default tool: `get_current_website_title` to retrieve the document title.
-- Supports cleanup for testing or dynamic reloading.
-- Built with security in mind (e.g., configurable allowed origins for transport).
-- Lightweight and treeshaken for browser efficiency.
-## Installation
-### Via NPM (for module-based projects)
-```bash
-npm install @mcp-b/global
-```
-or
-```bash
-yarn add @mcp-b/global
-```
-or
-```bash
-pnpm add @mcp-b/global
-```
-### Via CDN (for script tag usage)
-Use a CDN like unpkg or jsDelivr for direct browser inclusion:
-```html
-<script src="https://unpkg.com/@mcp-b/global@1.0.1/dist/index.umd.js"></script>
-```
-This will auto-initialize `window.mcp` upon loading.
-## Usage
-### Script Tag (Polyfill Mode)
-Simply include the script in your HTML. The library will auto-initialize and expose `window.mcp`.
-```html
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <title>MCP-B Global Example</title>
-    <script src="https://unpkg.com/@mcp-b/global@1.0.1/dist/index.umd.js"></script>
-  </head>
-  <body>
-    <script>
-      // Wait for DOMContentLoaded if needed, but auto-init handles it
-      document.addEventListener("DOMContentLoaded", () => {
-        console.log(window.mcp); // McpServer instance
-        // Use window.mcp.registerTool(...) or other methods
-      });
-    </script>
-  </body>
-</html>
-```
-### Module Import (ESM/CJS)
-For modern JavaScript projects:
-```javascript
-// ESM
-import { initializeGlobalMCP } from "@mcp-b/global";
-// or CJS
-const { initializeGlobalMCP } = require("@mcp-b/global");
-// Initialize manually
-initializeGlobalMCP();
-// Now window.mcp is available
-console.log(window.mcp);
-```
-#### Cleanup
-If you need to reset the instance (e.g., in tests or hot module replacement):
-```javascript
-import { cleanupGlobalMCP } from "@mcp-b/global";
-cleanupGlobalMCP(); // Closes the server and removes window.mcp
-```
-## API
-### `initializeGlobalMCP(): void`
-- Initializes the global MCP server if not already done.
-- Safe to call multiple times (idempotent).
-- Throws an error if initialization fails.
-- In browser environments only; skips in non-browser contexts.
-### `cleanupGlobalMCP(): void`
-- Closes the MCP server connection.
-- Removes `window.mcp`.
-- Resets internal state for re-initialization.
-### Global Exposure
-After initialization:
-- `window.mcp`: An instance of `McpServer` with:
-  - Server info: `{ name: hostname, version: '1.0.0' }`
-  - Capabilities: Supports tool list changes and debounced notifications.
-  - Default tool: `get_current_website_title` – Returns the current document title as `{ content: [{ type: 'text', text: title }] }`.
-You can extend it by calling `window.mcp.registerTool(...)` or other MCP SDK methods.
-## Configuration and Best Practices
-- **Security**: The transport uses `allowedOrigins: ['*']` by default for broad compatibility. In production, restrict this to trusted origins (e.g., your domain) to prevent cross-origin issues. Modify the source or fork if needed.
-- **Error Handling**: Tools and initialization include try-catch blocks for robustness.
-- **Browser Compatibility**: Targets ES2018; works in modern browsers (Chrome 61+, Firefox 55+, Safari 11+, Edge 16+).
-- **TypeScript**: Includes full type declarations for `window.mcp`.
-## Dependencies
-- `@mcp-b/transports`: For browser transport handling.
-- `@modelcontextprotocol/sdk`: Core MCP SDK.
-- `zod`: For schema validation (if used internally).
-## Development
-### Building
-```bash
-pnpm install
-pnpm build
-```
-### Scripts
-- `build`: Builds the library using tsup (ESM, CJS, UMD formats).
-- `typecheck`: Runs TypeScript checks.
-- `lint` / `format` / `check`: Uses Biome for code quality.
-- `clean`: Removes build artifacts.
-## License
-MIT License. See [LICENSE](LICENSE) for details.
-## Contributing
-Contributions welcome! Fork the repo, create a branch, and submit a PR. Report issues at [GitHub Issues](https://github.com/MiguelsPizza/WebMCP/issues).
-## Links
-- [Repository](https://github.com/MiguelsPizza/WebMCP/tree/main/packages/global)
-- [NPM Package](https://www.npmjs.com/package/@mcp-b/global)
-- [Homepage](https://github.com/MiguelsPizza/WebMCP#readme)