modality-mcp-kit 1.3.2 → 1.4.0

package/dist/FastHonoMcp.js

@@ -37,7 +37,6 @@ export class FastHonoMcp extends ModalityFastMCP {
     logger;
     config;
     sessions = new McpSessionManager();
-    currentSessionId = "";
     mcpPath = defaultMcpPath;
     constructor(config) {
         super();
@@ -61,25 +60,37 @@ export class FastHonoMcp extends ModalityFastMCP {
      * Disconnect and cleanup a session
      */
     disconnect(sessionId) {
-        const targetSession = sessionId || this.currentSessionId;
-        const disconnected = this.sessions.disconnect(targetSession);
+        const disconnected = this.sessions.disconnect(sessionId);
         if (disconnected) {
-            this.logger?.info(`Session disconnected: ${targetSession}`);
+            this.logger?.info(`Session disconnected: ${sessionId}`);
         }
         return disconnected;
     }
     /**
      * Ensure session exists, create if needed
+     * Returns the session ID to use
      */
-    ensureSession() {
-        if (!this.sessions.has(this.currentSessionId)) {
-            const session = this.sessions.create();
-            this.currentSessionId = session.id;
-            this.logger?.info(`Session connected: ${this.currentSessionId}`);
-        }
-        else {
-            this.sessions.touch(this.currentSessionId);
+    ensureSession(requestSessionId) {
+        if (requestSessionId && this.sessions.has(requestSessionId)) {
+            // Session exists, update activity
+            this.sessions.touch(requestSessionId);
+            return requestSessionId;
         }
+        // Create new session (either no ID provided or ID doesn't exist)
+        const session = this.sessions.create();
+        this.logger?.info(`Session created: ${session.id}`);
+        return session.id;
+    }
+    /**
+     * Get CORS headers for cross-origin requests
+     */
+    getCorsHeaders() {
+        return {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS, DELETE",
+            "Access-Control-Allow-Headers": "content-type,mcp-protocol-version,mcp-session-id",
+            "Access-Control-Max-Age": "86400",
+        };
     }
     handler() {
         return async (c, next) => {
@@ -90,15 +101,23 @@ export class FastHonoMcp extends ModalityFastMCP {
             if (!url.pathname.startsWith(this.mcpPath)) {
                 return next();
             }
+            // Set CORS headers once for all responses
+            const corsHeaders = this.getCorsHeaders();
+            Object.entries(corsHeaders).forEach(([key, value]) => {
+                c.header(key, value);
+            });
             try {
+                // Handle CORS preflight OPTIONS request
+                if (c.req.method === "OPTIONS" && url.pathname === this.mcpPath) {
+                    return c.body(null, 204);
+                }
                 // Handle DELETE for session disconnect
                 if (c.req.method === "DELETE" && url.pathname === this.mcpPath) {
                     const requestSessionId = c.req.header("mcp-session-id");
-                    // Validate session ID matches
-                    if (requestSessionId && requestSessionId !== this.currentSessionId) {
-                        return c.json({ error: "Session ID mismatch" }, 400);
+                    if (!requestSessionId) {
+                        return c.json({ error: "Missing mcp-session-id header" }, 400);
                     }
-                    const disconnected = this.disconnect(requestSessionId || this.currentSessionId);
+                    const disconnected = this.disconnect(requestSessionId);
                     if (disconnected) {
                         return c.body(null, 204);
                     }
@@ -106,38 +125,44 @@ export class FastHonoMcp extends ModalityFastMCP {
                 }
                 // Handle main MCP endpoint
                 if (c.req.method === "POST" && url.pathname === this.mcpPath) {
-                    // Ensure session exists (creates new one if disconnected)
-                    this.ensureSession();
-                    const headers = {
-                        "mcp-session-id": this.currentSessionId,
-                    };
+                    const requestSessionId = c.req.header("mcp-session-id");
+                    const sessionId = this.ensureSession(requestSessionId);
+                    c.header("mcp-session-id", sessionId);
                     const bodyText = await c.req.text();
                     this.logger.info("MCP Middleware Received Body", { bodyText });
-                    // Handle notifications/initialized locally (no response needed for notifications)
+                    // Handle notifications/initialized
                     try {
                         const requestData = JSON.parse(bodyText);
                         if (requestData?.method === "notifications/initialized") {
-                            return c.text(sseNotification(), 200, {
-                                ...SSE_HEADERS,
-                                ...headers,
+                            Object.entries(SSE_HEADERS).forEach(([key, value]) => {
+                                c.header(key, value);
                             });
+                            return c.text(sseNotification(), 200);
                         }
                     }
                     catch {
                         // Not valid JSON, continue with normal processing
                     }
                     // Use streaming SSE response
+                    const responseHeaders = {
+                        "mcp-session-id": sessionId,
+                        ...corsHeaders,
+                    };
                     return createSSEStream(async (writer) => {
                         const result = await createJsonRpcManager(this).validateMessage(bodyText);
-                        writer.send(result);
-                    }, headers);
+                        await writer.send(result);
+                        await writer.close();
+                    }, responseHeaders);
                 }
                 return c.json({ error: `Use ${this.mcpPath} for MCP requests` }, 400);
             }
             catch (error) {
                 this.logger.error(`FastHonoMcp (${url.pathname}) Middleware Error`, error);
                 const message = error instanceof Error ? error.message : "Internal error";
-                return c.text(sseError(null, -32603, message), 500, SSE_HEADERS);
+                Object.entries(SSE_HEADERS).forEach(([key, value]) => {
+                    c.header(key, value);
+                });
+                return c.text(sseError(null, -32603, message), 500);
             }
         };
     }

package/dist/sse-wrapper.js

@@ -15,11 +15,13 @@
 // ============================================
 /**
  * Standard SSE response headers for MCP
+ * Transfer-Encoding: chunked is required for streaming responses
  */
 export const SSE_HEADERS = {
     "Content-Type": "text/event-stream",
     "Cache-Control": "no-cache",
     "Connection": "keep-alive",
+    "Transfer-Encoding": "chunked",
 };
 // ============================================
 // CORE SSE FUNCTIONS
@@ -93,40 +95,43 @@ export function sseNotification() {
 // ============================================
 /**
  * SSE Stream writer for true streaming support
+ * Uses TransformStream with TextEncoder for HTTP-compatible byte streaming
  */
 export class SSEStreamWriter {
-    controller = null;
+    writer = null;
+    readable;
     encoder = new TextEncoder();
     closed = false;
+    constructor() {
+        const { readable, writable } = new TransformStream();
+        this.readable = readable;
+        this.writer = writable.getWriter();
+    }
     /**
-     * Create a ReadableStream for SSE responses
+     * Get the readable stream for the Response
      */
-    createStream() {
-        return new ReadableStream({
-            start: (controller) => {
-                this.controller = controller;
-            },
-            cancel: () => {
-                this.closed = true;
-                this.controller = null;
-            },
-        });
+    getReadableStream() {
+        return this.readable;
     }
     /**
-     * Send a JSON-RPC response as SSE message
+     * Write string data as encoded bytes
      */
-    send(response) {
-        if (this.closed || !this.controller)
+    async write(data) {
+        if (this.closed || !this.writer)
             return;
+        await this.writer.write(this.encoder.encode(data));
+    }
+    /**
+     * Send a JSON-RPC response as SSE message
+     */
+    async send(response) {
         const formatted = wrapAndFormatSSE(response);
-        this.controller.enqueue(this.encoder.encode(formatted));
+        await this.write(formatted);
     }
     /**
      * Send a progress notification
      */
-    sendProgress(progressToken, progress, total) {
-        if (this.closed || !this.controller)
-            return;
+    async sendProgress(progressToken, progress, total) {
         const notification = {
             jsonrpc: "2.0",
             id: null,
@@ -140,54 +145,58 @@ export class SSEStreamWriter {
             },
         };
         const formatted = wrapAndFormatSSE(notification);
-        this.controller.enqueue(this.encoder.encode(formatted));
+        await this.write(formatted);
     }
     /**
      * Send a keep-alive ping (SSE comment)
      */
-    ping() {
-        if (this.closed || !this.controller)
-            return;
-        this.controller.enqueue(this.encoder.encode(": ping\n\n"));
+    async ping() {
+        await this.write(": ping\n\n");
     }
     /**
      * Send raw SSE event
      */
-    sendEvent(event, data, id) {
-        if (this.closed || !this.controller)
-            return;
+    async sendEvent(event, data, id) {
         const sseId = id || generateSSEId();
         const formatted = `event: ${event}\nid: ${sseId}\ndata: ${JSON.stringify(data)}\n\n`;
-        this.controller.enqueue(this.encoder.encode(formatted));
+        await this.write(formatted);
     }
     /**
      * Close the stream
      */
-    close() {
-        if (this.closed || !this.controller)
+    async close() {
+        if (this.closed || !this.writer)
             return;
         this.closed = true;
-        this.controller.close();
-        this.controller = null;
+        await this.writer.close();
+        this.writer = null;
     }
     /**
      * Check if stream is still open
      */
     get isOpen() {
-        return !this.closed && this.controller !== null;
+        return !this.closed && this.writer !== null;
     }
 }
 /**
  * Create a streaming SSE response
+ *
+ * The stream lifecycle is managed as follows:
+ * - Handler sends data via writer.send()
+ * - Handler MUST call writer.close() when done sending all data
+ * - On error, an error response is sent and stream is closed
+ * - Client disconnect triggers cancel callback for cleanup
+ *
+ * IMPORTANT: The handler is responsible for calling writer.close()
+ * when it's finished sending data. Not closing will keep the connection open.
  */
 export function createSSEStream(handler, headers) {
     const writer = new SSEStreamWriter();
-    const stream = writer.createStream();
     // Execute handler asynchronously
-    handler(writer)
-        .catch((error) => {
+    // Handler is responsible for calling writer.close() when done
+    handler(writer).catch(async (error) => {
         if (writer.isOpen) {
-            writer.send({
+            await writer.send({
                 jsonrpc: "2.0",
                 id: null,
                 error: {
@@ -195,12 +204,11 @@ export function createSSEStream(handler, headers) {
                     message: error instanceof Error ? error.message : "Internal error",
                 },
             });
+            // Close stream on error to signal completion
+            await writer.close();
         }
-    })
-        .finally(() => {
-        writer.close();
     });
-    return new Response(stream, {
+    return new Response(writer.getReadableStream(), {
         headers: { ...SSE_HEADERS, ...headers },
     });
 }

package/dist/types/FastHonoMcp.d.ts

@@ -38,17 +38,21 @@ export declare class FastHonoMcp extends ModalityFastMCP {
     logger: ReturnType<typeof getLoggerInstance>;
     config: FastHonoMcpConfig;
     sessions: McpSessionManager;
-    private currentSessionId;
     mcpPath: string;
     constructor(config: FastHonoMcpConfig);
     initHono(app: Hono): this;
     /**
      * Disconnect and cleanup a session
      */
-    disconnect(sessionId?: string): boolean;
+    disconnect(sessionId: string): boolean;
     /**
      * Ensure session exists, create if needed
+     * Returns the session ID to use
      */
     private ensureSession;
+    /**
+     * Get CORS headers for cross-origin requests
+     */
+    private getCorsHeaders;
     handler(): MiddlewareHandler;
 }

package/dist/types/sse-wrapper.d.ts

@@ -18,11 +18,13 @@ interface SSEMessage {
 }
 /**
  * Standard SSE response headers for MCP
+ * Transfer-Encoding: chunked is required for streaming responses
  */
 export declare const SSE_HEADERS: {
     readonly "Content-Type": "text/event-stream";
     readonly "Cache-Control": "no-cache";
     readonly Connection: "keep-alive";
+    readonly "Transfer-Encoding": "chunked";
 };
 /**
  * Wrap a JSON-RPC response in SSE format
@@ -50,35 +52,42 @@ export declare function sseError(id: JSONRPCId, code: number, message: string, d
 export declare function sseNotification(): string;
 /**
  * SSE Stream writer for true streaming support
+ * Uses TransformStream with TextEncoder for HTTP-compatible byte streaming
  */
 export declare class SSEStreamWriter {
-    private controller;
+    private writer;
+    private readable;
     private encoder;
     private closed;
+    constructor();
     /**
-     * Create a ReadableStream for SSE responses
+     * Get the readable stream for the Response
      */
-    createStream(): ReadableStream<Uint8Array>;
+    getReadableStream(): ReadableStream<Uint8Array>;
+    /**
+     * Write string data as encoded bytes
+     */
+    private write;
     /**
      * Send a JSON-RPC response as SSE message
      */
-    send(response: JSONRPCResponse): void;
+    send(response: JSONRPCResponse): Promise<void>;
     /**
      * Send a progress notification
      */
-    sendProgress(progressToken: string | number, progress: number, total?: number): void;
+    sendProgress(progressToken: string | number, progress: number, total?: number): Promise<void>;
     /**
      * Send a keep-alive ping (SSE comment)
      */
-    ping(): void;
+    ping(): Promise<void>;
     /**
      * Send raw SSE event
      */
-    sendEvent(event: string, data: unknown, id?: string): void;
+    sendEvent(event: string, data: unknown, id?: string): Promise<void>;
     /**
      * Close the stream
      */
-    close(): void;
+    close(): Promise<void>;
     /**
      * Check if stream is still open
      */
@@ -86,6 +95,15 @@ export declare class SSEStreamWriter {
 }
 /**
  * Create a streaming SSE response
+ *
+ * The stream lifecycle is managed as follows:
+ * - Handler sends data via writer.send()
+ * - Handler MUST call writer.close() when done sending all data
+ * - On error, an error response is sent and stream is closed
+ * - Client disconnect triggers cancel callback for cleanup
+ *
+ * IMPORTANT: The handler is responsible for calling writer.close()
+ * when it's finished sending data. Not closing will keep the connection open.
  */
 export declare function createSSEStream(handler: (writer: SSEStreamWriter) => Promise<void>, headers?: Record<string, string>): Response;
 export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.3.2",
+  "version": "1.4.0",
   "name": "modality-mcp-kit",
   "repository": {
     "type": "git",