avancement planning
This commit is contained in:
+64
-127
@@ -1,85 +1,30 @@
|
||||
import { IncomingMessage, ServerResponse } from "node:http";
|
||||
import { Transport } from "../shared/transport.js";
|
||||
import { MessageExtraInfo, JSONRPCMessage, RequestId } from "../types.js";
|
||||
import { AuthInfo } from "./auth/types.js";
|
||||
export type StreamId = string;
|
||||
export type EventId = string;
|
||||
/**
|
||||
* Interface for resumability support via event storage
|
||||
* Node.js HTTP Streamable HTTP Server Transport
|
||||
*
|
||||
* This is a thin wrapper around `WebStandardStreamableHTTPServerTransport` that provides
|
||||
* compatibility with Node.js HTTP server (IncomingMessage/ServerResponse).
|
||||
*
|
||||
* For web-standard environments (Cloudflare Workers, Deno, Bun), use `WebStandardStreamableHTTPServerTransport` directly.
|
||||
*/
|
||||
export interface EventStore {
|
||||
/**
|
||||
* Stores an event for later retrieval
|
||||
* @param streamId ID of the stream the event belongs to
|
||||
* @param message The JSON-RPC message to store
|
||||
* @returns The generated event ID for the stored event
|
||||
*/
|
||||
storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId>;
|
||||
replayEventsAfter(lastEventId: EventId, { send }: {
|
||||
send: (eventId: EventId, message: JSONRPCMessage) => Promise<void>;
|
||||
}): Promise<StreamId>;
|
||||
}
|
||||
import { IncomingMessage, ServerResponse } from 'node:http';
|
||||
import { Transport } from '../shared/transport.js';
|
||||
import { AuthInfo } from './auth/types.js';
|
||||
import { MessageExtraInfo, JSONRPCMessage, RequestId } from '../types.js';
|
||||
import { WebStandardStreamableHTTPServerTransportOptions, EventStore, StreamId, EventId } from './webStandardStreamableHttp.js';
|
||||
export type { EventStore, StreamId, EventId };
|
||||
/**
|
||||
* Configuration options for StreamableHTTPServerTransport
|
||||
*
|
||||
* This is an alias for WebStandardStreamableHTTPServerTransportOptions for backward compatibility.
|
||||
*/
|
||||
export interface StreamableHTTPServerTransportOptions {
|
||||
/**
|
||||
* Function that generates a session ID for the transport.
|
||||
* The session ID SHOULD be globally unique and cryptographically secure (e.g., a securely generated UUID, a JWT, or a cryptographic hash)
|
||||
*
|
||||
* Return undefined to disable session management.
|
||||
*/
|
||||
sessionIdGenerator: (() => string) | undefined;
|
||||
/**
|
||||
* A callback for session initialization events
|
||||
* This is called when the server initializes a new session.
|
||||
* Useful in cases when you need to register multiple mcp sessions
|
||||
* and need to keep track of them.
|
||||
* @param sessionId The generated session ID
|
||||
*/
|
||||
onsessioninitialized?: (sessionId: string) => void | Promise<void>;
|
||||
/**
|
||||
* A callback for session close events
|
||||
* This is called when the server closes a session due to a DELETE request.
|
||||
* Useful in cases when you need to clean up resources associated with the session.
|
||||
* Note that this is different from the transport closing, if you are handling
|
||||
* HTTP requests from multiple nodes you might want to close each
|
||||
* StreamableHTTPServerTransport after a request is completed while still keeping the
|
||||
* session open/running.
|
||||
* @param sessionId The session ID that was closed
|
||||
*/
|
||||
onsessionclosed?: (sessionId: string) => void | Promise<void>;
|
||||
/**
|
||||
* If true, the server will return JSON responses instead of starting an SSE stream.
|
||||
* This can be useful for simple request/response scenarios without streaming.
|
||||
* Default is false (SSE streams are preferred).
|
||||
*/
|
||||
enableJsonResponse?: boolean;
|
||||
/**
|
||||
* Event store for resumability support
|
||||
* If provided, resumability will be enabled, allowing clients to reconnect and resume messages
|
||||
*/
|
||||
eventStore?: EventStore;
|
||||
/**
|
||||
* List of allowed host header values for DNS rebinding protection.
|
||||
* If not specified, host validation is disabled.
|
||||
*/
|
||||
allowedHosts?: string[];
|
||||
/**
|
||||
* List of allowed origin header values for DNS rebinding protection.
|
||||
* If not specified, origin validation is disabled.
|
||||
*/
|
||||
allowedOrigins?: string[];
|
||||
/**
|
||||
* Enable DNS rebinding protection (requires allowedHosts and/or allowedOrigins to be configured).
|
||||
* Default is false for backwards compatibility.
|
||||
*/
|
||||
enableDnsRebindingProtection?: boolean;
|
||||
}
|
||||
export type StreamableHTTPServerTransportOptions = WebStandardStreamableHTTPServerTransportOptions;
|
||||
/**
|
||||
* Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
|
||||
* It supports both SSE streaming and direct HTTP responses.
|
||||
*
|
||||
* This is a wrapper around `WebStandardStreamableHTTPServerTransport` that provides Node.js HTTP compatibility.
|
||||
* It uses the `@hono/node-server` library to convert between Node.js HTTP and Web Standard APIs.
|
||||
*
|
||||
* Usage example:
|
||||
*
|
||||
* ```typescript
|
||||
@@ -111,75 +56,67 @@ export interface StreamableHTTPServerTransportOptions {
|
||||
* - No session validation is performed
|
||||
*/
|
||||
export declare class StreamableHTTPServerTransport implements Transport {
|
||||
private sessionIdGenerator;
|
||||
private _started;
|
||||
private _streamMapping;
|
||||
private _requestToStreamMapping;
|
||||
private _requestResponseMap;
|
||||
private _initialized;
|
||||
private _enableJsonResponse;
|
||||
private _standaloneSseStreamId;
|
||||
private _eventStore?;
|
||||
private _onsessioninitialized?;
|
||||
private _onsessionclosed?;
|
||||
private _allowedHosts?;
|
||||
private _allowedOrigins?;
|
||||
private _enableDnsRebindingProtection;
|
||||
sessionId?: string;
|
||||
onclose?: () => void;
|
||||
onerror?: (error: Error) => void;
|
||||
onmessage?: (message: JSONRPCMessage, extra?: MessageExtraInfo) => void;
|
||||
constructor(options: StreamableHTTPServerTransportOptions);
|
||||
private _webStandardTransport;
|
||||
private _requestListener;
|
||||
private _requestContext;
|
||||
constructor(options?: StreamableHTTPServerTransportOptions);
|
||||
/**
|
||||
* Gets the session ID for this transport instance.
|
||||
*/
|
||||
get sessionId(): string | undefined;
|
||||
/**
|
||||
* Sets callback for when the transport is closed.
|
||||
*/
|
||||
set onclose(handler: (() => void) | undefined);
|
||||
get onclose(): (() => void) | undefined;
|
||||
/**
|
||||
* Sets callback for transport errors.
|
||||
*/
|
||||
set onerror(handler: ((error: Error) => void) | undefined);
|
||||
get onerror(): ((error: Error) => void) | undefined;
|
||||
/**
|
||||
* Sets callback for incoming messages.
|
||||
*/
|
||||
set onmessage(handler: ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined);
|
||||
get onmessage(): ((message: JSONRPCMessage, extra?: MessageExtraInfo) => void) | undefined;
|
||||
/**
|
||||
* Starts the transport. This is required by the Transport interface but is a no-op
|
||||
* for the Streamable HTTP transport as connections are managed per-request.
|
||||
*/
|
||||
start(): Promise<void>;
|
||||
/**
|
||||
* Validates request headers for DNS rebinding protection.
|
||||
* @returns Error message if validation fails, undefined if validation passes.
|
||||
* Closes the transport and all active connections.
|
||||
*/
|
||||
private validateRequestHeaders;
|
||||
close(): Promise<void>;
|
||||
/**
|
||||
* Handles an incoming HTTP request, whether GET or POST
|
||||
* Sends a JSON-RPC message through the transport.
|
||||
*/
|
||||
send(message: JSONRPCMessage, options?: {
|
||||
relatedRequestId?: RequestId;
|
||||
}): Promise<void>;
|
||||
/**
|
||||
* Handles an incoming HTTP request, whether GET or POST.
|
||||
*
|
||||
* This method converts Node.js HTTP objects to Web Standard Request/Response
|
||||
* and delegates to the underlying WebStandardStreamableHTTPServerTransport.
|
||||
*
|
||||
* @param req - Node.js IncomingMessage, optionally with auth property from middleware
|
||||
* @param res - Node.js ServerResponse
|
||||
* @param parsedBody - Optional pre-parsed body from body-parser middleware
|
||||
*/
|
||||
handleRequest(req: IncomingMessage & {
|
||||
auth?: AuthInfo;
|
||||
}, res: ServerResponse, parsedBody?: unknown): Promise<void>;
|
||||
/**
|
||||
* Handles GET requests for SSE stream
|
||||
* Close an SSE stream for a specific request, triggering client reconnection.
|
||||
* Use this to implement polling behavior during long-running operations -
|
||||
* client will reconnect after the retry interval specified in the priming event.
|
||||
*/
|
||||
private handleGetRequest;
|
||||
closeSSEStream(requestId: RequestId): void;
|
||||
/**
|
||||
* Replays events that would have been sent after the specified event ID
|
||||
* Only used when resumability is enabled
|
||||
* Close the standalone GET SSE stream, triggering client reconnection.
|
||||
* Use this to implement polling behavior for server-initiated notifications.
|
||||
*/
|
||||
private replayEvents;
|
||||
/**
|
||||
* Writes an event to the SSE stream with proper formatting
|
||||
*/
|
||||
private writeSSEEvent;
|
||||
/**
|
||||
* Handles unsupported requests (PUT, PATCH, etc.)
|
||||
*/
|
||||
private handleUnsupportedRequest;
|
||||
/**
|
||||
* Handles POST requests containing JSON-RPC messages
|
||||
*/
|
||||
private handlePostRequest;
|
||||
/**
|
||||
* Handles DELETE requests to terminate sessions
|
||||
*/
|
||||
private handleDeleteRequest;
|
||||
/**
|
||||
* Validates session ID for non-initialization requests
|
||||
* Returns true if the session is valid, false otherwise
|
||||
*/
|
||||
private validateSession;
|
||||
private validateProtocolVersion;
|
||||
close(): Promise<void>;
|
||||
send(message: JSONRPCMessage, options?: {
|
||||
relatedRequestId?: RequestId;
|
||||
}): Promise<void>;
|
||||
closeStandaloneSSEStream(): void;
|
||||
}
|
||||
//# sourceMappingURL=streamableHttp.d.ts.map
|
||||
Reference in New Issue
Block a user