libmodulor 0.28.0 → 0.30.0

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

@@ -0,0 +1,88 @@
+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 { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import { ucStreamExecOpts } from '../funcs.js';
+let MCPHTTPExpressProtocolRequestHandlerBuilder = class MCPHTTPExpressProtocolRequestHandlerBuilder {
+    logger;
+    productManifest;
+    serverRequestHandler;
+    wordingManager;
+    constructor(logger, productManifest, serverRequestHandler, wordingManager) {
+        this.logger = logger;
+        this.productManifest = productManifest;
+        this.serverRequestHandler = serverRequestHandler;
+        this.wordingManager = wordingManager;
+    }
+    exec({ ucs, ucManager, }) {
+        return async (req, res) => {
+            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(MCPServerRequestHandler)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, 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,15 @@
+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 { 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 serverRequestHandler;
+    private wordingManager;
+    constructor(logger: Logger, productManifest: ProductManifest, serverRequestHandler: MCPServerRequestHandler, wordingManager: WordingManager);
+    exec({ ucs, ucManager, }: MCPHTTPRequestHandlerBuilderInput): MiddlewareHandler;
+}

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

@@ -0,0 +1,88 @@
+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 { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../../../../i18n/index.js';
+import { ucMountingPoint, } from '../../../../../uc/index.js';
+import { toReq, toRes } from '../../../server-hono/funcs.js';
+import { init, toolConfig } from '../../funcs.js';
+import { MCPServerRequestHandler } from '../../MCPServerRequestHandler.js';
+import { ucStreamExecOpts } from '../funcs.js';
+let MCPHTTPHonoProtocolRequestHandlerBuilder = class MCPHTTPHonoProtocolRequestHandlerBuilder {
+    logger;
+    productManifest;
+    serverRequestHandler;
+    wordingManager;
+    constructor(logger, productManifest, serverRequestHandler, wordingManager) {
+        this.logger = logger;
+        this.productManifest = productManifest;
+        this.serverRequestHandler = serverRequestHandler;
+        this.wordingManager = wordingManager;
+    }
+    exec({ ucs, ucManager, }) {
+        return async (c) => {
+            const server = init(this.productManifest);
+            const transport = new WebStandardStreamableHTTPServerTransport();
+            // 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(c),
+                            bodyFromJSON: async () => input,
+                        },
+                        res: toRes(c),
+                        ucd: uc.def,
+                        ucManager,
+                    });
+                });
+            }
+            transport.onclose = async () => {
+                this.logger.trace('Transport closed => closing streams');
+                await Promise.all(execOptss.values().map((eo) => eo.stream?.onClose()));
+            };
+            c.req.raw.signal.addEventListener('abort', async () => {
+                this.logger.trace('Connection closed => closing transport');
+                await transport.close();
+            });
+            await server.connect(transport);
+            return transport.handleRequest(c.req.raw);
+        };
+    }
+};
+MCPHTTPHonoProtocolRequestHandlerBuilder = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject(MCPServerRequestHandler)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, MCPServerRequestHandler,
+        WordingManager])
+], MCPHTTPHonoProtocolRequestHandlerBuilder);
+export { MCPHTTPHonoProtocolRequestHandlerBuilder };

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

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from 'hono';
+import type { MCPHTTPRequestHandlerBuilder } from '../MCPHTTPRequestHandlerBuilder.js';
+export type MCPHTTPHonoRequestHandlerBuilder = MCPHTTPRequestHandlerBuilder<MiddlewareHandler>;

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

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

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

@@ -0,0 +1,31 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { AppManifest } from '../../../../app/index.js';
+import type { JWTManager, Worker } from '../../../../std/index.js';
+import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase } from '../../../../uc/index.js';
+import type { AuthDataStore } from '../../client/AuthDataStore.js';
+import type { StdioToolInput } from './input.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    toolInput: StdioToolInput<I>;
+    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.
+     *
+     * And in some cases, this latter is specific to a context : for instance in automated tests.
+     */
+    ucManager: UCManager;
+}
+type Output = CallToolResult;
+export declare class MCPStdioRequestHandler implements Worker<Input, Promise<Output>> {
+    private authDataStore;
+    private jwtManager;
+    private ucBuilder;
+    constructor(authDataStore: AuthDataStore, jwtManager: JWTManager, ucBuilder: UCBuilder);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, toolInput, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output>;
+    private auth;
+    private applySideEffects;
+    private applyClearAuthSideEffect;
+    private applyRedirectSideEffect;
+    private applySetAuthSideEffect;
+}
+export {};

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioRequestHandler.js

@@ -0,0 +1,108 @@
+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 { UCBuilder, UCOutputSideEffectType, } from '../../../../uc/index.js';
+import { resAborted, resError, resObj } from '../funcs.js';
+let MCPStdioRequestHandler = class MCPStdioRequestHandler {
+    authDataStore;
+    jwtManager;
+    ucBuilder;
+    constructor(authDataStore, jwtManager, ucBuilder) {
+        this.authDataStore = authDataStore;
+        this.jwtManager = jwtManager;
+        this.ucBuilder = ucBuilder;
+    }
+    async exec({ appManifest, toolInput, ucd, ucManager, }) {
+        try {
+            const auth = await this.auth();
+            const uc = this.ucBuilder.exec({
+                appManifest,
+                auth,
+                def: ucd,
+            });
+            if (toolInput) {
+                const { _reserved, ...rest } = toolInput;
+                uc.fill(rest);
+                if (_reserved?.confirmed === undefined) {
+                    await ucManager.confirmClient(uc);
+                    // ... throws an error
+                }
+                else if (_reserved.confirmed === false) {
+                    return resAborted();
+                }
+            }
+            const ucor = await ucManager.execClient(uc);
+            await this.applySideEffects(ucor);
+            return resObj(ucor.output());
+        }
+        catch (err) {
+            return resError(err);
+        }
+    }
+    async auth() {
+        // TODO : Memoize the auth instead of decoding each time
+        const jwt = await this.authDataStore.get();
+        if (!jwt) {
+            return null;
+        }
+        return this.jwtManager.decodeUnsafe(jwt);
+    }
+    async applySideEffects(ucor) {
+        const { io } = ucor.ucd();
+        const sideEffects = io.o?.sideEffects;
+        if (!sideEffects) {
+            return;
+        }
+        let item;
+        if (ucor.canItem00()) {
+            item = ucor.item00().item;
+        }
+        for (const se of sideEffects) {
+            const { type } = se;
+            switch (type) {
+                case UCOutputSideEffectType.CLEAR_AUTH:
+                    await this.applyClearAuthSideEffect();
+                    return;
+                case UCOutputSideEffectType.REDIRECT:
+                    await this.applyRedirectSideEffect(item);
+                    return;
+                case UCOutputSideEffectType.SET_AUTH:
+                    await this.applySetAuthSideEffect(item);
+                    return;
+                default:
+                    (type);
+            }
+        }
+    }
+    async applyClearAuthSideEffect() {
+        await this.authDataStore.set(null);
+    }
+    async applyRedirectSideEffect(_item) {
+        // Nothing to do
+    }
+    async applySetAuthSideEffect(item) {
+        if (!item || !('jwt' in item) || typeof item.jwt !== 'string') {
+            return;
+        }
+        const { jwt } = item;
+        await this.authDataStore.set(jwt);
+    }
+};
+MCPStdioRequestHandler = __decorate([
+    injectable(),
+    __param(0, inject('AuthDataStore')),
+    __param(1, inject('JWTManager')),
+    __param(2, inject(UCBuilder)),
+    __metadata("design:paramtypes", [Object, Object, UCBuilder])
+], MCPStdioRequestHandler);
+export { MCPStdioRequestHandler };

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

@@ -0,0 +1,7 @@
+import { WordingManager } from '../../../../i18n/index.js';
+import type { UCClientConfirmManager, UCDef, UCInput, UCOPIBase } from '../../../../uc/index.js';
+export declare class MCPStdioUCClientConfirmManager implements UCClientConfirmManager {
+    private wordingManager;
+    constructor(wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+}

package/dist/esm/target/lib/mcp-server/stdio/MCPStdioUCClientConfirmManager.js

@@ -0,0 +1,36 @@
+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 { WordingManager } from '../../../../i18n/index.js';
+import { UC_CONFIRM_HINT } from './consts.js';
+let MCPStdioUCClientConfirmManager = class MCPStdioUCClientConfirmManager {
+    wordingManager;
+    constructor(wordingManager) {
+        this.wordingManager = wordingManager;
+    }
+    async exec(ucd) {
+        const { message, title } = this.wordingManager.ucClientConfirm(ucd);
+        let m = title;
+        if (message) {
+            m = `\n${message}`;
+        }
+        m = `\n${UC_CONFIRM_HINT}`;
+        throw new Error(m);
+    }
+};
+MCPStdioUCClientConfirmManager = __decorate([
+    injectable(),
+    __param(0, inject(WordingManager)),
+    __metadata("design:paramtypes", [WordingManager])
+], MCPStdioUCClientConfirmManager);
+export { MCPStdioUCClientConfirmManager };

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

@@ -0,0 +1,2 @@
+export declare const ERR_LOGGER_LEVEL = "Set the logging_level to \"error\" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)";
+export declare const UC_CONFIRM_HINT: string;

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

@@ -0,0 +1,3 @@
+import { RESERVED_CONFIRMED_KEY, RESERVED_KEY } from './input.js';
+export const ERR_LOGGER_LEVEL = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
+export const UC_CONFIRM_HINT = `(Hint: ask the user to confirm. If they do, set the property "${RESERVED_CONFIRMED_KEY}" in "${RESERVED_KEY}" to true in the input. Otherwise, set it to false)`;

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

@@ -0,0 +1,2 @@
+import type { LoggerLevel } from '../../../../std/index.js';
+export declare function assertLoggerLevel(loggerLevel: LoggerLevel): void;

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

@@ -0,0 +1,10 @@
+import { ERR_LOGGER_LEVEL } from './consts.js';
+export function assertLoggerLevel(loggerLevel) {
+    if (loggerLevel === 'error') {
+        return;
+    }
+    // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
+    // That's why we explicitly write to stdout by calling console.error().
+    // biome-ignore lint/suspicious/noConsole: we want it
+    console.error(new Error(ERR_LOGGER_LEVEL));
+}

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

@@ -0,0 +1,10 @@
+import type { JSONSchemaObject } from '../../../../dt/index.js';
+import type { UCInput } from '../../../../uc/index.js';
+export type StdioToolInput<I extends UCInput | undefined = undefined> = I & {
+    _reserved?: {
+        confirmed?: boolean;
+    };
+};
+export declare const RESERVED_KEY: "_reserved";
+export declare const RESERVED_CONFIRMED_KEY: "confirmed";
+export declare function stdioToolInputSchema(): JSONSchemaObject<StdioToolInput>['properties'];

package/dist/esm/target/lib/mcp-server/stdio/input.js

@@ -0,0 +1,15 @@
+export const RESERVED_KEY = '_reserved';
+export const RESERVED_CONFIRMED_KEY = 'confirmed';
+export function stdioToolInputSchema() {
+    return {
+        [RESERVED_KEY]: {
+            additionalProperties: false,
+            properties: {
+                [RESERVED_CONFIRMED_KEY]: {
+                    type: 'boolean',
+                },
+            },
+            type: 'object',
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+export type RegisterToolConfig = Pick<RegisteredTool, 'description' | 'inputSchema' | 'outputSchema' | 'title' | 'annotations' | '_meta'>;

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

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

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

@@ -0,0 +1,25 @@
+import { WordingManager } from '../../../i18n/index.js';
+import type { ProductManifest, ProductUCsLoaderOutput } from '../../../product/index.js';
+import type { Configurable, I18nManager, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
+import type { OpenAPISpec } from './types.js';
+type Input = {
+    ucs: ProductUCsLoaderOutput;
+};
+interface Output {
+    spec: OpenAPISpec;
+}
+type S = Pick<ServerManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name' | 'server_public_url'>;
+export declare class OpenAPISpecBuilder implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private i18nManager;
+    private productManifest;
+    private settingsManager;
+    private wordingManager;
+    constructor(i18nManager: I18nManager, productManifest: ProductManifest, settingsManager: SettingsManager<S>, wordingManager: WordingManager);
+    s(): S;
+    exec({ ucs }: Input): Promise<Output>;
+    private initErrors;
+    private initOutput;
+    private initPath;
+}
+export {};