libmodulor 0.29.0 → 0.30.0

package/dist/esm/target/lib/client/impl/MixedServerClientManager.js

@@ -0,0 +1,44 @@
+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 { SettingsServerClientManager } from '../../../../std/impl/SettingsServerClientManager.js';
+let MixedServerClientManager = class MixedServerClientManager {
+    authDataStore;
+    settingsServerClientManager;
+    constructor(authDataStore, settingsServerClientManager) {
+        this.authDataStore = authDataStore;
+        this.settingsServerClientManager = settingsServerClientManager;
+    }
+    async authApiKey(opts) {
+        return this.settingsServerClientManager.authApiKey(opts);
+    }
+    async authBasic(opts) {
+        return this.settingsServerClientManager.authBasic(opts);
+    }
+    async authJWT(_opts) {
+        return this.authDataStore.get();
+    }
+    async baseURL(opts) {
+        return this.settingsServerClientManager.baseURL(opts);
+    }
+    async publicApiKey(opts) {
+        return this.settingsServerClientManager.publicApiKey(opts);
+    }
+};
+MixedServerClientManager = __decorate([
+    injectable(),
+    __param(0, inject('AuthDataStore')),
+    __param(1, inject(SettingsServerClientManager)),
+    __metadata("design:paramtypes", [Object, SettingsServerClientManager])
+], MixedServerClientManager);
+export { MixedServerClientManager };

package/dist/esm/target/lib/json-schema/error.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorMessage, JSONSchemaObject } from '../../../dt/index.js';
+import { type ServerError } from '../../../error/index.js';
+export declare function serverErrorJsonSchema(message?: ErrorMessage): JSONSchemaObject<ServerError>;

package/dist/esm/target/lib/json-schema/error.js

@@ -0,0 +1,14 @@
+import { IllegalArgumentError, } from '../../../error/index.js';
+export function serverErrorJsonSchema(message) {
+    return {
+        additionalProperties: false,
+        properties: {
+            message: {
+                examples: [message ?? new IllegalArgumentError().message],
+                type: 'string',
+            },
+        },
+        required: ['message'],
+        type: 'object',
+    };
+}

package/dist/esm/target/lib/json-schema/input.d.ts

@@ -0,0 +1,16 @@
+import type { DataType, JSONSchemaObject, JSONSchemaProperty } from '../../../dt/index.js';
+import { type UC, type UCInput, type UCInputField, type UCInputUnwrapped, type UCOPIBase } from '../../../uc/index.js';
+export interface UCInputFieldJsonSchemaDef<T extends DataType> {
+    /**
+     * Internal types that are not part of the spec
+     */
+    internal?: {
+        required?: boolean;
+    };
+    /**
+     * Fields that are part of the spec
+     */
+    spec?: JSONSchemaProperty<T>;
+}
+export declare function ucifJsonSchemaDef<T extends DataType>(field: UCInputField<T>): UCInputFieldJsonSchemaDef<T>;
+export declare function ucInputJsonSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): JSONSchemaObject<UCInputUnwrapped<I>>;

package/dist/esm/target/lib/json-schema/input.js

@@ -0,0 +1,67 @@
+import { ucifExamples, ucifIsMandatory, ucifRepeatability, } from '../../../uc/index.js';
+export function ucifJsonSchemaDef(field) {
+    const def = {
+        internal: {},
+        spec: { type: 'string' },
+    };
+    if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { def: fDef } = field;
+    const { type: fType } = fDef;
+    def.internal.required = ucifIsMandatory(fDef);
+    def.spec = fType.jsonSchemaType();
+    if (!def.internal.required && !Array.isArray(def.spec.type)) {
+        def.spec.type = [def.spec.type, 'null'];
+    }
+    const examples = ucifExamples(fDef);
+    if (examples) {
+        def.spec.examples = examples;
+    }
+    const options = fType.getOptions();
+    if (options) {
+        def.spec.enum = options.map((o) => o.value);
+        if (!def.internal.required) {
+            def.spec.enum.push(null);
+        }
+    }
+    const [isRepeatable] = ucifRepeatability(fDef);
+    if (isRepeatable) {
+        def.spec = {
+            items: def.spec,
+            type: def.internal.required ? 'array' : ['array', 'null'],
+        };
+        if (fDef.cardinality?.max !== undefined) {
+            def.spec.maxItems = fDef.cardinality?.max;
+        }
+        if (fDef.cardinality?.min !== undefined) {
+            def.spec.minItems = fDef.cardinality?.min;
+        }
+    }
+    return def;
+}
+export function ucInputJsonSchema(uc) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    for (const f of uc.inputFields) {
+        const { key } = f;
+        const { internal, spec } = ucifJsonSchemaDef(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;
+}

package/dist/esm/target/lib/json-schema/output.d.ts

@@ -0,0 +1,19 @@
+import type { DataType, JSONSchemaObject, JSONSchemaProperty } from '../../../dt/index.js';
+import { type UC, type UCInput, type UCOPIBase, type UCOutput, UCOutputField, type UCOutputPart, type UCOutputPartDef } from '../../../uc/index.js';
+export interface UCOutputFieldJsonSchemaDef<T extends DataType> {
+    /**
+     * Internal types that are not part of the spec
+     */
+    internal?: {
+        required?: boolean;
+    };
+    /**
+     * Fields that are part of the spec
+     */
+    spec?: JSONSchemaProperty<T>;
+}
+export declare function ucofJsonSchemaDef<OPI extends UCOPIBase, T extends DataType>(field: UCOutputField<OPI, T>): UCOutputFieldJsonSchemaDef<T>;
+export declare function ucOPIJsonSchema<OPI extends UCOPIBase>(part: UCOutputPartDef<NonNullable<OPI>>): JSONSchemaObject<OPI>;
+export declare function ucOutputPartJsonSchema<OPI extends UCOPIBase>(part: UCOutputPartDef<NonNullable<OPI>>): JSONSchemaObject<UCOutputPart<OPI>>;
+export declare function ucOutputPartPaginationJsonSchema<OPI extends UCOPIBase>(): JSONSchemaObject<NonNullable<UCOutputPart<OPI>['pagination']>>;
+export declare function ucOutputJsonSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): JSONSchemaObject<UCOutput<OPI0, OPI1>> | null;

package/dist/esm/target/lib/json-schema/output.js

@@ -0,0 +1,128 @@
+import { UCOPIBaseDefFields, UCOutputField, ucofExamples, ucofIsMandatory, ucofRepeatability, } from '../../../uc/index.js';
+export function ucofJsonSchemaDef(field) {
+    const def = {
+        internal: {},
+        spec: { type: 'string' },
+    };
+    if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { def: fDef } = field;
+    const { type: fType } = fDef;
+    def.internal.required = ucofIsMandatory(fDef);
+    def.spec = fType.jsonSchemaType();
+    if (!def.internal.required && !Array.isArray(def.spec.type)) {
+        def.spec.type = [def.spec.type, 'null'];
+    }
+    const examples = ucofExamples(fDef);
+    if (examples) {
+        def.spec.examples = examples;
+    }
+    const options = fType.getOptions();
+    if (options) {
+        def.spec.enum = options.map((o) => o.value);
+        if (!def.internal.required) {
+            def.spec.enum.push(null);
+        }
+    }
+    const [isRepeatable] = ucofRepeatability(fDef);
+    if (isRepeatable) {
+        def.spec = {
+            items: def.spec,
+            type: def.internal.required ? 'array' : ['array', 'null'],
+        };
+        if (fDef.cardinality?.max !== undefined) {
+            def.spec.maxItems = fDef.cardinality?.max;
+        }
+        if (fDef.cardinality?.min !== undefined) {
+            def.spec.minItems = fDef.cardinality?.min;
+        }
+    }
+    return def;
+}
+export function ucOPIJsonSchema(part) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    const allFields = { ...UCOPIBaseDefFields, ...part.fields };
+    for (const entry of Object.entries(allFields)) {
+        const key = entry[0];
+        const fDef = entry[1];
+        const f = new UCOutputField(key, fDef);
+        const { internal, spec } = ucofJsonSchemaDef(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 ucOutputPartJsonSchema(part) {
+    return {
+        additionalProperties: false,
+        properties: {
+            items: {
+                items: ucOPIJsonSchema(part),
+                type: 'array',
+            },
+            pagination: ucOutputPartPaginationJsonSchema(),
+            total: { examples: [1], type: 'integer' },
+        },
+        required: ['items', 'total'],
+        type: 'object',
+    };
+}
+export function ucOutputPartPaginationJsonSchema() {
+    return {
+        additionalProperties: false,
+        properties: {
+            id: { format: 'uuid', type: 'string' },
+            limit: { type: 'integer' },
+            offset: { type: 'integer' },
+            q: { type: 'string' },
+        },
+        type: 'object',
+    };
+}
+export function ucOutputJsonSchema(uc) {
+    if (!uc.hasOutputParts()) {
+        return null;
+    }
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    const part0 = uc.def.io.o?.parts?._0;
+    if (!part0) {
+        return null;
+    }
+    res.properties.parts = {
+        additionalProperties: false,
+        properties: {
+            _0: ucOutputPartJsonSchema(part0),
+        },
+        required: ['_0'],
+        type: 'object',
+    };
+    const part1 = uc.def.io.o?.parts?._1;
+    if (!part1) {
+        return res;
+    }
+    res.properties.parts.properties = {
+        _1: ucOutputPartJsonSchema(part1),
+    };
+    res.properties.parts.required?.push('_1');
+    return res;
+}

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/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,15 @@
+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 { 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 serverRequestHandler;
+    private wordingManager;
+    constructor(logger: Logger, productManifest: ProductManifest, serverRequestHandler: MCPServerRequestHandler, wordingManager: WordingManager);
+    exec({ ucs, ucManager, }: MCPHTTPRequestHandlerBuilderInput): RequestHandler;
+}