mcp-server-sdk 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Human4AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,388 @@
+# mcp-server-sdk
+
+Enhanced Model Context Protocol (MCP) server SDK with session management, message routing, and distributed capabilities.
+
+## Features
+
+- 🚀 **Single Instance, Multiple Sessions** - One server handles concurrent connections
+- 🔄 **Per-Request Transport** - Initialize transport for each request
+- 🆔 **Session Management** - Unique distributed session tracking with automatic timeouts
+- 📨 **Message Routing** - Route and store messages for resumability and replay
+- 💾 **Message Storage** - Built-in and custom storage implementations
+- 📊 **Event System** - Listen to session and message events
+- 🎯 **TypeScript Support** - Full type definitions
+- 🔌 **MCP Compatible** - Extends official `@modelcontextprotocol/sdk`
+- 🪶 **Minimal Dependencies**
+
+## Installation
+
+```bash
+npm install mcp-server-sdk @modelcontextprotocol/sdk
+```
+
+## Architecture
+
+The SDK supports a distributed architecture where:
+
+1. **Single Server Instance** - Runs continuously and handles multiple sessions
+2. **Per-Request Transports** - Each HTTP request can initialize its own transport
+3. **Session-Based Routing** - Messages are routed by unique session IDs
+4. **Message Storage** - All messages can be stored for resumability
+5. **Event-Driven** - React to session lifecycle and message events
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { createMCPServer } from "mcp-server-sdk";
+
+// Create server instance (singleton pattern recommended)
+const server = createMCPServer({
+  name: "my-mcp-server",
+  version: "1.0.0",
+  title: "My MCP Server",
+  websiteUrl: "https://example.com"
+});
+
+// Register tools
+server.tool("hello", "Say hello", async () => {
+  return {
+    content: [{ type: "text", text: "Hello from MCP!" }]
+  };
+});
+
+// Register resources
+server.resource("config", "file:///config.json", async (uri) => {
+  return {
+    contents: [{
+      uri: uri.href,
+      text: JSON.stringify({ setting: "value" }),
+      mimeType: "application/json"
+    }]
+  };
+});
+
+console.log(`Server instance ID: ${server.getInstanceId()}`);
+```
+
+### HTTP/SSE Server Integration
+
+```typescript
+import express from "express";
+import { createMCPServer } from "mcp-server-sdk";
+import { DistributedStreamableHttpServerTransport } from "@human4.ai/distributed-streamable-http-server-transport";
+
+const app = express();
+const server = createMCPServer({
+  name: "distributed-mcp-server",
+  version: "1.0.0"
+});
+
+// Register your tools, resources, and prompts
+server.tool("process-data", "Process data", async (args) => {
+  return {
+    content: [{ type: "text", text: `Processed: ${JSON.stringify(args)}` }]
+  };
+});
+
+// Handle incoming requests
+app.use("/mcp", async (req, res) => {
+  try {
+    // Create per-request transport
+    const transport = new DistributedStreamableHttpServerTransport();
+    
+    // Create or resume session
+    const sessionId = req.headers["x-session-id"] as string;
+    const session = await server.connectWithSession(transport, sessionId);
+    
+    // Set session header for client
+    res.setHeader("X-Session-ID", session.sessionId);
+    
+    // Handle the request
+    await transport.handleRequest(req, res);
+    
+    // Update session activity
+    server.updateSessionActivity(session.sessionId);
+  } catch (error) {
+    console.error("MCP request error:", error);
+    res.status(500).json({
+      jsonrpc: "2.0",
+      error: { code: -32603, message: "Internal server error" },
+      id: null
+    });
+  }
+});
+
+app.listen(3000, () => {
+  console.log("MCP server listening on port 3000");
+});
+```
+
+### Session Management
+
+```typescript
+const server = createMCPServer(
+  { name: "my-server", version: "1.0.0" },
+  {
+    sessionTimeout: 30 * 60 * 1000, // 30 minutes
+    enableMessageRouting: true
+  }
+);
+
+// Listen to session events
+server.on("session:created", (session) => {
+  console.log(`Session created: ${session.sessionId}`);
+});
+
+server.on("session:closed", (session) => {
+  console.log(`Session closed: ${session.sessionId}`);
+});
+
+// Get active sessions
+const sessions = server.getActiveSessions();
+console.log(`Active sessions: ${sessions.length}`);
+
+// Manually close a session
+await server.closeSession("session-id");
+```
+
+### Message Storage and Replay
+
+```typescript
+import { createMCPServer, InMemoryMessageStorage } from "mcp-server-sdk";
+
+const server = createMCPServer(
+  { name: "my-server", version: "1.0.0" },
+  {
+    messageStorage: new InMemoryMessageStorage(),
+    enableMessageRouting: true
+  }
+);
+
+// Listen to message events
+server.on("message:stored", (message) => {
+  console.log(`Message stored: ${message.id}`);
+});
+
+// Retrieve session messages for replay
+const messages = await server.getMessages("session-id", {
+  limit: 100,
+  offset: 0
+});
+
+console.log(`Retrieved ${messages.length} messages`);
+```
+
+### Custom Message Storage
+
+Implement your own storage backend:
+
+```typescript
+import { MessageStorage, Message } from "mcp-server-sdk";
+import { createClient } from "redis";
+
+class RedisMessageStorage implements MessageStorage {
+  private client = createClient();
+
+  async store(message: Message): Promise<void> {
+    await this.client.connect();
+    const key = `messages:${message.sessionId}`;
+    await this.client.rPush(key, JSON.stringify(message));
+    await this.client.expire(key, 86400); // 24 hour TTL
+  }
+
+  async retrieve(
+    sessionId: string,
+    options?: { limit?: number; offset?: number }
+  ): Promise<Message[]> {
+    await this.client.connect();
+    const key = `messages:${sessionId}`;
+    const start = options?.offset || 0;
+    const end = start + (options?.limit || 100) - 1;
+    const data = await this.client.lRange(key, start, end);
+    return data.map((item) => JSON.parse(item));
+  }
+
+  async delete(sessionId: string): Promise<void> {
+    await this.client.connect();
+    await this.client.del(`messages:${sessionId}`);
+  }
+}
+
+const server = createMCPServer(
+  { name: "my-server", version: "1.0.0" },
+  { messageStorage: new RedisMessageStorage() }
+);
+```
+
+## API Reference
+
+### `createMCPServer(serverInfo, options)`
+
+Creates a new MCP server instance with enhanced capabilities.
+
+**Parameters:**
+- `serverInfo: Implementation` - Server metadata
+  - `name: string` - Server name (required)
+  - `version: string` - Server version (required)
+  - `title?: string` - Display title
+  - `websiteUrl?: string` - Website URL
+  - `icons?: Array` - Server icons
+- `options?: McpServerOptions` - Configuration options
+  - `instanceId?: string` - Unique server instance ID (auto-generated if omitted)
+  - `distributed?: boolean` - Enable distributed features (default: true)
+  - `messageStorage?: MessageStorage` - Message storage implementation
+  - `enableMessageRouting?: boolean` - Enable message routing (default: true)
+  - `sessionTimeout?: number` - Session timeout in ms (default: 1800000 / 30 min)
+
+**Returns:** `MCPServer`
+
+### `MCPServer`
+
+Main server class extending `McpServer` from `@modelcontextprotocol/sdk`.
+
+**Session Methods:**
+- `createSession(metadata?: Record<string, unknown>): SessionInfo` - Create a new session
+- `getSession(sessionId: string): SessionInfo | undefined` - Get session by ID
+- `updateSessionActivity(sessionId: string): void` - Update session activity timestamp
+- `closeSession(sessionId: string): Promise<void>` - Close a specific session
+- `getActiveSessions(): SessionInfo[]` - Get all active sessions
+
+**Message Methods:**
+- `storeMessage(message: Omit<Message, "id" | "timestamp">): Promise<Message>` - Store a message
+- `getMessages(sessionId: string, options?: { limit?: number; offset?: number }): Promise<Message[]>` - Retrieve messages
+
+**Connection Methods:**
+- `connect(transport: Transport): Promise<void>` - Connect to transport (standard MCP)
+- `connectWithSession(transport: Transport, sessionId?: string): Promise<SessionInfo>` - Connect with session support
+- `close(): Promise<void>` - Close all connections and sessions
+
+**Instance Methods:**
+- `getInstanceId(): string` - Get the unique instance identifier
+- `isDistributed(): boolean` - Check if distributed mode is enabled
+
+**Event Methods:**
+- `on(event: string, listener: (...args: unknown[]) => void): this` - Listen to events
+- `off(event: string, listener: (...args: unknown[]) => void): this` - Remove event listener
+
+**Inherited Methods:**
+All methods from `McpServer`:
+- `tool()` - Register tools
+- `resource()` - Register resources
+- `prompt()` - Register prompts
+- `sendLoggingMessage()` - Send log messages
+- And more...
+
+### Events
+
+**Session Events:**
+- `session:created` - Emitted when a session is created
+- `session:closed` - Emitted when a session is closed
+
+**Message Events:**
+- `message:stored` - Emitted when a message is stored
+
+### Types
+
+```typescript
+interface SessionInfo {
+  sessionId: string;
+  instanceId: string;
+  createdAt: Date;
+  lastActivity: Date;
+  metadata?: Record<string, unknown>;
+}
+
+interface Message {
+  id: string;
+  sessionId: string;
+  timestamp: Date;
+  direction: "request" | "response" | "notification";
+  payload: unknown;
+  metadata?: Record<string, unknown>;
+}
+
+interface MessageStorage {
+  store(message: Message): Promise<void>;
+  retrieve(sessionId: string, options?: { limit?: number; offset?: number }): Promise<Message[]>;
+  delete(sessionId: string): Promise<void>;
+}
+```
+
+### Built-in Storage
+
+**`InMemoryMessageStorage`**
+
+In-memory implementation of `MessageStorage` interface. Suitable for development and testing.
+
+```typescript
+import { InMemoryMessageStorage } from "mcp-server-sdk";
+
+const storage = new InMemoryMessageStorage();
+```
+
+## Use Cases
+
+### 1. HTTP/SSE MCP Server
+
+Single server instance handling multiple HTTP requests with SSE for streaming responses.
+
+### 2. WebSocket MCP Server
+
+Maintain sessions across WebSocket connections with message replay on reconnection.
+
+### 3. Distributed MCP Cluster
+
+Multiple server instances with shared session storage (e.g., Redis) for load balancing.
+
+### 4. Development and Testing
+
+In-memory storage for rapid development without external dependencies.
+
+## TypeScript Support
+
+Full TypeScript support with exported types:
+
+```typescript
+import type {
+  Implementation,
+  Transport,
+  ToolCallback,
+  RegisteredTool,
+  ResourceTemplate,
+  CallToolResult,
+  SessionInfo,
+  Message,
+  MessageStorage,
+  McpServerOptions,
+} from "mcp-server-sdk";
+```
+
+## Backward Compatibility
+
+Legacy exports are maintained for backward compatibility:
+
+```typescript
+import { DistributedMcpServer, createDistributedMcpServer } from "mcp-server-sdk";
+// Aliases for MCPServer and createMCPServer
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- `@modelcontextprotocol/sdk` >= 1.0.0
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! This SDK is designed to be extended for specific distributed use cases.
+
+## Related
+
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/sdk)
+- [Human4AI Platform](https://github.com/Human4AI/source-code)

package/dist/index.d.ts

@@ -0,0 +1,178 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { Implementation } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Session information for tracking distributed MCP connections
+ */
+export interface SessionInfo {
+    sessionId: string;
+    instanceId: string;
+    createdAt: Date;
+    lastActivity: Date;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Message for routing and storage
+ */
+export interface Message {
+    id: string;
+    sessionId: string;
+    timestamp: Date;
+    direction: "request" | "response" | "notification";
+    payload: unknown;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Message storage interface for resumability and replay
+ */
+export interface MessageStorage {
+    store(message: Message): Promise<void>;
+    retrieve(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Message[]>;
+    delete(sessionId: string): Promise<void>;
+}
+/**
+ * In-memory message storage implementation
+ */
+export declare class InMemoryMessageStorage implements MessageStorage {
+    private messages;
+    store(message: Message): Promise<void>;
+    retrieve(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Message[]>;
+    delete(sessionId: string): Promise<void>;
+}
+export interface McpServerOptions {
+    /**
+     * Unique identifier for this server instance
+     */
+    instanceId?: string;
+    /**
+     * Enable distributed mode features
+     */
+    distributed?: boolean;
+    /**
+     * Message storage implementation for resumability
+     */
+    messageStorage?: MessageStorage;
+    /**
+     * Enable message routing
+     */
+    enableMessageRouting?: boolean;
+    /**
+     * Session timeout in milliseconds (default: 30 minutes)
+     */
+    sessionTimeout?: number;
+}
+/**
+ * MCP Server SDK - Enhanced MCP server with session management and distributed capabilities
+ *
+ * Features:
+ * - Single instance server supporting multiple concurrent sessions
+ * - Per-request transport initialization
+ * - Unique distributed session tracking
+ * - Message routing and storage for resumability
+ * - Built-in session management with timeouts
+ */
+export declare class MCPServer extends McpServer {
+    private readonly instanceId;
+    private readonly distributed;
+    private readonly sessions;
+    private readonly messageStorage;
+    private readonly enableMessageRouting;
+    private readonly sessionTimeout;
+    private readonly eventEmitter;
+    constructor(serverInfo: Implementation, options?: McpServerOptions);
+    /**
+     * Get the instance ID for this server
+     */
+    getInstanceId(): string;
+    /**
+     * Check if distributed mode is enabled
+     */
+    isDistributed(): boolean;
+    /**
+     * Create a new session for a transport connection
+     */
+    createSession(metadata?: Record<string, unknown>): SessionInfo;
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId: string): SessionInfo | undefined;
+    /**
+     * Update session activity timestamp
+     */
+    updateSessionActivity(sessionId: string): void;
+    /**
+     * Close a specific session
+     */
+    closeSession(sessionId: string): Promise<void>;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): SessionInfo[];
+    /**
+     * Store a message for resumability
+     */
+    storeMessage(message: Omit<Message, "id" | "timestamp">): Promise<Message>;
+    /**
+     * Retrieve messages for a session
+     */
+    getMessages(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Message[]>;
+    /**
+     * Connect to a transport (standard MCP method)
+     */
+    connect(transport: Transport): Promise<void>;
+    /**
+     * Connect to a transport with session management
+     */
+    connectWithSession(transport: Transport, sessionId?: string): Promise<SessionInfo>;
+    /**
+     * Close the connection with session cleanup
+     */
+    close(): Promise<void>;
+    /**
+     * Listen to server events
+     */
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Remove event listener
+     */
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Generate a unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Generate a unique message ID
+     */
+    private generateMessageId;
+    /**
+     * Generate a unique instance ID
+     */
+    private generateInstanceId;
+    /**
+     * Start periodic session cleanup
+     */
+    private startSessionCleanup;
+    /**
+     * Log distributed events
+     */
+    private logDistributedEvent;
+}
+/**
+ * Create a new MCP server instance with enhanced capabilities
+ */
+export declare function createMCPServer(serverInfo: Implementation, options?: McpServerOptions): MCPServer;
+export type { ToolCallback, RegisteredTool, RegisteredResource, RegisteredPrompt, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+export type { Implementation, CallToolResult, ReadResourceResult, GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
+export type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+export type { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
+export { MCPServer as DistributedMcpServer };
+export { createMCPServer as createDistributedMcpServer };

package/dist/index.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedMcpServer = exports.MCPServer = exports.InMemoryMessageStorage = void 0;
+exports.createMCPServer = createMCPServer;
+exports.createDistributedMcpServer = createMCPServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const events_1 = require("events");
+/**
+ * In-memory message storage implementation
+ */
+class InMemoryMessageStorage {
+    constructor() {
+        this.messages = new Map();
+    }
+    async store(message) {
+        const messages = this.messages.get(message.sessionId) || [];
+        messages.push(message);
+        this.messages.set(message.sessionId, messages);
+    }
+    async retrieve(sessionId, options) {
+        const messages = this.messages.get(sessionId) || [];
+        const offset = options?.offset || 0;
+        const limit = options?.limit || messages.length;
+        return messages.slice(offset, offset + limit);
+    }
+    async delete(sessionId) {
+        this.messages.delete(sessionId);
+    }
+}
+exports.InMemoryMessageStorage = InMemoryMessageStorage;
+/**
+ * MCP Server SDK - Enhanced MCP server with session management and distributed capabilities
+ *
+ * Features:
+ * - Single instance server supporting multiple concurrent sessions
+ * - Per-request transport initialization
+ * - Unique distributed session tracking
+ * - Message routing and storage for resumability
+ * - Built-in session management with timeouts
+ */
+class MCPServer extends mcp_js_1.McpServer {
+    constructor(serverInfo, options = {}) {
+        super(serverInfo);
+        this.sessions = new Map();
+        this.eventEmitter = new events_1.EventEmitter();
+        this.instanceId = options.instanceId || this.generateInstanceId();
+        this.distributed = options.distributed ?? true;
+        this.messageStorage = options.messageStorage || new InMemoryMessageStorage();
+        this.enableMessageRouting = options.enableMessageRouting ?? true;
+        this.sessionTimeout = options.sessionTimeout || 30 * 60 * 1000; // 30 minutes
+        // Start session cleanup interval
+        this.startSessionCleanup();
+    }
+    /**
+     * Get the instance ID for this server
+     */
+    getInstanceId() {
+        return this.instanceId;
+    }
+    /**
+     * Check if distributed mode is enabled
+     */
+    isDistributed() {
+        return this.distributed;
+    }
+    /**
+     * Create a new session for a transport connection
+     */
+    createSession(metadata) {
+        const sessionId = this.generateSessionId();
+        const session = {
+            sessionId,
+            instanceId: this.instanceId,
+            createdAt: new Date(),
+            lastActivity: new Date(),
+            metadata,
+        };
+        this.sessions.set(sessionId, session);
+        this.eventEmitter.emit("session:created", session);
+        return session;
+    }
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Update session activity timestamp
+     */
+    updateSessionActivity(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastActivity = new Date();
+            this.sessions.set(sessionId, session);
+        }
+    }
+    /**
+     * Close a specific session
+     */
+    async closeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            this.sessions.delete(sessionId);
+            this.eventEmitter.emit("session:closed", session);
+            if (this.distributed) {
+                await this.logDistributedEvent("session:closed", {
+                    sessionId,
+                    instanceId: this.instanceId,
+                });
+            }
+        }
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.sessions.values());
+    }
+    /**
+     * Store a message for resumability
+     */
+    async storeMessage(message) {
+        const fullMessage = {
+            ...message,
+            id: this.generateMessageId(),
+            timestamp: new Date(),
+        };
+        if (this.enableMessageRouting) {
+            await this.messageStorage.store(fullMessage);
+            this.eventEmitter.emit("message:stored", fullMessage);
+        }
+        return fullMessage;
+    }
+    /**
+     * Retrieve messages for a session
+     */
+    async getMessages(sessionId, options) {
+        return this.messageStorage.retrieve(sessionId, options);
+    }
+    /**
+     * Connect to a transport (standard MCP method)
+     */
+    async connect(transport) {
+        return super.connect(transport);
+    }
+    /**
+     * Connect to a transport with session management
+     */
+    async connectWithSession(transport, sessionId) {
+        const session = sessionId
+            ? this.getSession(sessionId) || this.createSession()
+            : this.createSession();
+        if (this.distributed) {
+            await this.logDistributedEvent("connect", {
+                sessionId: session.sessionId,
+                instanceId: this.instanceId,
+            });
+        }
+        await super.connect(transport);
+        return session;
+    }
+    /**
+     * Close the connection with session cleanup
+     */
+    async close() {
+        // Close all sessions
+        const sessionIds = Array.from(this.sessions.keys());
+        for (const sessionId of sessionIds) {
+            await this.closeSession(sessionId);
+        }
+        if (this.distributed) {
+            await this.logDistributedEvent("close", { instanceId: this.instanceId });
+        }
+        return super.close();
+    }
+    /**
+     * Listen to server events
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+        return this;
+    }
+    /**
+     * Remove event listener
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+        return this;
+    }
+    /**
+     * Generate a unique session ID
+     */
+    generateSessionId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 15);
+        return `session-${timestamp}-${random}`;
+    }
+    /**
+     * Generate a unique message ID
+     */
+    generateMessageId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 15);
+        return `msg-${timestamp}-${random}`;
+    }
+    /**
+     * Generate a unique instance ID
+     */
+    generateInstanceId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 9);
+        return `mcp-${timestamp}-${random}`;
+    }
+    /**
+     * Start periodic session cleanup
+     */
+    startSessionCleanup() {
+        setInterval(() => {
+            const now = Date.now();
+            for (const [sessionId, session] of this.sessions.entries()) {
+                if (now - session.lastActivity.getTime() > this.sessionTimeout) {
+                    this.closeSession(sessionId).catch((error) => {
+                        console.error(`Error closing session ${sessionId}:`, error);
+                    });
+                }
+            }
+        }, 60000); // Check every minute
+    }
+    /**
+     * Log distributed events
+     */
+    async logDistributedEvent(event, data) {
+        if (this.isConnected()) {
+            await this.sendLoggingMessage({
+                level: "info",
+                data: {
+                    event,
+                    ...data,
+                    timestamp: new Date().toISOString(),
+                },
+            });
+        }
+    }
+}
+exports.MCPServer = MCPServer;
+exports.DistributedMcpServer = MCPServer;
+/**
+ * Create a new MCP server instance with enhanced capabilities
+ */
+function createMCPServer(serverInfo, options) {
+    return new MCPServer(serverInfo, options);
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "mcp-server-sdk",
+  "version": "0.2.0",
+  "description": "Enhanced MCP server SDK with session management, message routing, and distributed capabilities",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "distributed",
+    "session-management",
+    "message-routing",
+    "server",
+    "sdk",
+    "ai"
+  ],
+  "author": "Human4AI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Human4AI/source-code.git",
+    "directory": "tmp/distributed-mcp-server"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}