@mimik/mcp-kit 1.0.0

package/READMD.md

@@ -0,0 +1,571 @@
+# mcp-kit: MCP Server Library
+
+A lightweight, flexible library for building Model Context Protocol (MCP) servers with comprehensive schema validation and Zod-like syntax support in mimik serverless environment.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Core Concepts](#core-concepts)
+- [Schema Definition](#schema-definition)
+- [API Reference](#api-reference)
+- [Examples](#examples)
+- [Error Handling](#error-handling)
+- [Best Practices](#best-practices)
+
+## Installation
+
+```bash
+npm install @mimik/mcp-kit
+```
+
+```javascript
+const { McpServer, z } = require('@mimik/mcp-kit');
+```
+
+## Quick Start
+
+```javascript
+const { McpServer, z } = require('@mimik/mcp-kit');
+
+// Create a server instance
+const server = new McpServer({
+  name: 'my-mcp-server',
+  version: '1.0.0'
+});
+
+// Register a tool
+server.tool(
+  'greet',
+  'Greets a user with optional formality',
+  {
+    name: z.string().describe('The name to greet'),
+    formal: z.boolean().default(false).describe('Use formal greeting')
+  },
+  async (args) => {
+    const { name, formal } = args;
+    const greeting = formal ? `Good day, ${name}` : `Hi ${name}!`;
+    return greeting;
+  }
+);
+
+// Handle MCP requests
+const response = await server.handleMcpRequest(request);
+```
+
+## Core Concepts
+
+### Server Instance
+
+The `McpServer` class is the main entry point for creating MCP servers. It handles JSON-RPC 2.0 protocol communication and manages tools, resources, and prompts.
+
+### Tools
+
+Tools are functions that can be called by MCP clients. Each tool has:
+- **Name**: Unique identifier
+- **Description**: Human-readable description
+- **Input Schema**: Defines expected parameters
+- **Handler**: Async function that processes the request
+
+### Resources
+
+Resources represent readable content (files, data, etc.) that clients can access.
+
+### Prompts
+
+Prompts are templates for generating messages with dynamic content.
+
+## Schema Definition
+
+This library supports multiple schema definition formats for maximum flexibility.
+
+### Zod-like Syntax (Recommended)
+
+```javascript
+{
+  name: z.string().describe('User name'),
+  age: z.number().default(25).describe('User age'),
+  role: z.enum(['admin', 'user', 'guest']).default('user').describe('User role'),
+  active: z.boolean().describe('Is user active'),
+  tags: z.array(z.string()).describe('User tags'),
+  profile: z.object({
+    bio: z.string().describe('Biography'),
+    website: z.optional(z.string()).describe('Website URL')
+  }),
+  nickname: z.optional(z.string()).describe('Optional nickname')
+}
+```
+
+### Custom Format
+
+```javascript
+{
+  name: { type: 'string', description: 'User name' },
+  age: { type: 'number', optional: true, default: 25, description: 'User age' },
+  role: { type: 'string', enum: ['admin', 'user', 'guest'], default: 'user' }
+}
+```
+
+### Pure JSON Schema
+
+```javascript
+{
+  type: 'object',
+  properties: {
+    name: { type: 'string', description: 'User name' },
+    age: { type: 'number', default: 25, description: 'User age' }
+  },
+  required: ['name']
+}
+```
+
+## API Reference
+
+### McpServer
+
+#### Constructor
+
+```javascript
+new McpServer(serverInfo?)
+```
+
+**Parameters:**
+- `serverInfo` (optional): Object with `name` and `version` properties
+
+#### Methods
+
+##### tool(name, description, inputSchema, handler)
+
+Registers a new tool.
+
+**Parameters:**
+- `name` (string): Unique tool identifier
+- `description` (string): Tool description
+- `inputSchema` (object): Parameter schema definition
+- `handler` (async function): Tool implementation
+
+**Returns:** `this` (for chaining)
+
+##### resource(uri, name, description, mimeType, handler)
+
+Registers a new resource.
+
+**Parameters:**
+- `uri` (string): Unique resource URI
+- `name` (string): Resource name
+- `description` (string): Resource description
+- `mimeType` (string): MIME type of the resource
+- `handler` (async function): Resource content provider
+
+**Returns:** `this` (for chaining)
+
+##### prompt(name, description, argumentsSchema, handler)
+
+Registers a new prompt.
+
+**Parameters:**
+- `name` (string): Unique prompt identifier
+- `description` (string): Prompt description
+- `argumentsSchema` (object): Arguments schema
+- `handler` (async function): Prompt generator
+
+**Returns:** `this` (for chaining)
+
+##### handleMcpRequest(requestBody)
+
+Processes an MCP request.
+
+**Parameters:**
+- `requestBody` (string | object): JSON-RPC 2.0 request
+
+**Returns:** Promise<object> - JSON-RPC 2.0 response
+
+### Schema Helpers (z)
+
+#### Basic Types
+
+```javascript
+z.string()    // String type
+z.number()    // Number type
+z.boolean()   // Boolean type
+```
+
+#### Complex Types
+
+```javascript
+z.enum(['option1', 'option2', 'option3'])           // Enumeration
+z.array(z.string())                                 // Array of strings
+z.object({ key: z.string() })                       // Object with properties
+z.optional(z.string())                              // Optional field
+```
+
+#### Modifiers
+
+```javascript
+.describe('Field description')    // Add description
+.default(value)                  // Set default value (makes field optional)
+```
+
+#### Chaining
+
+All modifiers can be chained in any order:
+
+```javascript
+z.enum(['small', 'medium', 'large'])
+  .default('medium')
+  .describe('Size selection')
+```
+
+## Examples
+
+### Basic Tool
+
+```javascript
+server.tool(
+  'add',
+  'Adds two numbers',
+  {
+    a: z.number().describe('First number'),
+    b: z.number().describe('Second number')
+  },
+  async ({ a, b }) => {
+    return `${a} + ${b} = ${a + b}`;
+  }
+);
+```
+
+### Tool with Optional Parameters
+
+```javascript
+server.tool(
+  'search',
+  'Search for items',
+  {
+    query: z.string().describe('Search query'),
+    limit: z.number().default(10).describe('Maximum results'),
+    category: z.optional(z.string()).describe('Filter by category')
+  },
+  async ({ query, limit, category }) => {
+    // Implementation here
+    return `Searching for "${query}" (limit: ${limit}, category: ${category || 'all'})`;
+  }
+);
+```
+
+### Tool with Enum and Complex Objects
+
+```javascript
+server.tool(
+  'createOrder',
+  'Create a new order',
+  {
+    type: z.enum(['pickup', 'delivery', 'dine-in']).default('pickup'),
+    priority: z.enum(['low', 'normal', 'high']).default('normal'),
+    customer: z.object({
+      name: z.string(),
+      email: z.string(),
+      phone: z.optional(z.string())
+    }),
+    items: z.array(z.object({
+      id: z.string(),
+      quantity: z.number(),
+      notes: z.optional(z.string())
+    }))
+  },
+  async (args) => {
+    const { type, priority, customer, items } = args;
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Order created: ${items.length} items for ${customer.name} (${type}, ${priority} priority)`
+        }
+      ]
+    };
+  }
+);
+```
+
+### Resource Example
+
+```javascript
+server.resource(
+  'file://logs/system.log',
+  'System Log',
+  'Current system log file',
+  'text/plain',
+  async () => {
+    // Return log content
+    return 'Log entries...';
+  }
+);
+```
+
+### Prompt Example
+
+```javascript
+server.prompt(
+  'codeReview',
+  'Generate code review prompt',
+  {
+    language: z.string().describe('Programming language'),
+    level: z.enum(['beginner', 'intermediate', 'advanced']).default('intermediate')
+  },
+  async ({ language, level }) => {
+    return [
+      {
+        role: 'user',
+        content: {
+          type: 'text',
+          text: `Please review this ${language} code focusing on ${level}-level best practices.`
+        }
+      }
+    ];
+  }
+);
+```
+
+## Error Handling
+
+The library provides comprehensive error handling:
+
+### Validation Errors
+
+```javascript
+// Missing required parameter
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32602,
+    "message": "Invalid arguments: Missing required parameter: name"
+  }
+}
+
+// Wrong parameter type
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32602,
+    "message": "Invalid arguments: Parameter 'age' should be a number, got string"
+  }
+}
+```
+
+### Tool Execution Errors
+
+```javascript
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32603,
+    "message": "Tool execution error",
+    "data": "Division by zero"
+  }
+}
+```
+
+### Common Error Codes
+
+- `-32700`: Parse error (malformed JSON)
+- `-32601`: Method not found
+- `-32602`: Invalid parameters
+- `-32603`: Internal error
+
+## Best Practices
+
+### 1. Use Descriptive Names and Descriptions
+
+```javascript
+// Good
+server.tool(
+  'calculateTax',
+  'Calculate tax amount based on income and tax rate',
+  {
+    income: z.number().describe('Annual income in dollars'),
+    rate: z.number().describe('Tax rate as decimal (0.1 for 10%)')
+  },
+  handler
+);
+
+// Avoid
+server.tool('calc', 'Does math', { a: z.number(), b: z.number() }, handler);
+```
+
+### 2. Provide Sensible Defaults
+
+```javascript
+server.tool(
+  'search',
+  'Search documents',
+  {
+    query: z.string().describe('Search query'),
+    maxResults: z.number().default(20).describe('Maximum results to return'),
+    sortBy: z.enum(['relevance', 'date', 'title']).default('relevance')
+  },
+  handler
+);
+```
+
+### 3. Use Enums for Limited Options
+
+```javascript
+// Good - clear valid options
+status: z.enum(['active', 'inactive', 'pending']).default('pending')
+
+// Avoid - unclear what values are valid
+status: z.string().describe('Status (active, inactive, or pending)')
+```
+
+### 4. Validate Input Early
+
+The library automatically validates parameters against the schema before calling your handler, so focus on business logic validation:
+
+```javascript
+async ({ email, age }) => {
+  // Schema validation already ensures email is string, age is number
+  
+  // Add business logic validation
+  if (age < 0 || age > 150) {
+    throw new Error('Age must be between 0 and 150');
+  }
+  
+  if (!email.includes('@')) {
+    throw new Error('Invalid email format');
+  }
+  
+  // Process the request...
+}
+```
+
+### 5. Return Structured Responses
+
+```javascript
+// For simple text responses
+return "Operation completed successfully";
+
+// For complex responses
+return {
+  content: [
+    { type: 'text', text: 'Results:' },
+    { type: 'text', text: JSON.stringify(data, null, 2) }
+  ]
+};
+```
+
+### 6. Handle Async Operations Properly
+
+```javascript
+server.tool(
+  'fetchData',
+  'Fetch data from external API',
+  { url: z.string() },
+  async ({ url }) => {
+    try {
+      const response = await fetch(url);
+      const data = await response.json();
+      return JSON.stringify(data, null, 2);
+    } catch (error) {
+      throw new Error(`Failed to fetch data: ${error.message}`);
+    }
+  }
+);
+```
+
+## Integration Examples
+
+### Express-like Middleware
+
+The key to integrating with Express or any similar web framework is using `server.handleMcpRequest()` to process all MCP requests:
+
+```javascript
+const { McpServer, z } = require('@mimik/mcp-kit');
+
+const server = new McpServer({ name: 'my-api', version: '1.0.0' });
+
+// Register your tools...
+server.tool('ping', 'Simple ping', {}, async () => 'pong');
+
+// IMPORTANT: Use server.handleMcpRequest() to handle all MCP communication
+app.post('/mcp', async (req, res) => {
+  try {
+    const response = await server.handleMcpRequest(req.body);
+    if (response) {
+      res.json(response);
+    } else {
+      res.status(204).end(); // For notifications - no response needed
+    }
+  } catch (error) {
+    res.status(500).json({
+      jsonrpc: '2.0',
+      id: req.body?.id || null,
+      error: { code: -32603, message: 'Internal error', data: error.message }
+    });
+  }
+});
+```
+
+#### Alternative Promise-based Approach
+
+```javascript
+// In your middleware app
+app.post('/mcp', (req, res) => {
+  server.handleMcpRequest(req.body).then((response) => {
+    if (response) {
+      res.json(response);
+    } else {
+      // Notification - no response needed
+      res.status(204).end();
+    }
+  }).catch((error) => {
+    res.status(500).json({ 
+      jsonrpc: '2.0',
+      id: req.body?.id || null,
+      error: { code: -32603, message: 'Internal error', data: error.message }
+    });
+  });
+});
+```
+
+**Key Points:**
+- Always use `server.handleMcpRequest(req.body)` to process MCP requests
+- Handle both responses (requests) and notifications (no response)
+- Use status 204 for notifications, not 200
+- Properly format error responses as JSON-RPC 2.0
+
+### Testing Your Server
+
+```javascript
+async function testServer() {
+  // Initialize
+  const initResponse = await server.handleMcpRequest({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {}
+  });
+  
+  // List tools
+  const toolsResponse = await server.handleMcpRequest({
+    jsonrpc: '2.0',
+    id: 2,
+    method: 'tools/list'
+  });
+  
+  // Call a tool
+  const callResponse = await server.handleMcpRequest({
+    jsonrpc: '2.0',
+    id: 3,
+    method: 'tools/call',
+    params: {
+      name: 'greet',
+      arguments: { name: 'World', formal: true }
+    }
+  });
+  
+  console.log('Tool response:', callResponse);
+}
+```

package/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@mimik/mcp-kit",
+  "version": "1.0.0",
+  "main": "./src/index.js"
+}

package/src/constants.js

@@ -0,0 +1,38 @@
+const JSONRPC_ERR_CODE_PARSE_ERROR = {
+  code: -32700,
+  message: 'Parse error',
+};
+
+const JSONRPC_ERR_CODE_INVALID_REQUEST = {
+  code: -32600,
+  message: 'Invalid Request',
+};
+
+const JSONRPC_ERR_CODE_METHOD_NOT_FOUND = {
+  code: -32601,
+  message: 'Method not found',
+};
+
+const JSONRPC_ERR_CODE_INVALID_PARAMS = {
+  code: -32602,
+  message: 'Invalid params',
+};
+
+const JSONRPC_ERR_CODE_INTERNAL_ERROR = {
+  code: -32603,
+  message: 'Internal error',
+};
+
+const JSONRPC_ERR_CODE_SERVER_ERROR = {
+  code: -32000,
+  message: 'Server error',
+};
+
+module.exports = {
+  JSONRPC_ERR_CODE_PARSE_ERROR,
+  JSONRPC_ERR_CODE_INVALID_REQUEST,
+  JSONRPC_ERR_CODE_METHOD_NOT_FOUND,
+  JSONRPC_ERR_CODE_INVALID_PARAMS,
+  JSONRPC_ERR_CODE_INTERNAL_ERROR,
+  JSONRPC_ERR_CODE_SERVER_ERROR,
+};

package/src/handlers.js

@@ -0,0 +1,288 @@
+const {
+  JSONRPC_ERR_CODE_PARSE_ERROR,
+  JSONRPC_ERR_CODE_METHOD_NOT_FOUND,
+  JSONRPC_ERR_CODE_INVALID_PARAMS,
+  JSONRPC_ERR_CODE_INTERNAL_ERROR,
+} = require('./constants');
+
+const {
+  createResponse,
+  createStandardError,
+  validateArguments,
+} = require('./jsonrpc');
+
+function handleMcpRequest(requestBody, mcpServer) {
+  return new Promise((resolve) => {
+    try {
+      const message = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+
+      if (message.method && message.id !== undefined) {
+        handleRequest(message, mcpServer).then(resolve);
+      } else if (message.method) {
+        handleNotification(message, mcpServer).then(() => resolve(null));
+      } else {
+        throw new Error('Invalid JSON-RPC message format');
+      }
+    } catch (error) {
+      resolve(createResponse(
+        null,
+        null,
+        createStandardError(JSONRPC_ERR_CODE_PARSE_ERROR, null, error.message),
+      ));
+    }
+  });
+}
+
+function handleRequest(request, mcpServer) {
+  const { method, params = {}, id } = request;
+
+  return new Promise((resolve) => {
+    const handleMethod = () => {
+      switch (method) {
+        case 'initialize':
+          return handleInitialize(params, id, mcpServer);
+
+        case 'tools/list':
+          return handleToolsList(id, mcpServer);
+
+        case 'tools/call':
+          return handleToolsCall(params, id, mcpServer);
+
+        case 'resources/list':
+          return handleResourcesList(id, mcpServer);
+
+        case 'resources/read':
+          return handleResourcesRead(params, id, mcpServer);
+
+        case 'prompts/list':
+          return handlePromptsList(id, mcpServer);
+
+        case 'prompts/get':
+          return handlePromptsGet(params, id, mcpServer);
+
+        default:
+          return Promise.resolve(createResponse(
+            id,
+            null,
+            createStandardError(JSONRPC_ERR_CODE_METHOD_NOT_FOUND),
+          ));
+      }
+    };
+
+    handleMethod()
+      .then(resolve)
+      .catch((error) => {
+        resolve(createResponse(
+          id,
+          null,
+          createStandardError(JSONRPC_ERR_CODE_INTERNAL_ERROR, null, error.message),
+        ));
+      });
+  });
+}
+
+function handleNotification(notification, mcpServer) {
+  return new Promise((resolve) => {
+    const { method } = notification;
+
+    switch (method) {
+      case 'notifications/initialized':
+        mcpServer.isInitialized = true;
+        break;
+
+      case 'notifications/cancelled':
+        break;
+
+      default:
+        break;
+    }
+
+    resolve();
+  });
+}
+
+function handleInitialize(params, id, mcpServer) {
+  return new Promise((resolve) => {
+    const capabilities = {};
+
+    if (mcpServer.tools.size > 0) {
+      capabilities.tools = {};
+    }
+
+    if (mcpServer.resources.size > 0) {
+      capabilities.resources = { subscribe: true, listChanged: true };
+    }
+
+    if (mcpServer.prompts.size > 0) {
+      capabilities.prompts = {};
+    }
+
+    const result = {
+      protocolVersion: '2025-06-18',
+      capabilities,
+      serverInfo: mcpServer.serverInfo,
+    };
+
+    resolve(createResponse(id, result));
+  });
+}
+
+function handleToolsList(id, mcpServer) {
+  return new Promise((resolve) => {
+    const tools = Array.from(mcpServer.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    }));
+
+    resolve(createResponse(id, { tools }));
+  });
+}
+
+function handleToolsCall(params, id, mcpServer) {
+  return new Promise((resolve) => {
+    const { name, arguments: args = {} } = params;
+
+    if (!mcpServer.tools.has(name)) {
+      resolve(createResponse(
+        id,
+        null,
+        createStandardError(JSONRPC_ERR_CODE_INVALID_PARAMS, `Tool '${name}' not found`),
+      ));
+      return;
+    }
+
+    const tool = mcpServer.tools.get(name);
+
+    const validationError = validateArguments(args, tool.inputSchema);
+    if (validationError) {
+      resolve(createResponse(
+        id,
+        null,
+        createStandardError(JSONRPC_ERR_CODE_INVALID_PARAMS, `Invalid arguments: ${validationError}`),
+      ));
+      return;
+    }
+
+    Promise.resolve(tool.handler(args))
+      .then((result) => {
+        let response;
+        if (result && result.content) {
+          response = result;
+        } else if (typeof result === 'string') {
+          response = {
+            content: [{ type: 'text', text: result }],
+          };
+        } else {
+          response = {
+            content: [{ type: 'text', text: String(result) }],
+          };
+        }
+
+        resolve(createResponse(id, response));
+      })
+      .catch((error) => {
+        resolve(createResponse(
+          id,
+          null,
+          createStandardError(JSONRPC_ERR_CODE_INTERNAL_ERROR, 'Tool execution error', error.message),
+        ));
+      });
+  });
+}
+
+function handleResourcesList(id, mcpServer) {
+  return new Promise((resolve) => {
+    const resources = Array.from(mcpServer.resources.values()).map((resource) => ({
+      uri: resource.uri,
+      name: resource.name,
+      description: resource.description,
+      mimeType: resource.mimeType,
+    }));
+
+    resolve(createResponse(id, { resources }));
+  });
+}
+
+function handleResourcesRead(params, id, mcpServer) {
+  return new Promise((resolve) => {
+    const { uri } = params;
+
+    if (!mcpServer.resources.has(uri)) {
+      resolve(createResponse(
+        id,
+        null,
+        createStandardError(JSONRPC_ERR_CODE_INVALID_PARAMS, `Resource '${uri}' not found`),
+      ));
+      return;
+    }
+
+    const resource = mcpServer.resources.get(uri);
+
+    Promise.resolve(resource.handler())
+      .then((content) => {
+        resolve(createResponse(id, {
+          contents: [{
+            uri: resource.uri,
+            mimeType: resource.mimeType,
+            text: content,
+          }],
+        }));
+      })
+      .catch((error) => {
+        resolve(createResponse(
+          id,
+          null,
+          createStandardError(JSONRPC_ERR_CODE_INTERNAL_ERROR, 'Resource read error', error.message),
+        ));
+      });
+  });
+}
+
+function handlePromptsList(id, mcpServer) {
+  return new Promise((resolve) => {
+    const prompts = Array.from(mcpServer.prompts.values()).map((prompt) => ({
+      name: prompt.name,
+      description: prompt.description,
+      arguments: prompt.arguments,
+    }));
+
+    resolve(createResponse(id, { prompts }));
+  });
+}
+
+function handlePromptsGet(params, id, mcpServer) {
+  return new Promise((resolve) => {
+    const { name, arguments: args = {} } = params;
+
+    if (!mcpServer.prompts.has(name)) {
+      resolve(createResponse(
+        id,
+        null,
+        createStandardError(JSONRPC_ERR_CODE_INVALID_PARAMS, `Prompt '${name}' not found`),
+      ));
+      return;
+    }
+
+    const prompt = mcpServer.prompts.get(name);
+
+    Promise.resolve(prompt.handler(args))
+      .then((messages) => {
+        resolve(createResponse(id, {
+          description: prompt.description,
+          messages,
+        }));
+      })
+      .catch((error) => {
+        resolve(createResponse(
+          id,
+          null,
+          createStandardError(JSONRPC_ERR_CODE_INTERNAL_ERROR, 'Prompt execution error', error.message),
+        ));
+      });
+  });
+}
+
+module.exports = {
+  handleMcpRequest,
+};

package/src/index.js

@@ -0,0 +1,76 @@
+
+
+const {
+  convertToJsonSchema,
+} = require('./jsonrpc');
+const { handleMcpRequest } = require('./handlers');
+
+class McpServer {
+  constructor(aServerInfo) {
+    const serverInfo = {
+      name: 'custom-mcp-server',
+      version: '1.0.0',
+    };
+
+    if (aServerInfo) {
+      const { name, version } = aServerInfo;
+
+      if (name) {
+        serverInfo.name = name;
+      }
+
+      if (version) {
+        serverInfo.version = version;
+      }
+    }
+
+    this.serverInfo = serverInfo;
+    this.tools = new Map();
+    this.resources = new Map();
+    this.prompts = new Map();
+    this.isInitialized = false;
+  }
+
+  tool(name, description, inputSchema, handler) {
+    const jsonSchema = convertToJsonSchema(inputSchema);
+
+    this.tools.set(name, {
+      name,
+      description,
+      inputSchema: jsonSchema,
+      handler,
+    });
+
+    return this;
+  }
+
+
+  resource(uri, name, description, mimeType, handler) {
+    this.resources.set(uri, {
+      uri,
+      name,
+      description,
+      mimeType,
+      handler,
+    });
+    return this;
+  }
+
+  prompt(name, description, argumentsSchema, handler) {
+    this.prompts.set(name, {
+      name,
+      description,
+      arguments: argumentsSchema,
+      handler,
+    });
+    return this;
+  }
+
+  handleMcpRequest(requestBody) {
+    return handleMcpRequest(requestBody, this);
+  }
+}
+
+const { z } = require('./schema');
+
+module.exports = { McpServer, z };

package/src/jsonrpc.js

@@ -0,0 +1,207 @@
+function createMessage(method, params = null, id = null) {
+  const message = {
+    jsonrpc: '2.0',
+    method,
+  };
+
+  if (params !== null && params !== undefined) {
+    message.params = params;
+  }
+
+  if (id !== null && id !== undefined) {
+    message.id = id;
+  }
+
+  return message;
+}
+
+function createResponse(id, result = null, error = null) {
+  const response = {
+    jsonrpc: '2.0',
+    id,
+  };
+
+  if (error) {
+    response.error = error;
+  } else {
+    response.result = result || {};
+  }
+
+  return response;
+}
+
+function createError(code, message, data = null) {
+  const error = { code, message };
+  if (data) error.data = data;
+  return error;
+}
+
+function createStandardError(errorConstant, customMessage = null, data = null) {
+  if (!errorConstant || typeof errorConstant.code !== 'number') {
+    throw new Error('Invalid error constant provided');
+  }
+
+  return createError(
+    errorConstant.code,
+    customMessage || errorConstant.message,
+    data,
+  );
+}
+
+function convertToJsonSchema(inputSchema) {
+  if (inputSchema && inputSchema.type === 'object' && inputSchema.properties) {
+    return inputSchema;
+  }
+
+  const jsonSchema = {
+    type: 'object',
+    properties: {},
+    required: [],
+  };
+
+  if (!inputSchema || Object.keys(inputSchema).length === 0) {
+    return jsonSchema;
+  }
+
+  for (const [key, schemaType] of Object.entries(inputSchema)) {
+    let propertySchema = {};
+    let isRequired = true;
+
+    if (typeof schemaType === 'object' && schemaType !== null) {
+      if (schemaType.type) {
+        propertySchema = { ...schemaType };
+      } else if (schemaType._def) {
+        const zodType = _convertZodType(schemaType);
+        propertySchema = zodType.schema;
+        isRequired = zodType.required;
+      } else if (schemaType.optional !== undefined) {
+        isRequired = !schemaType.optional;
+        propertySchema = {
+          type: schemaType.type || 'string',
+          ...(schemaType.description && { description: schemaType.description }),
+          ...(schemaType.default !== undefined && { default: schemaType.default }),
+        };
+      } else {
+        propertySchema = { type: 'string' };
+      }
+    } else if (typeof schemaType === 'string') {
+      propertySchema = { type: schemaType };
+    } else {
+      propertySchema = { type: 'string' };
+    }
+
+    jsonSchema.properties[key] = propertySchema;
+
+    if (isRequired) {
+      jsonSchema.required.push(key);
+    }
+  }
+
+  return jsonSchema;
+}
+
+function _convertZodType(zodType) {
+  const def = zodType._def;
+  let schema = {};
+  let required = true;
+
+  switch (def.typeName) {
+    case 'ZodNumber':
+      schema = { type: 'number' };
+      break;
+    case 'ZodString':
+      schema = { type: 'string' };
+      break;
+    case 'ZodBoolean':
+      schema = { type: 'boolean' };
+      break;
+    case 'ZodArray':
+      schema = {
+        type: 'array',
+        items: _convertZodType(def.type).schema,
+      };
+      break;
+    case 'ZodObject':
+      schema = {
+        type: 'object',
+        properties: {},
+        required: [],
+      };
+      for (const [key, value] of Object.entries(def.shape)) {
+        const converted = _convertZodType(value);
+        schema.properties[key] = converted.schema;
+        if (converted.required) {
+          schema.required.push(key);
+        }
+      }
+      break;
+    case 'ZodEnum':
+      schema = {
+        type: 'string',
+        enum: def.values,
+      };
+      break;
+    case 'ZodOptional': {
+      const innerConverted = _convertZodType(def.innerType);
+      schema = innerConverted.schema;
+      required = false;
+    }
+      break;
+    default:
+      schema = { type: 'string' };
+  }
+
+  if (def.description) {
+    schema.description = def.description;
+  }
+
+  if (def.default !== undefined) {
+    schema.default = def.default;
+    required = false;
+  }
+
+  return { schema, required };
+}
+
+function validateArguments(args, schema) {
+  if (!schema || !schema.required) {
+    return null;
+  }
+
+  for (const requiredField of schema.required) {
+    if (args[requiredField] === undefined || args[requiredField] === null) {
+      return `Missing required parameter: ${requiredField}`;
+    }
+  }
+
+  if (schema.properties) {
+    for (const [key, value] of Object.entries(args)) {
+      const propSchema = schema.properties[key];
+      if (propSchema && propSchema.type) {
+        const actualType = typeof value;
+        const expectedType = propSchema.type;
+
+        if (expectedType === 'number' && actualType !== 'number') {
+          return `Parameter '${key}' should be a number, got ${actualType}`;
+        }
+        if (expectedType === 'string' && actualType !== 'string') {
+          return `Parameter '${key}' should be a string, got ${actualType}`;
+        }
+        if (expectedType === 'boolean' && actualType !== 'boolean') {
+          return `Parameter '${key}' should be a boolean, got ${actualType}`;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  createMessage,
+  createResponse,
+  createError,
+  createStandardError,
+  convertToJsonSchema,
+  validateArguments,
+};

package/src/schema.js

@@ -0,0 +1,117 @@
+const z = {
+  number: () => {
+    const result = { type: 'number', _def: { typeName: 'ZodNumber' } };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  string: () => {
+    const result = { type: 'string', _def: { typeName: 'ZodString' } };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  boolean: () => {
+    const result = { type: 'boolean', _def: { typeName: 'ZodBoolean' } };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  enum: (values) => {
+    const result = {
+      type: 'string',
+      _def: {
+        typeName: 'ZodEnum',
+        values,
+      },
+    };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  array: (items) => {
+    const result = {
+      type: 'array',
+      _def: {
+        typeName: 'ZodArray',
+        type: items,
+      },
+    };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  object: (shape) => {
+    const result = {
+      type: 'object',
+      _def: {
+        typeName: 'ZodObject',
+        shape,
+      },
+    };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+
+  optional: (type) => {
+    const result = {
+      _def: {
+        typeName: 'ZodOptional',
+        innerType: type,
+      },
+    };
+    result.describe = (description) => {
+      result._def.description = description;
+      return result;
+    };
+    result.default = (defaultValue) => {
+      result._def.default = defaultValue;
+      return result;
+    };
+    return result;
+  },
+};
+
+module.exports = { z };