libmodulor 0.29.0 → 0.31.0

package/dist/esm/target/lib/manifest.d.ts

@@ -1,3 +1,4 @@
+import type { UCDefLifecycle } from '../../uc/index.js';
 import type { EnumOf } from '../../utils/index.js';
 export declare const TARGETS: {
     readonly 'edge-worker-hono-server': "edge-worker-hono-server";
@@ -5,9 +6,39 @@ export declare const TARGETS: {
     readonly 'node-core-cli': "node-core-cli";
     readonly 'node-express-server': "node-express-server";
     readonly 'node-hono-server': "node-hono-server";
-    readonly 'node-mcp-server': "node-mcp-server";
+    readonly 'node-mcp-server-stdio': "node-mcp-server-stdio";
     readonly 'node-stricli-cli': "node-stricli-cli";
     readonly 'react-native-pure': "react-native-pure";
     readonly 'react-web-pure': "react-web-pure";
 };
 export type TargetName = EnumOf<typeof TARGETS>;
+export declare const TargetCapability: {
+    readonly FULL: "FULL";
+    readonly NOT_APPLICABLE: "NOT_APPLICABLE";
+    readonly PARTIAL: "PARTIAL";
+    readonly TODO: "TODO";
+};
+export type TargetCapability = EnumOf<typeof TargetCapability>;
+export interface TargetCapabilities {
+    authBasic: TargetCapability;
+    authJWT: TargetCapability;
+    authPrivKey: TargetCapability;
+    authPubKey: TargetCapability;
+    i18n: TargetCapability;
+    mcp: TargetCapability;
+    mcpOAuth: TargetCapability;
+    openapiSpec: TargetCapability;
+    streaming: TargetCapability;
+    ucAutoMounting: TargetCapability;
+    ucClientConfirm: TargetCapability;
+    ucInputFile: TargetCapability;
+    ucValidation: TargetCapability;
+}
+export declare const TARGET_CAPABILITIES_SAMPLE: TargetCapabilities;
+export interface TargetDef {
+    lifecycle: UCDefLifecycle;
+    capabilities: TargetCapabilities;
+}
+export interface TargetDefSrc {
+    DEF: TargetDef;
+}

package/dist/esm/target/lib/manifest.js

@@ -4,8 +4,29 @@ export const TARGETS = {
     'node-core-cli': 'node-core-cli',
     'node-express-server': 'node-express-server',
     'node-hono-server': 'node-hono-server',
-    'node-mcp-server': 'node-mcp-server',
+    'node-mcp-server-stdio': 'node-mcp-server-stdio',
     'node-stricli-cli': 'node-stricli-cli',
     'react-native-pure': 'react-native-pure',
     'react-web-pure': 'react-web-pure',
 };
+export const TargetCapability = {
+    FULL: 'FULL',
+    NOT_APPLICABLE: 'NOT_APPLICABLE',
+    PARTIAL: 'PARTIAL',
+    TODO: 'TODO',
+};
+export const TARGET_CAPABILITIES_SAMPLE = {
+    authBasic: TargetCapability.FULL,
+    authJWT: TargetCapability.FULL,
+    authPrivKey: TargetCapability.FULL,
+    authPubKey: TargetCapability.FULL,
+    i18n: TargetCapability.FULL,
+    mcp: TargetCapability.FULL,
+    mcpOAuth: TargetCapability.FULL,
+    openapiSpec: TargetCapability.FULL,
+    streaming: TargetCapability.FULL,
+    ucAutoMounting: TargetCapability.FULL,
+    ucClientConfirm: TargetCapability.FULL,
+    ucInputFile: TargetCapability.FULL,
+    ucValidation: TargetCapability.FULL,
+};

package/dist/esm/target/lib/mcp-server/MCPServerRequestChecker.d.ts

@@ -0,0 +1,22 @@
+import type { HTTPStatusNumber } from '../../../dt/index.js';
+import type { Configurable, SettingsManager, Worker } from '../../../std/index.js';
+import { JWTAuthenticationChecker } from '../server/JWTAuthenticationChecker.js';
+import { PublicApiKeyChecker } from '../server/PublicApiKeyChecker.js';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
+import type { ServerRequestHandlerReq } from '../server/ServerRequestHandler.js';
+interface Input {
+    req: ServerRequestHandlerReq;
+}
+interface Output {
+    status: Extract<HTTPStatusNumber, 401> | null;
+}
+type S = Pick<ServerManagerSettings, 'server_mcp_dangerously_skip_auth_check' | 'server_mcp_dangerously_skip_pub_api_key_check' | 'server_public_api_key_header_name'>;
+export declare class MCPServerRequestChecker implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private jwtAuthenticationChecker;
+    private publicApiKeyChecker;
+    private settingsManager;
+    constructor(jwtAuthenticationChecker: JWTAuthenticationChecker, publicApiKeyChecker: PublicApiKeyChecker, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ req }: Input): Promise<Output>;
+}
+export {};

package/dist/esm/target/lib/mcp-server/MCPServerRequestChecker.js

@@ -0,0 +1,71 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { logDevWarning } from '../../../error/index.js';
+import { JWTAuthenticationChecker } from '../server/JWTAuthenticationChecker.js';
+import { PublicApiKeyChecker } from '../server/PublicApiKeyChecker.js';
+let MCPServerRequestChecker = class MCPServerRequestChecker {
+    jwtAuthenticationChecker;
+    publicApiKeyChecker;
+    settingsManager;
+    constructor(jwtAuthenticationChecker, publicApiKeyChecker, settingsManager) {
+        this.jwtAuthenticationChecker = jwtAuthenticationChecker;
+        this.publicApiKeyChecker = publicApiKeyChecker;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_mcp_dangerously_skip_auth_check: this.settingsManager.get()('server_mcp_dangerously_skip_auth_check'),
+            server_mcp_dangerously_skip_pub_api_key_check: this.settingsManager.get()('server_mcp_dangerously_skip_pub_api_key_check'),
+            server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
+        };
+    }
+    async exec({ req }) {
+        const { header } = req;
+        if (this.s().server_mcp_dangerously_skip_pub_api_key_check) {
+            logDevWarning('Skipping pub api key check');
+        }
+        else {
+            await this.publicApiKeyChecker.exec({
+                checkType: 'on',
+                value: await header(this.s().server_public_api_key_header_name),
+            });
+        }
+        if (this.s().server_mcp_dangerously_skip_auth_check) {
+            logDevWarning('Skipping auth check');
+        }
+        else {
+            const authorizationHeader = await header('Authorization');
+            const auth = await this.jwtAuthenticationChecker.exec({
+                rawValue: authorizationHeader,
+            });
+            if (!auth) {
+                return {
+                    status: 401,
+                };
+            }
+        }
+        return {
+            status: null,
+        };
+    }
+};
+MCPServerRequestChecker = __decorate([
+    injectable(),
+    __param(0, inject(JWTAuthenticationChecker)),
+    __param(1, inject(PublicApiKeyChecker)),
+    __param(2, inject('SettingsManager')),
+    __metadata("design:paramtypes", [JWTAuthenticationChecker,
+        PublicApiKeyChecker, Object])
+], MCPServerRequestChecker);
+export { MCPServerRequestChecker };

package/dist/esm/target/lib/mcp-server/MCPServerRequestHandler.d.ts

@@ -0,0 +1,16 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { Configurable, SettingsManager, Worker } from '../../../std/index.js';
+import type { UCInput, UCOPIBase } from '../../../uc/index.js';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
+import { ServerRequestHandler, type ServerRequestHandlerInput } from '../server/ServerRequestHandler.js';
+type Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Omit<ServerRequestHandlerInput<I, OPI0, OPI1>, 'dangerouslySkipAuthCheck' | 'dangerouslySkipPubApiKeyCheck' | 'skipSideEffects'>;
+type Output = CallToolResult;
+type S = Pick<ServerManagerSettings, 'server_mcp_dangerously_skip_auth_check' | 'server_mcp_dangerously_skip_pub_api_key_check'>;
+export declare class MCPServerRequestHandler implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private serverRequestHandler;
+    private settingsManager;
+    constructor(serverRequestHandler: ServerRequestHandler, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, envelope, execOpts, req, res, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output>;
+}
+export {};

package/dist/esm/target/lib/mcp-server/MCPServerRequestHandler.js

@@ -0,0 +1,54 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { ServerRequestHandler, } from '../server/ServerRequestHandler.js';
+import { resError, resObj } from './funcs.js';
+let MCPServerRequestHandler = class MCPServerRequestHandler {
+    serverRequestHandler;
+    settingsManager;
+    constructor(serverRequestHandler, settingsManager) {
+        this.serverRequestHandler = serverRequestHandler;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_mcp_dangerously_skip_auth_check: this.settingsManager.get()('server_mcp_dangerously_skip_auth_check'),
+            server_mcp_dangerously_skip_pub_api_key_check: this.settingsManager.get()('server_mcp_dangerously_skip_pub_api_key_check'),
+        };
+    }
+    async exec({ appManifest, envelope, execOpts, req, res, ucd, ucManager, }) {
+        const { body, rawErr } = await this.serverRequestHandler.exec({
+            appManifest,
+            dangerouslySkipAuthCheck: this.s().server_mcp_dangerously_skip_auth_check,
+            dangerouslySkipPubApiKeyCheck: this.s().server_mcp_dangerously_skip_pub_api_key_check,
+            envelope,
+            execOpts,
+            req,
+            res,
+            skipSideEffects: true,
+            ucd,
+            ucManager,
+        });
+        if (rawErr) {
+            return resError(rawErr);
+        }
+        return resObj(body);
+    }
+};
+MCPServerRequestHandler = __decorate([
+    injectable(),
+    __param(0, inject(ServerRequestHandler)),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [ServerRequestHandler, Object])
+], MCPServerRequestHandler);
+export { MCPServerRequestHandler };

package/dist/esm/target/lib/mcp-server/consts.d.ts

@@ -0,0 +1 @@
+export declare const ABORTED_RES = "Aborted";

package/dist/esm/target/lib/mcp-server/consts.js

@@ -0,0 +1 @@
+export const ABORTED_RES = 'Aborted';

package/dist/esm/target/lib/mcp-server/funcs.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AnySchema } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ProductManifest } from '../../../product/index.js';
+import type { UC, UCDefLifecycle, UCInput, UCOPIBase, UCWording } from '../../../uc/index.js';
+import type { RegisterToolConfig } from './types.js';
+export declare function init(productManifest: ProductManifest): McpServer;
+export declare function resAborted(): CallToolResult;
+export declare function resError(err: Error): CallToolResult;
+export declare function resObj<T>(obj: T): CallToolResult;
+export declare function toolConfig<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, lifecycle: UCDefLifecycle, wording: UCWording): RegisterToolConfig;
+export declare function ucInputMCPSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, lifecycle: UCDefLifecycle): AnySchema;
+export declare function ucOutputMCPSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): AnySchema | undefined;

package/dist/esm/target/lib/mcp-server/funcs.js

@@ -0,0 +1,84 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { fromJSONSchema } from 'zod';
+import { ucInputJsonSchema } from '../json-schema/input.js';
+import { ucOutputJsonSchema } from '../json-schema/output.js';
+import { DEFAULT_VERSION } from '../shared.js';
+import { ABORTED_RES } from './consts.js';
+import { stdioToolInputSchema } from './stdio/input.js';
+export function init(productManifest) {
+    const { name, version } = productManifest;
+    return new McpServer({
+        name: name,
+        version: version ?? DEFAULT_VERSION,
+    }, { capabilities: { logging: {} } });
+}
+export function resAborted() {
+    return {
+        content: [
+            {
+                text: ABORTED_RES,
+                type: 'text',
+            },
+        ],
+    };
+}
+export function resError(err) {
+    return {
+        content: [
+            {
+                text: err.message,
+                type: 'text',
+            },
+        ],
+        isError: true,
+    };
+}
+export function resObj(obj) {
+    return {
+        content: [],
+        structuredContent: obj,
+    };
+}
+export function toolConfig(uc, lifecycle, wording) {
+    const inputSchema = ucInputMCPSchema(uc, lifecycle);
+    const outputSchema = ucOutputMCPSchema(uc);
+    const { desc, label } = wording;
+    const config = {
+        annotations: {
+            destructiveHint: uc.def.metadata.sensitive,
+        },
+        inputSchema,
+        title: label,
+    };
+    if (outputSchema) {
+        config.outputSchema = outputSchema;
+    }
+    if (desc) {
+        config.description = desc;
+    }
+    return config;
+}
+export function ucInputMCPSchema(uc, lifecycle) {
+    const jsonSchema = ucInputJsonSchema(uc);
+    switch (lifecycle) {
+        case 'client':
+            jsonSchema.properties = {
+                ...jsonSchema.properties,
+                ...stdioToolInputSchema(),
+            };
+            break;
+        case 'server':
+            // Nothing to do
+            break;
+        default:
+            lifecycle;
+    }
+    return fromJSONSchema(jsonSchema);
+}
+export function ucOutputMCPSchema(uc) {
+    const jsonSchema = ucOutputJsonSchema(uc);
+    if (!jsonSchema) {
+        return;
+    }
+    return fromJSONSchema(jsonSchema);
+}

package/dist/esm/target/lib/mcp-server/http/MCPHTTPRequestHandlerBuilder.d.ts

@@ -0,0 +1,14 @@
+import type { ProductUCsLoaderOutput } from '../../../../product/index.js';
+import type { Worker } from '../../../../std/index.js';
+import type { UCManager } from '../../../../uc/index.js';
+export interface MCPHTTPRequestHandlerBuilderInput {
+    ucs: ProductUCsLoaderOutput;
+    /**
+     * It is not injected in the handler constructor because it must be the same as the one used in ServerManager.
+     *
+     * And in some cases, this latter is specific to a context : for instance in automated tests.
+     */
+    ucManager: UCManager;
+}
+export interface MCPHTTPRequestHandlerBuilder<H extends Function> extends Worker<MCPHTTPRequestHandlerBuilderInput, H> {
+}

package/dist/esm/target/lib/mcp-server/http/MCPHTTPRequestHandlerBuilder.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/target/lib/mcp-server/http/express/MCPHTTPExpressFakeRequestHandlerBuilder.d.ts

@@ -0,0 +1,5 @@
+import type { RequestHandler } from 'express';
+import type { MCPHTTPExpressRequestHandlerBuilder } from './types.js';
+export declare class MCPHTTPExpressFakeRequestHandlerBuilder implements MCPHTTPExpressRequestHandlerBuilder {
+    exec(): RequestHandler;
+}

package/dist/esm/target/lib/mcp-server/http/express/MCPHTTPExpressFakeRequestHandlerBuilder.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+let MCPHTTPExpressFakeRequestHandlerBuilder = class MCPHTTPExpressFakeRequestHandlerBuilder {
+    exec() {
+        return async (_req, res) => {
+            res.status(200).json({});
+        };
+    }
+};
+MCPHTTPExpressFakeRequestHandlerBuilder = __decorate([
+    injectable()
+], MCPHTTPExpressFakeRequestHandlerBuilder);
+export { MCPHTTPExpressFakeRequestHandlerBuilder };

package/dist/esm/target/lib/mcp-server/http/express/MCPHTTPExpressProtocolRequestHandlerBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { RequestHandler } from 'express';
+import { WordingManager } from '../../../../../i18n/index.js';
+import type { ProductManifest } from '../../../../../product/index.js';
+import type { Logger } from '../../../../../std/index.js';
+import { MCPServerRequestChecker } from '../../MCPServerRequestChecker.js';
+import { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import type { MCPHTTPRequestHandlerBuilderInput } from '../MCPHTTPRequestHandlerBuilder.js';
+import type { MCPHTTPExpressRequestHandlerBuilder } from './types.js';
+export declare class MCPHTTPExpressProtocolRequestHandlerBuilder implements MCPHTTPExpressRequestHandlerBuilder {
+    private logger;
+    private productManifest;
+    private serverRequestChecker;
+    private serverRequestHandler;
+    private wordingManager;
+    constructor(logger: Logger, productManifest: ProductManifest, serverRequestChecker: MCPServerRequestChecker, serverRequestHandler: MCPServerRequestHandler, wordingManager: WordingManager);
+    exec({ ucs, ucManager, }: MCPHTTPRequestHandlerBuilderInput): RequestHandler;
+}

package/dist/esm/target/lib/mcp-server/http/express/MCPHTTPExpressProtocolRequestHandlerBuilder.js

@@ -0,0 +1,100 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../../../../i18n/index.js';
+import { ucMountingPoint, } from '../../../../../uc/index.js';
+import { toReq, toRes } from '../../../server-express/funcs.js';
+import { init, toolConfig } from '../../funcs.js';
+import { MCPServerRequestChecker } from '../../MCPServerRequestChecker.js';
+import { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import { ucStreamExecOpts } from '../funcs.js';
+let MCPHTTPExpressProtocolRequestHandlerBuilder = class MCPHTTPExpressProtocolRequestHandlerBuilder {
+    logger;
+    productManifest;
+    serverRequestChecker;
+    serverRequestHandler;
+    wordingManager;
+    constructor(logger, productManifest, serverRequestChecker, serverRequestHandler, wordingManager) {
+        this.logger = logger;
+        this.productManifest = productManifest;
+        this.serverRequestChecker = serverRequestChecker;
+        this.serverRequestHandler = serverRequestHandler;
+        this.wordingManager = wordingManager;
+    }
+    exec({ ucs, ucManager, }) {
+        return async (req, res) => {
+            const { status } = await this.serverRequestChecker.exec({
+                req: toReq(req),
+            });
+            if (status) {
+                res.status(status).json({});
+                return;
+            }
+            const server = init(this.productManifest);
+            const transport = new StreamableHTTPServerTransport();
+            // In Streamable HTTP, there is usually one request => one transport => one server.
+            // So there shouldn't be multiple 'stream' use cases invoked at the same time.
+            // But maintaining a Map allows us to handle this case if it occurs.
+            // This way, we have all the streams available to close them when the transport is closed.
+            const execOptss = new Map();
+            for (const uc of ucs) {
+                const { def: { ext }, } = uc;
+                const mountingPoint = ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+                const wording = this.wordingManager.uc(uc.def);
+                const config = toolConfig(uc, 'server', wording);
+                const transportType = ext?.http?.transportType ?? 'standard';
+                server.registerTool(mountingPoint, config, (input, extra) => {
+                    const execOpts = ucStreamExecOpts(this.logger, transportType, extra);
+                    if (execOpts) {
+                        execOptss.set(mountingPoint, execOpts);
+                    }
+                    return this.serverRequestHandler.exec({
+                        appManifest: uc.appManifest,
+                        envelope: 'json',
+                        execOpts,
+                        req: {
+                            ...toReq(req),
+                            bodyFromJSON: async () => input,
+                        },
+                        res: toRes(res),
+                        ucd: uc.def,
+                        ucManager,
+                    });
+                });
+            }
+            transport.onclose = async () => {
+                this.logger.trace('Transport closed => closing streams');
+                await Promise.all(execOptss.values().map((eo) => eo.stream?.onClose()));
+            };
+            res.on('close', async () => {
+                this.logger.trace('Connection closed => closing transport');
+                await transport.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        };
+    }
+};
+MCPHTTPExpressProtocolRequestHandlerBuilder = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject(MCPServerRequestChecker)),
+    __param(3, inject(MCPServerRequestHandler)),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, MCPServerRequestChecker,
+        MCPServerRequestHandler,
+        WordingManager])
+], MCPHTTPExpressProtocolRequestHandlerBuilder);
+export { MCPHTTPExpressProtocolRequestHandlerBuilder };

package/dist/esm/target/lib/mcp-server/http/express/types.d.ts

@@ -0,0 +1,3 @@
+import type { RequestHandler } from 'express';
+import type { MCPHTTPRequestHandlerBuilder } from '../MCPHTTPRequestHandlerBuilder.js';
+export type MCPHTTPExpressRequestHandlerBuilder = MCPHTTPRequestHandlerBuilder<RequestHandler>;

package/dist/esm/target/lib/mcp-server/http/express/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/target/lib/mcp-server/http/funcs.d.ts

@@ -0,0 +1,6 @@
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types.js';
+import type { TransportType } from '../../../../dt/index.js';
+import type { Logger } from '../../../../std/index.js';
+import type { UCManagerExecServerOpts, UCOPIBase } from '../../../../uc/index.js';
+export declare function ucStreamExecOpts<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(logger: Logger, transportType: TransportType, extra: RequestHandlerExtra<ServerRequest, ServerNotification>): UCManagerExecServerOpts<OPI0, OPI1> | undefined;

package/dist/esm/target/lib/mcp-server/http/funcs.js

@@ -0,0 +1,50 @@
+import { defaultStreamOnClose } from '../../../../utils/index.js';
+export function ucStreamExecOpts(logger, transportType, extra) {
+    let execOpts;
+    switch (transportType) {
+        case 'standard':
+            // Nothing to do
+            break;
+        case 'stream': {
+            let streamedOnce = false;
+            execOpts = {
+                stream: {
+                    onClose: defaultStreamOnClose(streamedOnce),
+                    onData: async (output) => {
+                        logger.trace('execOpts.stream.onData', {
+                            output: JSON.stringify(output),
+                        });
+                        streamedOnce = true;
+                        if (!output) {
+                            return;
+                        }
+                        try {
+                            await extra.sendNotification({
+                                method: 'notifications/message',
+                                params: {
+                                    data: output,
+                                    level: 'info',
+                                },
+                            });
+                        }
+                        catch (_err) {
+                            // There are cases where the client (e.g. Claude) has already closed the stream
+                            // without triggering any lifecycle method (e.g `transport.onclose` or `c.req.raw.signal.addEventListener('abort')` with hono.
+                            // Sending a notification in this case triggers an error like so : `No connection established for request ID: 1`.
+                            // So we assume it's closed and force close the stream.
+                            logger.trace('Connection already closed => force closing stream');
+                            await execOpts?.stream?.onClose();
+                        }
+                    },
+                    onDone: async () => {
+                        logger.trace('execOpts.stream.onDone');
+                    },
+                },
+            };
+            break;
+        }
+        default:
+            transportType;
+    }
+    return execOpts;
+}

package/dist/esm/target/lib/mcp-server/http/hono/MCPHTTPHonoFakeRequestHandlerBuilder.d.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareHandler } from 'hono';
+import type { MCPHTTPHonoRequestHandlerBuilder } from './types.js';
+export declare class MCPHTTPHonoFakeRequestHandlerBuilder implements MCPHTTPHonoRequestHandlerBuilder {
+    exec(): MiddlewareHandler;
+}

package/dist/esm/target/lib/mcp-server/http/hono/MCPHTTPHonoFakeRequestHandlerBuilder.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'inversify';
+let MCPHTTPHonoFakeRequestHandlerBuilder = class MCPHTTPHonoFakeRequestHandlerBuilder {
+    exec() {
+        return async (c) => {
+            return c.json({}, 200);
+        };
+    }
+};
+MCPHTTPHonoFakeRequestHandlerBuilder = __decorate([
+    injectable()
+], MCPHTTPHonoFakeRequestHandlerBuilder);
+export { MCPHTTPHonoFakeRequestHandlerBuilder };

package/dist/esm/target/lib/mcp-server/http/hono/MCPHTTPHonoProtocolRequestHandlerBuilder.d.ts

@@ -0,0 +1,17 @@
+import type { MiddlewareHandler } from 'hono';
+import { WordingManager } from '../../../../../i18n/index.js';
+import type { ProductManifest } from '../../../../../product/index.js';
+import type { Logger } from '../../../../../std/index.js';
+import { MCPServerRequestChecker } from '../../MCPServerRequestChecker.js';
+import { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import type { MCPHTTPRequestHandlerBuilderInput } from '../MCPHTTPRequestHandlerBuilder.js';
+import type { MCPHTTPHonoRequestHandlerBuilder } from './types.js';
+export declare class MCPHTTPHonoProtocolRequestHandlerBuilder implements MCPHTTPHonoRequestHandlerBuilder {
+    private logger;
+    private productManifest;
+    private serverRequestChecker;
+    private serverRequestHandler;
+    private wordingManager;
+    constructor(logger: Logger, productManifest: ProductManifest, serverRequestChecker: MCPServerRequestChecker, serverRequestHandler: MCPServerRequestHandler, wordingManager: WordingManager);
+    exec({ ucs, ucManager, }: MCPHTTPRequestHandlerBuilderInput): MiddlewareHandler;
+}