/**
 * MCP Streamable HTTP Transport — 2025 MCP Spec
 *
 * Implements the MCP 2025-03-26 Streamable HTTP transport, which replaces
 * the older SSE-only transport with a single bidirectional endpoint that
 * supports both JSON responses and SSE streams from the same POST handler.
 *
 * Also adds full `resources/*` and `prompts/*` capability support through
 * the `McpResourceProvider` and `McpPromptProvider` interfaces.
 *
 * Architecture:
 *
 *   POST /mcp   — single endpoint for all JSON-RPC 2.0 traffic
 *                 • If Accept contains text/event-stream → SSE stream response
 *                 • Otherwise → immediate JSON response
 *   GET  /mcp   — optional SSE upgrade for server-initiated messages
 *   GET  /health — health check
 *   GET  /tools  — tool listing
 *
 * Zero external dependencies — uses Node.js `node:http` only.
 *
 * @module mcp-transport-http
 * @version 1.0.0
 */
import { McpCombinedBridge } from './mcp-transport-sse';
/**
 * An MCP resource — a named piece of content the server exposes to clients.
 * Resources map to `resources/list` and `resources/read` in the MCP 2025 spec.
 */
export interface McpResource {
    /** Unique URI identifying this resource, e.g. `"network-ai://blackboard/main"`. */
    uri: string;
    /** Human-readable name. */
    name: string;
    /** Optional MIME type. Defaults to `"text/plain"`. */
    mimeType?: string;
    /** Optional description shown in client UIs. */
    description?: string;
}
/** Result returned from `McpResourceProvider.read()`. */
export interface McpResourceContent {
    uri: string;
    mimeType?: string;
    /** Text content (use this OR `blob`, not both). */
    text?: string;
    /** Base64-encoded binary content. */
    blob?: string;
}
/**
 * Register an `McpResourceProvider` with `McpStreamableServer` to expose
 * resources to MCP clients via `resources/list` and `resources/read`.
 */
export interface McpResourceProvider {
    /** Return all resources this provider exposes. */
    listResources(): McpResource[];
    /**
     * Return the content for a given URI.
     * Return `null` if the URI is not handled by this provider.
     */
    readResource(uri: string): Promise<McpResourceContent | null>;
}
/** An argument a prompt accepts. */
export interface McpPromptArgument {
    name: string;
    description?: string;
    required?: boolean;
}
/** An MCP prompt — a reusable message template. */
export interface McpPrompt {
    name: string;
    description?: string;
    arguments?: McpPromptArgument[];
}
/** A single message in a prompt response. */
export interface McpPromptMessage {
    role: 'user' | 'assistant';
    content: {
        type: 'text';
        text: string;
    };
}
/** Result returned from `McpPromptProvider.getPrompt()`. */
export interface McpPromptResult {
    description?: string;
    messages: McpPromptMessage[];
}
/**
 * Register an `McpPromptProvider` with `McpStreamableServer` to expose
 * reusable prompt templates via `prompts/list` and `prompts/get`.
 */
export interface McpPromptProvider {
    listPrompts(): McpPrompt[];
    /**
     * Return rendered prompt messages for the given name and arguments.
     * Return `null` if the prompt name is not handled by this provider.
     */
    getPrompt(name: string, args: Record<string, string>): Promise<McpPromptResult | null>;
}
/** Options for `McpStreamableServer`. */
export interface McpStreamableServerOptions {
    /** TCP port. Defaults to `3002`. */
    port?: number;
    /**
     * Hostname. Defaults to `'127.0.0.1'`.
     * Set to `'0.0.0.0'` only with a non-empty `secret`.
     */
    host?: string;
    /**
     * Bearer secret for authentication. Required — server rejects all requests
     * when empty (fail-closed, CWE-306/CWE-862).
     */
    secret?: string;
    /** SSE heartbeat interval in ms. Defaults to `15000`. Set to `0` to disable. */
    heartbeatMs?: number;
}
/**
 * MCP Streamable HTTP server implementing the 2025-03-26 MCP spec.
 *
 * Endpoints:
 * - `POST /mcp`   — all JSON-RPC traffic; SSE-streamed if client sends
 *                   `Accept: text/event-stream`
 * - `GET  /mcp`   — server-initiated SSE stream (server push)
 * - `GET  /health` — health check
 * - `GET  /tools`  — tool listing JSON
 *
 * Register tool, resource, and prompt providers via the constructor or
 * `registerResource()` / `registerPrompt()`.
 *
 * @example
 * ```typescript
 * import { McpStreamableServer } from 'network-ai';
 *
 * const bridge = new McpCombinedBridge('network-ai');
 * bridge.register(new McpBlackboardBridgeAdapter(myBridge));
 *
 * const server = new McpStreamableServer(bridge, {
 *   port: 3002,
 *   secret: process.env['NETWORK_AI_MCP_SECRET']!,
 * });
 *
 * server.registerResource(new BlackboardResourceProvider(myBridge));
 * server.registerPrompt(new OrchestrationPromptProvider());
 *
 * await server.listen();
 * ```
 */
export declare class McpStreamableServer {
    private readonly _bridge;
    private readonly _opts;
    private readonly _resourceProviders;
    private readonly _promptProviders;
    private _server;
    private readonly _sseClients;
    constructor(bridge: McpCombinedBridge, options?: McpStreamableServerOptions);
    /** Register an `McpResourceProvider`. */
    registerResource(provider: McpResourceProvider): void;
    /** Register an `McpPromptProvider`. */
    registerPrompt(provider: McpPromptProvider): void;
    /** Start listening. Resolves when ready. */
    listen(): Promise<void>;
    /** Stop the server and close all SSE streams. */
    close(): Promise<void>;
    get port(): number;
    get clientCount(): number;
    /** Broadcast an event to all connected SSE clients. */
    broadcast(eventName: string, data: unknown): void;
    private _isAuthorized;
    private _unauthorized;
    private _handleRequest;
    private _handlePost;
    private _handleSseUpgrade;
    private _dispatch;
    private _handleHealth;
    private _handleTools;
    private _ok;
    private _error;
}
/**
 * Built-in `McpResourceProvider` that exposes blackboard entries as
 * `network-ai://blackboard/<key>` URIs.
 *
 * Register with `McpStreamableServer.registerResource()`.
 */
export declare class BlackboardResourceProvider implements McpResourceProvider {
    private readonly _read;
    private readonly _list;
    /**
     * @param read   Async function to read a blackboard key
     * @param list   Async function to list all blackboard keys
     */
    constructor(read: (key: string) => Promise<unknown>, list: () => Promise<string[]>);
    listResources(): McpResource[];
    readResource(uri: string): Promise<McpResourceContent | null>;
}
/**
 * Built-in `McpPromptProvider` that exposes common Network-AI orchestration
 * prompt templates to MCP clients.
 */
export declare class OrchestrationPromptProvider implements McpPromptProvider {
    listPrompts(): McpPrompt[];
    getPrompt(name: string, args: Record<string, string>): Promise<McpPromptResult | null>;
}
//# sourceMappingURL=mcp-transport-http.d.ts.map