libmodulor 0.29.0 → 0.30.0

package/dist/esm/target/lib/openapi/funcs.js

@@ -1,21 +1,10 @@
-import { ERROR_HTTP_STATUS_MAP, IllegalArgumentError, } from '../../../error/index.js';
-import { DEFAULT_UC_SEC_AT, DEFAULT_UC_SEC_PAKCT, UCOutputReader, ucofExamples, } from '../../../uc/index.js';
+import { ERROR_HTTP_STATUS_MAP } from '../../../error/index.js';
+import { DEFAULT_UC_SEC_AT, DEFAULT_UC_SEC_PAKCT, } from '../../../uc/index.js';
 import { isBlank } from '../../../utils/index.js';
+import { serverErrorJsonSchema } from '../json-schema/error.js';
+import { ucifJsonSchemaDef } from '../json-schema/input.js';
+import { ucOutputJsonSchema } from '../json-schema/output.js';
 import { AUTHORIZATION_HEADER_NAME, } from '../shared.js';
-import { SUCCESS_DESCRIPTION } from './consts.js';
-import { openAPIInputDef } from './input.js';
-export function openAPIErrorSchema() {
-    return {
-        additionalProperties: false,
-        properties: {
-            message: {
-                examples: [new IllegalArgumentError().message],
-                type: 'string',
-            },
-        },
-        type: 'object',
-    };
-}
 export function openAPIErrors() {
     return ERROR_HTTP_STATUS_MAP.entries().reduce((acc, cur) => {
         const [status, clazz] = cur;
@@ -23,16 +12,7 @@ export function openAPIErrors() {
         acc[status] = {
             content: {
                 'application/json': {
-                    schema: {
-                        additionalProperties: false,
-                        properties: {
-                            message: {
-                                examples: [message],
-                                type: 'string',
-                            },
-                        },
-                        type: 'object',
-                    },
+                    schema: serverErrorJsonSchema(message),
                 },
             },
             description: message,
@@ -40,95 +20,6 @@ export function openAPIErrors() {
         return acc;
     }, {});
 }
-export function openAPIInputSchema(uc) {
-    const res = {
-        additionalProperties: false,
-        properties: {},
-        type: 'object',
-    };
-    for (const f of uc.inputFields) {
-        const { key } = f;
-        const { internal, spec } = openAPIInputDef(f);
-        if (!spec) {
-            continue;
-        }
-        const k = key;
-        res.properties[k] = spec;
-        if (!internal?.required) {
-            continue;
-        }
-        if (!res.required) {
-            res.required = [];
-        }
-        res.required.push(k);
-    }
-    return res;
-}
-export function openAPIOPISchema(part) {
-    const res = {
-        additionalProperties: false,
-        properties: {},
-        type: 'object',
-    };
-    for (const f of part.fields) {
-        const { def, key } = f;
-        const { type } = def;
-        const k = key;
-        res.properties[k] = type.jsonSchemaType();
-        const examples = ucofExamples(def);
-        if (examples) {
-            res.properties[k].examples = examples;
-        }
-    }
-    return res;
-}
-export function openAPIOutputPartSchema(part) {
-    return {
-        additionalProperties: false,
-        properties: {
-            items: {
-                items: openAPIOPISchema(part),
-                type: 'array',
-            },
-            pagination: {
-                properties: {
-                    id: { format: 'uuid', type: 'string' },
-                    limit: { type: 'integer' },
-                    offset: { type: 'integer' },
-                    q: { type: 'string' },
-                },
-                type: 'object',
-            },
-            total: { examples: [1], type: 'integer' },
-        },
-        required: ['items', 'total'],
-        type: 'object',
-    };
-}
-export function openAPIOutputSchema(uc) {
-    const res = {
-        additionalProperties: false,
-        properties: {},
-        type: 'object',
-    };
-    if (!uc.hasOutputParts()) {
-        return res;
-    }
-    const ucor = new UCOutputReader(uc.def, undefined);
-    const [part0, part1] = ucor.parts();
-    res.properties.parts = {
-        properties: {
-            _0: openAPIOutputPartSchema(part0),
-        },
-        type: 'object',
-    };
-    if (part1) {
-        res.properties.parts.properties = {
-            _1: openAPIOutputPartSchema(part1),
-        };
-    }
-    return res;
-}
 export function openAPIParameters(uc, envelope) {
     const res = [];
     switch (envelope) {
@@ -136,7 +27,7 @@ export function openAPIParameters(uc, envelope) {
             {
                 for (const f of uc.inputFields) {
                     const { key } = f;
-                    const { internal, spec } = openAPIInputDef(f);
+                    const { internal, spec } = ucifJsonSchemaDef(f);
                     if (!spec) {
                         continue;
                     }
@@ -235,15 +126,23 @@ export function openAPISecurity(sec) {
     item[authType] = [];
     return res;
 }
-export function openAPISuccess(uc) {
+export function openAPISuccess(uc, descriptions) {
+    const schema = ucOutputJsonSchema(uc);
+    if (!schema) {
+        return {
+            '204': {
+                description: descriptions[204],
+            },
+        };
+    }
     return {
         '200': {
             content: {
                 'application/json': {
-                    schema: openAPIOutputSchema(uc),
+                    schema,
                 },
             },
-            description: SUCCESS_DESCRIPTION,
+            description: descriptions[200],
         },
     };
 }

package/dist/esm/target/lib/openapi/types.d.ts

@@ -1,23 +1,12 @@
-import type { DataType, FreeTextLong, FreeTextShort, HTTPMethod, HTTPStatusNumber, JSONSchemaType, SemVerVersion, URL } from '../../../dt/index.js';
+import type { FreeTextLong, FreeTextShort, HTTPMethod, HTTPStatusNumber, JSONSchemaObject, JSONSchemaProperty, SemVerVersion, URL } from '../../../dt/index.js';
 import type { ProductName } from '../../../product/index.js';
 import type { FQUCInputName, FQUCOPI0Name, FQUCOPI1Name, UCFieldKey } from '../../../uc/index.js';
-import type { StringKeys } from '../../../utils/index.js';
 import type { AUTHORIZATION_HEADER_NAME, AuthCookieName, PublicApiKeyHeaderName } from '../shared.js';
 export type OpenAPIPathName = string;
 export type OpenAPIDescription = FreeTextLong;
 export type OpenAPISchemaName = FQUCInputName | FQUCOPI0Name | FQUCOPI1Name | `Error`;
 export type OpenAPISchemaRef = `#/components/schemas/${OpenAPISchemaName}`;
 export type OpenAPISummary = FreeTextShort;
-export type OpenAPIProperty<T extends DataType> = JSONSchemaType & {
-    enum?: T[];
-    examples?: T[];
-};
-export interface OpenAPISchema<T extends object> {
-    additionalProperties: false;
-    properties: Record<StringKeys<T>, OpenAPIProperty<any>>;
-    required?: StringKeys<T>[];
-    type: 'object';
-}
 export type OpenAPISecurityItem = Partial<Record<keyof OpenAPISecuritySchemes, []>>;
 export type OpenAPISecurity = OpenAPISecurityItem[];
 export interface OpenAPISecurityScheme {
@@ -47,14 +36,14 @@ export interface OpenAPISecuritySchemes {
 }
 export interface OpenAPIComponents {
     securitySchemes: OpenAPISecuritySchemes;
-    schemas: Record<OpenAPISchemaName, OpenAPISchema<any>>;
+    schemas: Record<OpenAPISchemaName, JSONSchemaObject<any>>;
 }
 export interface OpenAPIParameter {
     description?: OpenAPIDescription;
     in: 'path' | 'query';
     name: UCFieldKey;
     required: boolean;
-    schema: OpenAPIProperty<any>;
+    schema: JSONSchemaProperty<any>;
 }
 export interface OpenAPIPath {
     description?: OpenAPIDescription;
@@ -68,7 +57,7 @@ export interface OpenAPIPath {
 export interface OpenAPIInnerContent {
     schema: {
         $ref: OpenAPISchemaRef;
-    } | OpenAPISchema<any>;
+    } | JSONSchemaObject<any>;
 }
 export type OpenAPIContent = {
     'application/json': OpenAPIInnerContent;
@@ -87,7 +76,7 @@ export interface OpenAPIRequestBody {
 }
 export type OpenAPIPaths = Record<OpenAPIPathName, Partial<Record<Lowercase<HTTPMethod>, OpenAPIPath>>>;
 export interface OpenAPIResponse {
-    content: OpenAPIContent;
+    content?: OpenAPIContent;
     description: OpenAPIDescription;
 }
 export type OpenAPIResponses = Partial<Record<HTTPStatusNumber, OpenAPIResponse>>;

package/dist/esm/target/lib/server/ServerBooter.d.ts

@@ -5,7 +5,7 @@ import type { TargetEntrypointInput } from '../entrypoint.js';
 import { OpenAPISpecBuilder } from '../openapi/OpenAPISpecBuilder.js';
 import { ServerInstaller } from './ServerInstaller.js';
 import type { ServerManager, ServerManagerSettings } from './ServerManager.js';
-type S = Pick<ServerManagerSettings, 'server_expose_openapi_spec' | 'server_expose_openapi_spec_at' | 'server_static_dir_path' | 'server_tmp_path'>;
+type S = Pick<ServerManagerSettings, 'server_expose_mcp' | 'server_expose_mcp_at' | 'server_expose_openapi_spec' | 'server_expose_openapi_spec_at' | 'server_static_dir_path' | 'server_tmp_path'>;
 type Input = TargetEntrypointInput & {
     autoMountUCs?: boolean;
 };

package/dist/esm/target/lib/server/ServerBooter.js

@@ -43,6 +43,8 @@ let ServerBooter = class ServerBooter {
     }
     s() {
         return {
+            server_expose_mcp: this.settingsManager.get()('server_expose_mcp'),
+            server_expose_mcp_at: this.settingsManager.get()('server_expose_mcp_at'),
             server_expose_openapi_spec: this.settingsManager.get()('server_expose_openapi_spec'),
             server_expose_openapi_spec_at: this.settingsManager.get()('server_expose_openapi_spec_at'),
             server_static_dir_path: this.settingsManager.get()('server_static_dir_path'),
@@ -97,6 +99,14 @@ let ServerBooter = class ServerBooter {
             });
             await this.serverManager.mountOpenAPISpec(spec, at);
         }
+        if (this.s().server_expose_mcp) {
+            const at = this.s().server_expose_mcp_at;
+            this.logger.info('Mounting MCP', {
+                at,
+                mountedUCs: mountedUCs.length,
+            });
+            await this.serverManager.mountMCP(mountedUCs, at);
+        }
         await this.serverManager.warmUp();
         await this.serverManager.start();
     }

package/dist/esm/target/lib/server/ServerManager.d.ts

@@ -1,5 +1,6 @@
 import type { AppManifest } from '../../../app/index.js';
 import type { ApiKey, DirPath, FilePath, HostPort, HTTPMethod, Password, URL, URLPath, Username } from '../../../dt/index.js';
+import type { ProductUCsLoaderOutput } from '../../../product/index.js';
 import type { Settings } from '../../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../../uc/index.js';
 import type { HTTPCSPValue } from '../../../utils/http/types.js';
@@ -25,8 +26,12 @@ export interface ServerManagerSettings extends ServerManagerAuthSettings, Settin
     server_cors_headers: HTTPHeaderName[];
     server_cors_methods: HTTPMethod[];
     server_cors_origins: URL[];
+    server_expose_mcp: boolean;
+    server_expose_mcp_at: URLPath;
     server_expose_openapi_spec: boolean;
     server_expose_openapi_spec_at: URLPath;
+    server_mcp_dangerously_skip_pub_api_key_check: boolean;
+    server_mcp_dangerously_skip_auth_check: boolean;
     server_public_api_key_header_name: PublicApiKeyHeaderName;
     server_public_url: URL;
     server_ssl_fullchain_path: FilePath | null;
@@ -51,6 +56,11 @@ export interface ServerManager extends Initializable {
      * @param contract
      */
     mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
+    /**
+     * Mount the MCP endpoint
+     * @param spec
+     */
+    mountMCP(ucs: ProductUCsLoaderOutput, at: URLPath): Promise<void>;
     /**
      * Mount the OpenAPI spec
      * @param spec

package/dist/esm/target/lib/server/ServerRequestHandler.d.ts

@@ -26,12 +26,15 @@ export interface ServerRequestHandlerRes {
     redirect: (location: URL | URLPath) => Promise<void>;
     setCookie: (info: AuthCookieCreatorOutput) => Promise<void>;
 }
-interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+export interface ServerRequestHandlerInput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
     appManifest: AppManifest;
+    dangerouslySkipAuthCheck?: boolean | undefined;
+    dangerouslySkipPubApiKeyCheck?: boolean | undefined;
     envelope: HTTPDataEnvelope;
     execOpts?: UCManagerExecServerOpts<OPI0, OPI1> | undefined;
     req: ServerRequestHandlerReq;
     res: ServerRequestHandlerRes;
+    skipSideEffects?: boolean | undefined;
     ucd: UCDef<I, OPI0, OPI1>;
     /**
      * It is not injected in the handler constructor because it must be the same as the one used in ServerManager.
@@ -41,15 +44,18 @@ interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBas
     ucManager: UCManager;
 }
 type BodylessStatus = 204 | 302;
-type Output<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = {
+type Output<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = ({
     body: undefined;
     status: BodylessStatus;
 } | {
     body: UCOutput<OPI0, OPI1> | object;
+    rawErr?: Error;
     status: Exclude<HTTPStatusNumber, BodylessStatus>;
+}) & {
+    rawErr?: Error;
 };
 type S = Pick<ServerManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name'>;
-export declare class ServerRequestHandler implements Worker<Input, Promise<Output>> {
+export declare class ServerRequestHandler implements Worker<ServerRequestHandlerInput, Promise<Output>> {
     private authCookieCreator;
     private authenticationChecker;
     private customerFacingErrorBuilder;
@@ -58,10 +64,9 @@ export declare class ServerRequestHandler implements Worker<Input, Promise<Outpu
     private requestLogger;
     private settingsManager;
     private ucBuilder;
-    private static X_FORWARDED_PROTO_HEADER_NAME;
     constructor(authCookieCreator: AuthCookieCreator, authenticationChecker: AuthenticationChecker, customerFacingErrorBuilder: CustomerFacingErrorBuilder, publicApiKeyChecker: PublicApiKeyChecker, requestChecker: RequestChecker, requestLogger: RequestLogger, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder);
     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<OPI0, OPI1>>;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, dangerouslySkipAuthCheck, dangerouslySkipPubApiKeyCheck, envelope, execOpts, req, res, skipSideEffects, ucd, ucManager, }: ServerRequestHandlerInput<I, OPI0, OPI1>): Promise<Output<OPI0, OPI1>>;
     private fill;
     private applySideEffects;
     private applyClearAuthSideEffect;

package/dist/esm/target/lib/server/ServerRequestHandler.js

@@ -10,11 +10,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var ServerRequestHandler_1;
 import { inject, injectable } from 'inversify';
-import { IllegalArgumentError, isEmptyJSON } from '../../../error/index.js';
+import { IllegalArgumentError, isEmptyJSON, logDevWarning, } from '../../../error/index.js';
 import { UCBuilder, UCOutputReader, UCOutputSideEffectType, } from '../../../uc/index.js';
-import { AUTHORIZATION_HEADER_NAME } from '../shared.js';
+import { AUTHORIZATION_HEADER_NAME, X_FORWARDED_PROTO_HEADER_NAME, } from '../shared.js';
 import { AuthCookieCreator, } from './AuthCookieCreator.js';
 import { AuthenticationChecker } from './AuthenticationChecker.js';
 import { CustomerFacingErrorBuilder } from './CustomerFacingErrorBuilder.js';
@@ -22,7 +21,6 @@ import { PublicApiKeyChecker } from './PublicApiKeyChecker.js';
 import { RequestChecker } from './RequestChecker.js';
 import { RequestLogger } from './RequestLogger.js';
 let ServerRequestHandler = class ServerRequestHandler {
-    static { ServerRequestHandler_1 = this; }
     authCookieCreator;
     authenticationChecker;
     customerFacingErrorBuilder;
@@ -31,7 +29,6 @@ let ServerRequestHandler = class ServerRequestHandler {
     requestLogger;
     settingsManager;
     ucBuilder;
-    static X_FORWARDED_PROTO_HEADER_NAME = 'X-Forwarded-Proto';
     constructor(authCookieCreator, authenticationChecker, customerFacingErrorBuilder, publicApiKeyChecker, requestChecker, requestLogger, settingsManager, ucBuilder) {
         this.authCookieCreator = authCookieCreator;
         this.authenticationChecker = authenticationChecker;
@@ -48,7 +45,7 @@ let ServerRequestHandler = class ServerRequestHandler {
             server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
         };
     }
-    async exec({ appManifest, envelope, execOpts, req, res, ucd, ucManager, }) {
+    async exec({ appManifest, dangerouslySkipAuthCheck = false, dangerouslySkipPubApiKeyCheck = false, envelope, execOpts, req, res, skipSideEffects = false, ucd, ucManager, }) {
         try {
             const { bodyRaw, cookie, header, method, secure, url } = req;
             this.requestLogger.exec({
@@ -59,34 +56,46 @@ let ServerRequestHandler = class ServerRequestHandler {
             this.requestChecker.exec({
                 secure,
                 url,
-                xForwardedProtoHeader: await header(ServerRequestHandler_1.X_FORWARDED_PROTO_HEADER_NAME),
+                xForwardedProtoHeader: await header(X_FORWARDED_PROTO_HEADER_NAME),
             });
             const { ext, sec } = ucd;
-            await this.publicApiKeyChecker.exec({
-                checkType: sec?.publicApiKeyCheckType,
-                value: await header(this.s().server_public_api_key_header_name),
-            });
+            if (dangerouslySkipPubApiKeyCheck) {
+                logDevWarning('Skipping pub api key check');
+            }
+            else {
+                await this.publicApiKeyChecker.exec({
+                    checkType: sec?.publicApiKeyCheckType,
+                    value: await header(this.s().server_public_api_key_header_name),
+                });
+            }
             const uc = this.ucBuilder.exec({
                 appManifest,
                 auth: null,
                 def: ucd,
             });
-            const { auth } = await this.authenticationChecker.exec({
-                authCookie: await cookie(this.s().server_cookies_name_auth),
-                authorizationHeader: await header(AUTHORIZATION_HEADER_NAME),
-                uc,
-            });
-            if (auth) {
-                uc.auth = auth;
+            if (dangerouslySkipAuthCheck) {
+                logDevWarning('Skipping auth check');
+            }
+            else {
+                const { auth } = await this.authenticationChecker.exec({
+                    authCookie: await cookie(this.s().server_cookies_name_auth),
+                    authorizationHeader: await header(AUTHORIZATION_HEADER_NAME),
+                    uc,
+                });
+                if (auth) {
+                    uc.auth = auth;
+                }
             }
             await this.fill(req, envelope, uc);
             const output = await ucManager.execServer(uc, execOpts);
-            const { status } = await this.applySideEffects(res, ucd, output);
-            if (status !== undefined) {
-                return {
-                    body: undefined,
-                    status,
-                };
+            if (!skipSideEffects) {
+                const { status } = await this.applySideEffects(res, ucd, output);
+                if (status !== undefined) {
+                    return {
+                        body: undefined,
+                        status,
+                    };
+                }
             }
             if (!output) {
                 return {
@@ -106,6 +115,7 @@ let ServerRequestHandler = class ServerRequestHandler {
             });
             return {
                 body: error.toObj(),
+                rawErr: err,
                 status: error.httpStatus,
             };
         }
@@ -186,7 +196,7 @@ let ServerRequestHandler = class ServerRequestHandler {
         res.setCookie(output);
     }
 };
-ServerRequestHandler = ServerRequestHandler_1 = __decorate([
+ServerRequestHandler = __decorate([
     injectable(),
     __param(0, inject(AuthCookieCreator)),
     __param(1, inject(AuthenticationChecker)),

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

@@ -17,8 +17,12 @@ export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
     server_csp_default_src: [],
     server_csp_img_src: [],
     server_csp_script_src: [],
+    server_expose_mcp: false,
+    server_expose_mcp_at: '/mcp',
     server_expose_openapi_spec: false,
     server_expose_openapi_spec_at: '/api/openapi.json',
+    server_mcp_dangerously_skip_auth_check: false,
+    server_mcp_dangerously_skip_pub_api_key_check: false,
     server_private_api_key_entries: [],
     server_public_api_key_entries: [unsafeDefaultSetting()],
     server_public_api_key_header_name: 'X-API-Key',

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

@@ -1,7 +1,7 @@
 import cookieParser from 'cookie-parser';
 import express, {} from 'express';
 import fileUpload from 'express-fileupload';
-import { fmtSingleDataMsg, fmtSSEError, isError, SSE_HEADERS, } from '../../../utils/index.js';
+import { defaultStreamOnClose, fmtSingleDataMsg, fmtSSEError, isError, SSE_HEADERS, } from '../../../utils/index.js';
 export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager) {
     const { envelope } = contract;
     const handler = async (req, res) => {
@@ -15,11 +15,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 let streamedOnce = false;
                 execOpts = {
                     stream: {
-                        onClose: async () => {
-                            if (streamedOnce) {
-                                throw new Error('execOpts.stream.onClose needs to be set in the UC ServerMain');
-                            }
-                        },
+                        onClose: defaultStreamOnClose(streamedOnce),
                         onData: async (output) => {
                             streamedOnce = true;
                             if (!output) {

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

@@ -3,7 +3,7 @@ import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
 import { logger } from 'hono/logger';
 import { secureHeaders } from 'hono/secure-headers';
 import { NotFoundError } from '../../../error/index.js';
-import { fmtSingleDataMsg, fmtSSEError, fromFormData, isError, SSE_HEADERS, } from '../../../utils/index.js';
+import { defaultStreamOnClose, fmtSingleDataMsg, fmtSSEError, fromFormData, isError, SSE_HEADERS, } from '../../../utils/index.js';
 export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager, beforeExec) {
     const { envelope } = contract;
     const handler = async (c) => {
@@ -28,10 +28,12 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                             ctrl.close();
                             closed = true;
                         };
+                        let streamedOnce = false;
                         execOpts = {
                             stream: {
-                                onClose: async () => { },
+                                onClose: defaultStreamOnClose(streamedOnce),
                                 onData: async (output) => {
+                                    streamedOnce = true;
                                     if (!output || closed) {
                                         return;
                                     }

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

@@ -3,4 +3,5 @@ import type { HTTPHeaderName } from '../../utils/index.js';
 export type AuthCookieName = 'auth';
 export type PublicApiKeyHeaderName = 'X-API-Key' | (string & {});
 export declare const AUTHORIZATION_HEADER_NAME: HTTPHeaderName;
+export declare const X_FORWARDED_PROTO_HEADER_NAME: HTTPHeaderName;
 export declare const DEFAULT_VERSION: SemVerVersion;

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

@@ -1,2 +1,3 @@
 export const AUTHORIZATION_HEADER_NAME = 'Authorization';
+export const X_FORWARDED_PROTO_HEADER_NAME = 'X-Forwarded-Proto';
 export const DEFAULT_VERSION = '0.1.0';

package/dist/esm/target/nextjs-server/NextJSServerManager.d.ts

@@ -1,5 +1,6 @@
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath, URLPath } from '../../dt/index.js';
+import type { ProductUCsLoaderOutput } from '../../product/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
 import type { OpenAPISpec } from '../lib/openapi/types.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
@@ -9,6 +10,7 @@ export declare class NextJSServerManager implements ServerManager {
     initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): Promise<void>;
     mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): void;
+    mountMCP(_ucs: ProductUCsLoaderOutput, _at: URLPath): Promise<void>;
     mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;

package/dist/esm/target/nextjs-server/NextJSServerManager.js

@@ -21,6 +21,9 @@ let NextJSServerManager = class NextJSServerManager {
     mountSync(_appManifest, _ucd, _contract) {
         // Nothing to do
     }
+    async mountMCP(_ucs, _at) {
+        // Nothing to do
+    }
     async mountOpenAPISpec(_spec, _at) {
         // Nothing to do
     }

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -1,8 +1,10 @@
-import { type Express } from 'express';
+import { type Express, type RequestHandler } from 'express';
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath, URLPath } from '../../dt/index.js';
+import type { ProductUCsLoaderOutput } from '../../product/index.js';
 import type { Configurable, EnvironmentManager, Logger, LoggerSettings, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import type { MCPHTTPRequestHandlerBuilder } from '../lib/mcp-server/http/MCPHTTPRequestHandlerBuilder.js';
 import type { OpenAPISpec } from '../lib/openapi/types.js';
 import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
@@ -20,13 +22,14 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     protected environmentManager: EnvironmentManager;
     private helmetMiddlewareBuilder;
     protected logger: Logger;
+    private mcpHTTPRequestHandlerBuilder;
     private serverRequestHandler;
     private serverSSLCertLoader;
     private settingsManager;
     private ucManager;
     protected runtime: Express;
     private server;
-    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMiddlewareBuilder: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMiddlewareBuilder: HelmetMiddlewareBuilder, logger: Logger, mcpHTTPRequestHandlerBuilder: MCPHTTPRequestHandlerBuilder<RequestHandler>, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
@@ -34,6 +37,7 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
     mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
+    mountMCP(ucs: ProductUCsLoaderOutput, at: URLPath): Promise<void>;
     mountOpenAPISpec(spec: OpenAPISpec, at: URLPath): Promise<void>;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;