@tmcp/transport-http 0.7.0 → 0.8.0

package/README.md

@@ -135,10 +135,16 @@ The HTTP transport supports custom session managers for different deployment sce
 #### In-Memory Sessions (Default)
 
 ```javascript
-import { InMemorySessionManager } from '@tmcp/session-manager';
+import {
+	InMemoryStreamSessionManager,
+	InMemoryInfoSessionManager,
+} from '@tmcp/session-manager';
 
 const transport = new HttpTransport(server, {
-	sessionManager: new InMemorySessionManager(), // Default behavior
+	sessionManager: {
+		streams: new InMemoryStreamSessionManager(),
+		info: new InMemoryInfoSessionManager(),
+	},
 });
 ```
 
@@ -147,10 +153,16 @@ const transport = new HttpTransport(server, {
 For deployments across multiple servers or serverless environments where sessions need to be shared:
 
 ```javascript
-import { RedisSessionManager } from '@tmcp/session-manager-redis';
+import {
+	RedisStreamSessionManager,
+	RedisInfoSessionManager,
+} from '@tmcp/session-manager-redis';
 
 const transport = new HttpTransport(server, {
-	sessionManager: new RedisSessionManager('redis://localhost:6379'),
+	sessionManager: {
+		streams: new RedisStreamSessionManager('redis://localhost:6379'),
+		info: new RedisInfoSessionManager('redis://localhost:6379'),
+	},
 });
 ```
 
@@ -170,6 +182,7 @@ const transport = new HttpTransport(server, {
 - **⚡ Real-time Updates**: Server can push notifications and updates to connected clients
 - **🛡️ Error Handling**: Graceful error handling for malformed requests
 - **🔀 Multiple HTTP Methods**: Supports GET (notifications), POST (messages), and DELETE (disconnect)
+- **🧠 Session Metadata**: Automatically persists client capabilities, info, and log levels and exposes them via `server.ctx.sessionInfo`
 
 ## API
 
@@ -195,10 +208,15 @@ interface HttpTransportOptions {
 	getSessionId: () => string; // Custom session ID generator
 	path?: string | null; // MCP endpoint path (default: '/mcp', null responds on every path)
 	oauth?: OAuth; // an oauth provider generated from @tmcp/auth
-	sessionManager?: SessionManager; // Custom session manager (default: InMemorySessionManager)
+	sessionManager?: {
+		streams?: StreamSessionManager;
+		info?: InfoSessionManager;
+	}; // Provide custom managers; defaults to in-memory implementations
 }
 ```
 
+If you omit `sessionManager` the transport creates `InMemoryStreamSessionManager` and `InMemoryInfoSessionManager` instances for you. You can override either field independently (for example, Redis streams with in-memory metadata during development).
+
 #### Methods
 
 ##### `respond(request: Request, customContext?: T): Promise<Response | null>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmcp/transport-http",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Transport for TMCP using HTTP",
   "type": "module",
   "main": "src/index.js",
@@ -16,7 +16,13 @@
     "src/**/*"
   ],
   "peerDependencies": {
-    "tmcp": "^1.15.1"
+    "tmcp": "^1.16.0",
+    "@tmcp/auth": "^0.3.3"
+  },
+  "peerDependenciesMeta": {
+    "@tmcp/auth": {
+      "optional": true
+    }
   },
   "keywords": [
     "tmcp",
@@ -30,19 +36,19 @@
   },
   "dependencies": {
     "esm-env": "^1.2.2",
-    "@tmcp/session-manager": "^0.1.2"
+    "@tmcp/session-manager": "^0.2.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.17.1",
-    "@remix-run/node-fetch-server": "^0.10.0",
+    "@remix-run/node-fetch-server": "^0.11.0",
     "@types/node": "^24.0.15",
     "dts-buddy": "^0.6.2",
     "publint": "^0.3.12",
     "valibot": "^1.1.0",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.0",
     "@tmcp/adapter-valibot": "^0.1.4",
     "@tmcp/auth": "^0.3.3",
-    "tmcp": "^1.15.1"
+    "tmcp": "^1.16.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.js

@@ -1,7 +1,7 @@
 /**
  * @import { AuthInfo, McpServer } from "tmcp";
  * @import { OAuth  } from "@tmcp/auth";
- * @import { SessionManager  } from "@tmcp/session-manager";
+ * @import { StreamSessionManager, InfoSessionManager } from "@tmcp/session-manager";
  */
 
 /**
@@ -21,25 +21,32 @@
  * 	path?: string | null
  * 	oauth?: OAuth<"built">
  * 	cors?: CorsConfig | boolean,
- * 	sessionManager?: SessionManager
+ * 	sessionManager?: { streams?: StreamSessionManager, info?: InfoSessionManager }
  * }} HttpTransportOptions
  */
 
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { InMemorySessionManager } from '@tmcp/session-manager';
+import {
+	InMemoryStreamSessionManager,
+	InMemoryInfoSessionManager,
+} from '@tmcp/session-manager';
 import { DEV } from 'esm-env';
 
 /**
  * @template {Record<string, unknown> | undefined} [TCustom=undefined]
  */
 export class HttpTransport {
+	/**
+	 * @typedef {NonNullable<Required<Pick<HttpTransportOptions, "sessionManager">["sessionManager"]>>} SessionManager
+	 */
+
 	/**
 	 * @type {McpServer<any, TCustom>}
 	 */
 	#server;
 
 	/**
-	 * @type {Required<Omit<HttpTransportOptions, 'oauth' | 'cors'>> & { cors?: CorsConfig | boolean }}
+	 * @type {Required<Omit<HttpTransportOptions, 'oauth' | 'cors' | 'sessionManager'>> & { cors?: CorsConfig | boolean, sessionManager: SessionManager }}
 	 */
 	#options;
 
@@ -53,6 +60,11 @@ export class HttpTransport {
 	 */
 	#controller_storage = new AsyncLocalStorage();
 
+	/**
+	 * @type {AsyncLocalStorage<string>}
+	 */
+	#session_id_storage = new AsyncLocalStorage();
+
 	/**
 	 * @type {OAuth<"built"> | undefined}
 	 */
@@ -72,11 +84,23 @@ export class HttpTransport {
 			path = '/mcp',
 			oauth,
 			cors,
-			sessionManager = new InMemorySessionManager(),
+			sessionManager: _sessionManager = {
+				streams: new InMemoryStreamSessionManager(),
+				info: new InMemoryInfoSessionManager(),
+			},
 		} = options ?? {
 			getSessionId: () => crypto.randomUUID(),
 		};
 
+		/**
+		 * @type {SessionManager}
+		 */
+		const sessionManager = {
+			streams:
+				_sessionManager.streams ?? new InMemoryStreamSessionManager(),
+			info: _sessionManager.info ?? new InMemoryInfoSessionManager(),
+		};
+
 		if (options?.path === undefined && DEV) {
 			// TODO: remove on 1.0.0 release
 			console.warn(
@@ -90,7 +114,47 @@ export class HttpTransport {
 
 		this.#options = { getSessionId, path, cors, sessionManager };
 		this.#path = path;
-		this.#server.on('send', async ({ request, context: { sessions } }) => {
+
+		this.#server.on('initialize', ({ capabilities, clientInfo }) => {
+			const sessionId = this.#session_id_storage.getStore();
+			if (!sessionId) return;
+			this.#options.sessionManager.info.setClientCapabilities(
+				sessionId,
+				capabilities,
+			);
+			this.#options.sessionManager.info.setClientInfo(
+				sessionId,
+				clientInfo,
+			);
+		});
+
+		this.#server.on('subscription', async ({ uri }) => {
+			const sessionId = this.#session_id_storage.getStore();
+			if (!sessionId) return;
+			this.#options.sessionManager.info.addSubscription(sessionId, uri);
+		});
+
+		this.#server.on('loglevelchange', ({ level }) => {
+			const sessionId = this.#session_id_storage.getStore();
+			if (!sessionId) return;
+			this.#options.sessionManager.info.setLogLevel(sessionId, level);
+		});
+
+		this.#server.on('broadcast', async ({ request }) => {
+			let sessions = undefined;
+			if (request.method === 'notifications/resources/updated') {
+				sessions =
+					await this.#options.sessionManager.info.getSubscriptions(
+						request.params.uri,
+					);
+			}
+			await this.#options.sessionManager.streams.send(
+				sessions,
+				'data: ' + JSON.stringify(request) + '\n\n',
+			);
+		});
+
+		this.#server.on('send', async ({ request }) => {
 			// use the current controller if the request has an id (it means it's a request and not a notification)
 			if (request.id != null) {
 				const controller = this.#controller_storage.getStore();
@@ -103,8 +167,11 @@ export class HttpTransport {
 				);
 				return;
 			}
-			await this.#options.sessionManager.send(
-				sessions,
+			const session_id = this.#session_id_storage.getStore();
+			if (!session_id) return;
+
+			await this.#options.sessionManager.streams.send(
+				[session_id],
 				'data: ' + JSON.stringify(request) + '\n\n',
 			);
 		});
@@ -197,7 +264,8 @@ export class HttpTransport {
 	 * @param {string} session_id
 	 */
 	async #handle_delete(session_id) {
-		await this.#options.sessionManager.delete(session_id);
+		await this.#options.sessionManager.streams.delete(session_id);
+		await this.#options.sessionManager.info.delete(session_id);
 		return new Response(null, {
 			status: 200,
 			headers: {
@@ -213,8 +281,9 @@ export class HttpTransport {
 	 */
 	async #handle_get(session_id) {
 		const sessions = this.#options.sessionManager;
+		const text_encoder = this.#text_encoder;
 		// If session already exists, return error
-		const existing_session = await sessions.has(session_id);
+		const existing_session = await sessions.streams.has(session_id);
 		if (existing_session) {
 			return new Response(
 				JSON.stringify({
@@ -239,10 +308,12 @@ export class HttpTransport {
 		// Create new long-lived stream for notifications
 		const stream = new ReadableStream({
 			async start(controller) {
-				await sessions.create(session_id, controller);
+				await sessions.streams.create(session_id, controller);
+				// send a comment to flush the headers immediately
+				controller.enqueue(text_encoder.encode(': connected\n\n'));
 			},
 			async cancel() {
-				await sessions.delete(session_id);
+				await sessions.streams.delete(session_id);
 			},
 		});
 
@@ -302,15 +373,35 @@ export class HttpTransport {
 				},
 			});
 
+			const session_id_storage = this.#session_id_storage;
+
 			const handle = async () => {
+				const client_capabilities =
+					await this.#options.sessionManager.info
+						.getClientCapabilities(session_id)
+						.catch(() => undefined);
+				const client_info = await this.#options.sessionManager.info
+					.getClientInfo(session_id)
+					.catch(() => undefined);
+				const log_level = await this.#options.sessionManager.info
+					.getLogLevel(session_id)
+					.catch(() => undefined);
+
 				const response = await this.#controller_storage.run(
 					controller,
 					() =>
-						this.#server.receive(body, {
-							sessionId: session_id,
-							auth: auth_info ?? undefined,
-							custom: ctx,
-						}),
+						session_id_storage.run(session_id, () =>
+							this.#server.receive(body, {
+								sessionId: session_id,
+								auth: auth_info ?? undefined,
+								sessionInfo: {
+									clientCapabilities: client_capabilities,
+									clientInfo: client_info,
+									logLevel: log_level,
+								},
+								custom: ctx,
+							}),
+						),
 				);
 
 				controller?.enqueue(
@@ -325,18 +416,21 @@ export class HttpTransport {
 
 			const messages = Array.isArray(body) ? body : [body];
 
+			const has_request = messages.some((message) => message.id != null);
+
 			// Determine status code based on response type
 			// 202 Accepted for notifications/responses, 200 OK for standard requests
-			const status = !messages.some((message) => message.id != null)
-				? 202
-				: 200;
-
-			return new Response(stream, {
-				headers: {
-					'Content-Type': 'text/event-stream',
-					'Cache-Control': 'no-cache',
-					'mcp-session-id': session_id,
-				},
+			const status = !has_request ? 202 : 200;
+
+			return new Response(has_request ? stream : null, {
+				headers: has_request
+					? {
+							'Content-Type': 'text/event-stream',
+							'Cache-Control': 'no-cache',
+							connection: 'keep-alive',
+							'mcp-session-id': session_id,
+						}
+					: undefined,
 				status,
 			});
 		} catch (error) {

package/src/types/index.d.ts

@@ -1,7 +1,7 @@
 declare module '@tmcp/transport-http' {
 	import type { McpServer } from 'tmcp';
 	import type { OAuth } from '@tmcp/auth';
-	import type { SessionManager } from '@tmcp/session-manager';
+	import type { StreamSessionManager, InfoSessionManager } from '@tmcp/session-manager';
 	export class HttpTransport<TCustom extends Record<string, unknown> | undefined = undefined> {
 		
 		constructor(server: McpServer<any, TCustom>, options?: HttpTransportOptions);
@@ -22,7 +22,10 @@ declare module '@tmcp/transport-http' {
 		path?: string | null;
 		oauth?: OAuth<"built">;
 		cors?: CorsConfig | boolean;
-		sessionManager?: SessionManager;
+		sessionManager?: {
+			streams?: StreamSessionManager;
+			info?: InfoSessionManager;
+		};
 	};
 
 	export {};

package/src/types/index.d.ts.map

@@ -10,6 +10,6 @@
 	"sourcesContent": [
 		null
 	],
-	"mappings": ";;;;cAkCaA,aAAaA",
+	"mappings": ";;;;cAqCaA,aAAaA",
 	"ignoreList": []
 }