@atlisp/mcp 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.1.3",
+    "version": "1.1.5",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {

package/src/atlisp-mcp.js

@@ -55,11 +55,11 @@ import rawBody from 'raw-body';
 import iconv from 'iconv-lite';
 import rateLimit from 'express-rate-limit';
 import { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
 const { decode: charsetDecode, encodingExists } = iconv;
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { SessionTransport } from './session-transport.js';
 import {
     ListToolsRequestSchema,
     CallToolRequestSchema,
@@ -79,9 +79,14 @@ import * as functionHandlers from './handlers/function-handlers.js';
 import { listResources, readResource } from './handlers/resource-handlers.js';
 import { listPrompts, getPrompt } from './handlers/prompt-handlers.js';
 import * as subMgr from './subscription-manager.js';
-import { createError, toMcpError } from './errors.js';
+import { sessionManager } from './subscription-manager.js';
+import { SseSessionManager } from './sse-session-manager.js';
+import { SseSession } from './sse-session.js';
 import config from './config.js';
 
+const mcpContext = new AsyncLocalStorage();
+const sseSessionManager = new SseSessionManager();
+
 const SERVER_CAPABILITIES = {
     tools: {},
     resources: { subscribe: true, listChanged: true },
@@ -137,6 +142,37 @@ const TOOL_HANDLERS = {
     }),
 };
 
+function getOrCreateSessionServer(sessionId) {
+  let entry = sessionServers.get(sessionId);
+  if (!entry) {
+    const server = createMcpServer();
+    const transport = new SessionTransport(sessionId);
+    server.connect(transport);
+    entry = { server, transport };
+    sessionServers.set(sessionId, entry);
+    sessionTranports.set(sessionId, transport);
+  }
+  return entry;
+}
+
+function removeSessionServer(sessionId) {
+  const entry = sessionServers.get(sessionId);
+  if (entry) {
+    entry.transport.close().catch(() => {});
+    entry.server.close().catch(() => {});
+    sessionServers.delete(sessionId);
+    sessionTranports.delete(sessionId);
+  }
+}
+
+function broadcastToAllSessions(uri) {
+  for (const [sid, entry] of sessionServers) {
+    entry.server.sendResourceUpdated({ uri }).catch(err => {
+      log(`Failed to send resource update to session ${sid}: ${err.message}`);
+    });
+  }
+}
+
 export const tools = [
     {
 	name: 'connect_cad',
@@ -311,10 +347,11 @@ async function initCadConnection() {
     }
 }
 
-let server = null;
+const sessionServers = new Map();
+const sessionTranports = new Map();
 
 export function createMcpServer() {
-    server = new Server(
+    const server = new Server(
 	{ name: SERVER_NAME, version: SERVER_VERSION },
 	{ capabilities: SERVER_CAPABILITIES }
     );
@@ -326,9 +363,14 @@ export function createMcpServer() {
 	return await handleToolCall(name, args || {});
     });
 
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-        resources: await listResources(subMgr.list())
-    }));
+    server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+        const ctx = mcpContext.getStore();
+        const sessionId = ctx?.sessionId;
+        const subscribedUris = sessionId ? subMgr.list(sessionId) : subMgr.list();
+        return {
+            resources: await listResources(subscribedUris)
+        };
+    });
 
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const { uri } = request.params;
@@ -352,13 +394,15 @@ export function createMcpServer() {
 
     server.setRequestHandler(SubscribeRequestSchema, async (request) => {
         const { uri } = request.params;
-        subMgr.subscribe(uri);
+        const ctx = mcpContext.getStore();
+        subMgr.subscribe(uri, ctx?.sessionId);
         return { success: true };
     });
 
     server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
         const { uri } = request.params;
-        subMgr.unsubscribe(uri);
+        const ctx = mcpContext.getStore();
+        subMgr.unsubscribe(uri, ctx?.sessionId);
         return { success: true };
     });
 
@@ -374,74 +418,18 @@ export function createMcpServer() {
     return server;
 }
 
-async function dispatchMcpMethod(responder, method, params, id) {
-    try {
-        if (method === 'initialize') {
-            responder({ jsonrpc: '2.0', id, result: SERVER_INFO });
-            return;
-        }
-
-        const methodHandlers = {
-            'tools/list': async () => ({ tools }),
-            'resources/list': async () => ({ resources: await listResources(subMgr.list()) }),
-            'resources/read': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                const data = await readResource(uri);
-                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(data) }] };
-            },
-            'resources/subscribe': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                subMgr.subscribe(uri);
-                return { success: true };
-            },
-            'resources/unsubscribe': async () => {
-                const uri = params?.uri;
-                if (!uri) throw createError('INVALID_PARAMS', { detail: '缺少 uri 参数' });
-                subMgr.unsubscribe(uri);
-                return { success: true };
-            },
-            'tools/call': async () => {
-                const toolName = params?.name;
-                if (!toolName) throw createError('INVALID_PARAMS', { detail: 'missing tool name' });
-                return await handleToolCall(toolName, params?.arguments || {});
-            },
-            'prompts/list': async () => ({ prompts: await listPrompts() }),
-            'prompts/get': async () => {
-                const promptName = params?.name;
-                if (!promptName) throw createError('INVALID_PARAMS', { detail: '缺少 prompt name 参数' });
-                return await getPrompt(promptName, params?.arguments || {});
-            }
-        };
-
-        const handler = methodHandlers[method];
-        if (handler) {
-            const result = await handler();
-            responder({ jsonrpc: '2.0', id, result });
-        } else {
-            responder({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
-        }
-    } catch (e) {
-        const mcpError = toMcpError(e);
-        log(`MCP error [${method}]: ${mcpError.message}`);
-        responder({ jsonrpc: '2.0', id, error: { code: -32603, message: mcpError.message } });
-    }
-}
 
-async function handleMcpRequest(session, method, params, id) {
-    await dispatchMcpMethod(
-        (response) => session.sendResponse(response),
-        method, params, id
-    );
-}
 
 export async function startServer() {
     if (config.transport === 'stdio') {
         await initCadConnection();
         const mcpServer = createMcpServer();
         const transport = new StdioServerTransport();
-        await mcpServer.connect(transport);
+        const sessionId = 'stdio-session';
+        sessionManager.createSession(sessionId);
+        await mcpContext.run({ sessionId }, async () => {
+            await mcpServer.connect(transport);
+        });
         console.error(`${SERVER_NAME} 运行在 stdio 模式`);
 
         subMgr.setNotify((uri, data) => {
@@ -502,129 +490,115 @@ export async function startServer() {
             });
         }
 
-        const mcpServer = createMcpServer();
-
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID(),
-        });
-
-        await mcpServer.connect(transport);
-        log('MCP Server connected to StreamableHTTPServerTransport');
-
         subMgr.setNotify((uri, data) => {
-            mcpServer.sendResourceUpdated({ uri }).catch(err => {
-                log(`Failed to send resource update: ${err.message}`);
-            });
+            broadcastToAllSessions(uri);
+            for (const session of sseSessionManager.listActive()) {
+                sseSessionManager.sendToClient(session.clientId, 'resource_updated', { uri });
+            }
         });
 
-        app.all('/mcp', mcpLimiter, async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`Transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
+        async function handleMcpPost(req, res) {
+            const sessionId = req.headers['mcp-session-id'] || req.query.sessionId || randomUUID();
+            sessionManager.createSession(sessionId);
+            const body = req.body;
+            if (!body || !body.method) {
+                return res.status(400).json({ error: 'Invalid request' });
             }
-        });
 
-        app.all('/mcp/:path', mcpLimiter, async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`Transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
+            const { server, transport } = getOrCreateSessionServer(sessionId);
+            transport.resetCleanupTimer();
+
+            await mcpContext.run({ sessionId }, async () => {
+                try {
+                    const response = await transport.handleRequest(body);
+                    if (response) {
+                        const headers = { 'Content-Type': 'application/json' };
+                        if (transport.sessionId) {
+                            headers['mcp-session-id'] = transport.sessionId;
+                        }
+                        res.writeHead(200, headers);
+                        res.end(JSON.stringify(response));
+                    } else {
+                        if (!res.headersSent) {
+                            res.status(202).end();
+                        }
+                    }
+                } catch (error) {
+                    log(`Transport error [${sessionId}]: ${error.message}`);
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: 'Internal server error', message: error.message });
+                    }
                 }
-            }
-        });
+            });
+        }
+
+        app.all('/mcp', mcpLimiter, handleMcpPost);
+        app.all('/mcp/:path', mcpLimiter, handleMcpPost);
+        app.get('/mcp/stream', mcpLimiter, handleMcpPost);
 
         const sseEndpoint = '/sse';
         app.get(sseEndpoint, async (req, res) => {
-            const sseTransport = new SSEServerTransport(sseEndpoint, res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`SSE transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
-        app.post(sseEndpoint, mcpLimiter, async (req, res) => {
-            const sessionId = req.headers['mcp-session-id'];
-            const sseTransport = sessionId ? sseEndpoint + '?sessionId=' + sessionId : sseEndpoint;
-            try {
-                const transport = new SSEServerTransport(sseEndpoint, res);
-                await mcpServer.connect(transport);
-                await transport.handleRequest(req, res);
-            } catch (error) {
-                log(`SSE POST error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
+            const sessionId = randomUUID();
+            sessionManager.createSession(sessionId);
+            getOrCreateSessionServer(sessionId);
 
-        app.get('/mcp/sse', async (req, res) => {
-            const sseTransport = new SSEServerTransport('/mcp/sse', res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/mcp/sse transport error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
-        app.post('/mcp/sse', mcpLimiter, async (req, res) => {
-            const sseTransport = new SSEServerTransport('/mcp/sse', res);
-            try {
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/mcp/sse POST error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
-        });
+            const sseSession = new SseSession(res, { clientId: sessionId });
+            sseSessionManager.add(sessionId, sseSession);
 
-        app.get('/mcp/stream', async (req, res) => {
-            try {
-                await transport.handleRequest(req, res, req.body);
-            } catch (error) {
-                log(`/mcp/stream error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
-                }
-            }
+            sseSession.sendEndpoint(`/message?sessionId=${sessionId}`);
+
+            req.on('close', () => {
+                sseSessionManager.remove(sessionId);
+                removeSessionServer(sessionId);
+            });
         });
 
         app.post('/message', mcpLimiter, async (req, res) => {
-            try {
-                const sessionId = req.headers['mcp-session-id'];
-                const sseTransport = new SSEServerTransport('/message', res);
-                await mcpServer.connect(sseTransport);
-                await sseTransport.handleRequest(req, res);
-            } catch (error) {
-                log(`/message error: ${error.message}`);
-                if (!res.headersSent) {
-                    res.status(500).json({ error: 'Internal server error' });
+            const sessionId = req.query.sessionId;
+            if (!sessionId) {
+                return res.status(400).json({ error: 'Missing sessionId' });
+            }
+            const sseSession = sseSessionManager.get(sessionId);
+            if (!sseSession) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            sessionManager.createSession(sessionId);
+            const { server, transport } = getOrCreateSessionServer(sessionId);
+            transport.resetCleanupTimer();
+
+            const body = req.body;
+            if (body && body.method) {
+                try {
+                    const response = await transport.handleRequest(body);
+                    if (response) {
+                        sseSession.sendResponse(response);
+                    }
+                    if (!res.headersSent) {
+                        res.status(202).end();
+                    }
+                } catch (error) {
+                    log(`SSE message error [${sessionId}]: ${error.message}`);
+                    if (!res.headersSent) {
+                        res.status(500).json({ error: 'Internal server error' });
+                    }
                 }
+            } else {
+                res.status(400).json({ error: 'Invalid request' });
             }
         });
 
         const httpServer = app.listen(config.port, config.host, async () => {
             await initCadConnection();
-            console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} - Streamable HTTP (SDK)`);
+            console.error(`@lisp MCP Server 启动 - http://${config.host}:${config.port} (多会话模式)`);
         });
 
         async function shutdown(signal) {
             console.error(`\n收到 ${signal}，正在优雅关闭...`);
-            await transport.close();
+            sseSessionManager.closeAll();
+            sessionManager.clear();
+            for (const [sid] of sessionServers) {
+                removeSessionServer(sid);
+            }
             await cad.disconnect();
             closeLog();
             httpServer.close(() => process.exit(0));

package/src/cad-worker.js

@@ -244,10 +244,11 @@ process.stdin.on('data', (data) => {
     if (!line.trim()) continue;
     try {
       const msg = JSON.parse(line);
+      const requestId = msg.requestId;
       handleMessage(msg).then(result => {
-        process.stdout.write(JSON.stringify(result) + '\n');
+        process.stdout.write(JSON.stringify({ ...result, requestId }) + '\n');
       }).catch(err => {
-        process.stdout.write(JSON.stringify({ error: err.message }) + '\n');
+        process.stdout.write(JSON.stringify({ error: err.message, requestId }) + '\n');
       });
     } catch (e) {
       process.stdout.write(JSON.stringify({ error: 'invalid message' }) + '\n');

package/src/cad.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { randomUUID } from 'crypto';
 import { CAD_PLATFORMS, FILE_EXTENSIONS } from './constants.js';
 import config from './config.js';
 
@@ -15,8 +16,19 @@ let _platform = null;
 let _version = null;
 
 let heartbeatTimer = null;
+const pendingRequests = new Map();
+let stdoutHandlerSetup = false;
+
+const MAX_BUFFER_SIZE = 1024 * 1024;
 
 export function resetWorker() {
+  for (const [id, { reject, timeout }] of pendingRequests) {
+    clearTimeout(timeout);
+    reject(new Error('Worker reset'));
+  }
+  pendingRequests.clear();
+  stdoutHandlerSetup = false;
+
   if (worker) {
     worker.kill();
     worker = null;
@@ -27,6 +39,43 @@ export function resetWorker() {
   }
 }
 
+function setupStdoutHandler(w) {
+  let buffer = '';
+  stdoutHandlerSetup = true;
+
+  w.stdout.on('data', (data) => {
+    try {
+      buffer += data.toString();
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        buffer = buffer.slice(-MAX_BUFFER_SIZE);
+      }
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const result = JSON.parse(line);
+          const rid = result.requestId;
+          if (rid && pendingRequests.has(rid)) {
+            const { resolve, reject, timeout } = pendingRequests.get(rid);
+            clearTimeout(timeout);
+            pendingRequests.delete(rid);
+            if (result.error) {
+              reject(new Error(result.error));
+            } else {
+              resolve(result);
+            }
+          }
+        } catch (parseErr) {
+          console.error('JSON parse error in worker output:', parseErr.message);
+        }
+      }
+    } catch (e) {
+      console.error('Unexpected error in worker stdout handler:', e.message);
+    }
+  });
+}
+
 export function getWorker() {
   if (!worker || !worker.connected) {
     if (worker) worker.kill();
@@ -34,18 +83,27 @@ export function getWorker() {
       stdio: ['pipe', 'pipe', 'pipe']
     });
     worker.connected = true;
-    
+
     worker.stderr.on('data', (d) => console.error('worker stderr:', d.toString()));
     const w = worker;
     w.on('exit', (code) => {
       console.error('worker exited:', code);
       if (w !== worker) return;
       w.connected = false;
+
+      for (const [id, { reject, timeout }] of pendingRequests) {
+        clearTimeout(timeout);
+        reject(new Error(`Worker exited with code ${code}`));
+      }
+      pendingRequests.clear();
+      stdoutHandlerSetup = false;
+
       if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
         heartbeatTimer = null;
       }
     });
+    setupStdoutHandler(w);
     startHeartbeat();
   }
   return worker;
@@ -68,53 +126,26 @@ function startHeartbeat() {
 }
 
 export function sendMessage(msg) {
-  return new Promise((resolve, reject) => {
-    const w = getWorker();
-    let responded = false;
-    let buffer = '';
+  const w = getWorker();
+  const requestId = randomUUID();
 
+  return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
-      if (!responded) {
-        responded = true;
+      const pending = pendingRequests.get(requestId);
+      if (pending) {
+        pendingRequests.delete(requestId);
         reject(new Error('Timeout waiting for worker'));
       }
     }, MESSAGE_TIMEOUT);
 
-    const handler = (data) => {
-      try {
-        buffer += data.toString();
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const result = JSON.parse(line);
-            if (result.error) {
-              if (!responded) {
-                responded = true;
-                clearTimeout(timeout);
-                w.stdout.off('data', handler);
-                reject(new Error(result.error));
-              }
-            } else {
-              if (!responded) {
-                responded = true;
-                clearTimeout(timeout);
-                w.stdout.off('data', handler);
-                resolve(result);
-              }
-            }
-          } catch (parseErr) {
-            console.error('JSON parse error in worker output:', parseErr.message, 'line:', line.slice(0, 200));
-          }
-        }
-      } catch (e) {
-        console.error('Unexpected error in worker stdout handler:', e.message);
-      }
-    };
-
-    w.stdout.on('data', handler);
-    w.stdin.write(JSON.stringify(msg) + '\n');
+    pendingRequests.set(requestId, { resolve, reject, timeout });
+    try {
+      w.stdin.write(JSON.stringify({ ...msg, requestId }) + '\n');
+    } catch (e) {
+      clearTimeout(timeout);
+      pendingRequests.delete(requestId);
+      reject(new Error(`Failed to write to worker: ${e.message}`));
+    }
   });
 }
 

package/src/session-manager.js

@@ -0,0 +1,89 @@
+export class Session {
+  constructor(clientId) {
+    this.clientId = clientId;
+    this.subscriptions = new Set();
+    this.createdAt = Date.now();
+    this.connected = false;
+  }
+}
+
+export class SessionManager {
+  #sessions = new Map();
+
+  createSession(clientId) {
+    let session = this.#sessions.get(clientId);
+    if (!session) {
+      session = new Session(clientId);
+      this.#sessions.set(clientId, session);
+    }
+    return session;
+  }
+
+  getSession(clientId) {
+    return this.#sessions.get(clientId) || null;
+  }
+
+  hasSession(clientId) {
+    return this.#sessions.has(clientId);
+  }
+
+  removeSession(clientId) {
+    return this.#sessions.delete(clientId);
+  }
+
+  subscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      session.subscriptions.add(uri);
+      return true;
+    }
+    return false;
+  }
+
+  unsubscribe(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    if (session) {
+      return session.subscriptions.delete(uri);
+    }
+    return false;
+  }
+
+  getSubscriptions(clientId) {
+    const session = this.#sessions.get(clientId);
+    return session ? Array.from(session.subscriptions) : [];
+  }
+
+  isSubscribed(clientId, uri) {
+    const session = this.#sessions.get(clientId);
+    return session ? session.subscriptions.has(uri) : false;
+  }
+
+  getAllSubscribedUris() {
+    const all = new Set();
+    for (const session of this.#sessions.values()) {
+      for (const uri of session.subscriptions) {
+        all.add(uri);
+      }
+    }
+    return all;
+  }
+
+  list() {
+    return Array.from(this.#sessions.entries()).map(([id, s]) => ({
+      clientId: id,
+      subscriptions: Array.from(s.subscriptions),
+      createdAt: s.createdAt,
+      connected: s.connected
+    }));
+  }
+
+  count() {
+    return this.#sessions.size;
+  }
+
+  clear() {
+    this.#sessions.clear();
+  }
+}
+
+export default SessionManager;

package/src/session-transport.js

@@ -0,0 +1,89 @@
+import { randomUUID } from 'crypto';
+
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+
+export class SessionTransport {
+  constructor(sessionId) {
+    this.sessionId = sessionId || randomUUID();
+    this.onclose = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this._pendingRequest = null;
+    this._started = false;
+    this._closed = false;
+    this._cleanupTimer = null;
+  }
+
+  async start() {
+    if (this._started) {
+      throw new Error('Transport already started');
+    }
+    this._started = true;
+  }
+
+  async send(message) {
+    if (this._closed) return;
+    if (this._pendingRequest) {
+      const { resolve, reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      resolve(message);
+    }
+  }
+
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pendingRequest) {
+      const { reject, timeout } = this._pendingRequest;
+      clearTimeout(timeout);
+      this._pendingRequest = null;
+      reject(new Error('Transport closed'));
+    }
+    this._clearCleanupTimer();
+    this.onclose?.();
+  }
+
+  async handleRequest(message, timeoutMs = 60000) {
+    if (this._closed) {
+      throw new Error('Transport closed');
+    }
+
+    if (!message || !message.method) {
+      throw new Error('Invalid message');
+    }
+
+    if (!message.id) {
+      this.onmessage?.(message);
+      return null;
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (this._pendingRequest?.resolve === resolve) {
+          this._pendingRequest = null;
+          reject(new Error('Request timeout'));
+        }
+      }, timeoutMs);
+
+      this._pendingRequest = { resolve, reject, timeout };
+      this.onmessage?.(message);
+    });
+  }
+
+  resetCleanupTimer() {
+    this._clearCleanupTimer();
+    this._cleanupTimer = setTimeout(() => {
+      this.close();
+    }, SESSION_TIMEOUT);
+  }
+
+  _clearCleanupTimer() {
+    if (this._cleanupTimer) {
+      clearTimeout(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+  }
+}
+
+export default SessionTransport;

package/src/subscription-manager.js

@@ -1,25 +1,38 @@
-const subscriptions = new Map();
+import { SessionManager } from './session-manager.js';
+
+const sessionManager = new SessionManager();
 let _notifyFn = null;
 
 export function setNotify(fn) {
     _notifyFn = fn;
 }
 
-export function subscribe(uri) {
-    subscriptions.set(uri, Date.now());
+export function subscribe(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.subscribe(sessionId, uri);
+    }
     return true;
 }
 
-export function unsubscribe(uri) {
-    return subscriptions.delete(uri);
+export function unsubscribe(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.unsubscribe(sessionId, uri);
+    }
+    return true;
 }
 
-export function list() {
-    return Array.from(subscriptions.keys());
+export function list(sessionId) {
+    if (sessionId) {
+        return sessionManager.getSubscriptions(sessionId);
+    }
+    return Array.from(sessionManager.getAllSubscribedUris());
 }
 
-export function isSubscribed(uri) {
-    return subscriptions.has(uri);
+export function isSubscribed(uri, sessionId) {
+    if (sessionId) {
+        return sessionManager.isSubscribed(sessionId, uri);
+    }
+    return sessionManager.getAllSubscribedUris().has(uri);
 }
 
 export function notify(uri, data) {
@@ -29,9 +42,11 @@ export function notify(uri, data) {
 }
 
 export function clear() {
-    subscriptions.clear();
+    sessionManager.clear();
 }
 
 export function size() {
-    return subscriptions.size;
-}
+    return sessionManager.count();
+}
+
+export { sessionManager };