@tmcp/transport-http 0.7.1 → 0.8.1

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.1",
+  "version": "0.8.1",
   "description": "Transport for TMCP using HTTP",
   "type": "module",
   "main": "src/index.js",
@@ -16,7 +16,13 @@
     "src/**/*"
   ],
   "peerDependencies": {
-    "tmcp": "^1.15.3"
+    "tmcp": "^1.16.3",
+    "@tmcp/auth": "^0.3.3"
+  },
+  "peerDependenciesMeta": {
+    "@tmcp/auth": {
+      "optional": true
+    }
   },
   "keywords": [
     "tmcp",
@@ -30,11 +36,11 @@
   },
   "dependencies": {
     "esm-env": "^1.2.2",
-    "@tmcp/session-manager": "^0.1.2"
+    "@tmcp/session-manager": "^0.2.1"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.17.1",
-    "@remix-run/node-fetch-server": "^0.11.0",
+    "@remix-run/node-fetch-server": "^0.12.0",
     "@types/node": "^24.0.15",
     "dts-buddy": "^0.6.2",
     "publint": "^0.3.12",
@@ -42,7 +48,7 @@
     "vitest": "^4.0.0",
     "@tmcp/adapter-valibot": "^0.1.4",
     "@tmcp/auth": "^0.3.3",
-    "tmcp": "^1.15.3"
+    "tmcp": "^1.16.3"
   },
   "publishConfig": {
     "access": "public"

package/src/index.js

@@ -1,7 +1,8 @@
 /**
  * @import { AuthInfo, McpServer } from "tmcp";
  * @import { OAuth  } from "@tmcp/auth";
- * @import { SessionManager  } from "@tmcp/session-manager";
+ * @import { StreamSessionManager, InfoSessionManager } from "@tmcp/session-manager";
+ * @import { OptionalizeSessionManager } from "./type-utils.js"
  */
 
 /**
@@ -21,25 +22,32 @@
  * 	path?: string | null
  * 	oauth?: OAuth<"built">
  * 	cors?: CorsConfig | boolean,
- * 	sessionManager?: SessionManager
+ * 	sessionManager?: { streams?: StreamSessionManager, info?: OptionalizeSessionManager<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 +61,11 @@ export class HttpTransport {
 	 */
 	#controller_storage = new AsyncLocalStorage();
 
+	/**
+	 * @type {AsyncLocalStorage<string>}
+	 */
+	#session_id_storage = new AsyncLocalStorage();
+
 	/**
 	 * @type {OAuth<"built"> | undefined}
 	 */
@@ -72,11 +85,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,24 +115,67 @@ export class HttpTransport {
 
 		this.#options = { getSessionId, path, cors, sessionManager };
 		this.#path = path;
-		this.#server.on('send', async ({ request, context: { sessions } }) => {
-			// 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();
-				if (!controller) return;
 
-				controller.enqueue(
-					this.#text_encoder.encode(
-						'data: ' + JSON.stringify(request) + '\n\n',
-					),
+		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, action }) => {
+			const sessionId = this.#session_id_storage.getStore();
+			if (!sessionId) return;
+			if (action === 'remove') {
+				this.#options.sessionManager.info.removeSubscription?.(
+					sessionId,
+					uri,
 				);
-				return;
+			} else {
+				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.send(
+			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)
+			const controller = this.#controller_storage.getStore();
+			if (!controller) return;
+
+			controller.enqueue(
+				this.#text_encoder.encode(
+					'data: ' + JSON.stringify(request) + '\n\n',
+				),
+			);
+		});
 	}
 
 	/**
@@ -197,7 +265,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: {
@@ -215,7 +284,7 @@ export class HttpTransport {
 		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({
@@ -240,12 +309,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);
 			},
 		});
 
@@ -305,15 +374,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(

package/src/type-utils.d.ts

@@ -0,0 +1,6 @@
+
+import { InfoSessionManager } from "@tmcp/session-manager";
+
+type ToOmit = 'removeSubscription';
+
+export type OptionalizeSessionManager<TInfoSessionManager extends InfoSessionManager> = Omit<TInfoSessionManager, ToOmit> & Partial<Pick<TInfoSessionManager, ToOmit>>;

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,8 +22,14 @@ declare module '@tmcp/transport-http' {
 		path?: string | null;
 		oauth?: OAuth<"built">;
 		cors?: CorsConfig | boolean;
-		sessionManager?: SessionManager;
+		sessionManager?: {
+			streams?: StreamSessionManager;
+			info?: OptionalizeSessionManager<InfoSessionManager>;
+		};
 	};
+	type ToOmit = 'removeSubscription';
+
+	type OptionalizeSessionManager<TInfoSessionManager extends InfoSessionManager> = Omit<TInfoSessionManager, ToOmit> & Partial<Pick<TInfoSessionManager, ToOmit>>;
 
 	export {};
 }

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

@@ -2,14 +2,18 @@
 	"version": 3,
 	"file": "index.d.ts",
 	"names": [
-		"HttpTransport"
+		"HttpTransport",
+		"ToOmit",
+		"OptionalizeSessionManager"
 	],
 	"sources": [
-		"../index.js"
+		"../index.js",
+		"../type-utils.d.ts"
 	],
 	"sourcesContent": [
+		null,
 		null
 	],
-	"mappings": ";;;;cAkCaA,aAAaA",
+	"mappings": ";;;;cAsCaA,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;MCnCrBC,MAAMA;;MAECC,yBAAyBA",
 	"ignoreList": []
 }