@gavdi/cap-mcp 0.9.0

package/lib/annotations/structures.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpPromptAnnotation = exports.McpToolAnnotation = exports.McpResourceAnnotation = exports.McpAnnotation = void 0;
+class McpAnnotation {
+    _name;
+    _description;
+    _target;
+    _serviceName;
+    constructor(name, description, target, serviceName) {
+        this._name = name;
+        this._description = description;
+        this._target = target;
+        this._serviceName = serviceName;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get target() {
+        return this._target;
+    }
+    get serviceName() {
+        return this._serviceName;
+    }
+}
+exports.McpAnnotation = McpAnnotation;
+class McpResourceAnnotation extends McpAnnotation {
+    _functionalities;
+    _properties;
+    _resourceKeys;
+    constructor(name, description, target, serviceName, functionalities, properties, resourceKeys) {
+        super(name, description, target, serviceName);
+        this._functionalities = functionalities;
+        this._properties = properties;
+        this._resourceKeys = resourceKeys;
+    }
+    get functionalities() {
+        return this._functionalities;
+    }
+    get properties() {
+        return this._properties;
+    }
+    get resourceKeys() {
+        return this._resourceKeys;
+    }
+}
+exports.McpResourceAnnotation = McpResourceAnnotation;
+class McpToolAnnotation extends McpAnnotation {
+    _parameters;
+    _entityKey;
+    _operationKind;
+    _keyTypeMap;
+    constructor(name, description, operation, serviceName, parameters, entityKey, operationKind, keyTypeMap) {
+        super(name, description, operation, serviceName);
+        this._parameters = parameters;
+        this._entityKey = entityKey;
+        this._operationKind = operationKind;
+        this._keyTypeMap = keyTypeMap;
+    }
+    get parameters() {
+        return this._parameters;
+    }
+    get entityKey() {
+        return this._entityKey;
+    }
+    get operationKind() {
+        return this._operationKind;
+    }
+    get keyTypeMap() {
+        return this._keyTypeMap;
+    }
+}
+exports.McpToolAnnotation = McpToolAnnotation;
+class McpPromptAnnotation extends McpAnnotation {
+    _prompts;
+    constructor(name, description, serviceName, prompts) {
+        super(name, description, serviceName, serviceName);
+        this._prompts = prompts;
+    }
+    get prompts() {
+        return this._prompts;
+    }
+}
+exports.McpPromptAnnotation = McpPromptAnnotation;

package/lib/annotations/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/annotations/utils.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitDefinitionName = splitDefinitionName;
+exports.containsMcpAnnotation = containsMcpAnnotation;
+exports.containsRequiredAnnotations = containsRequiredAnnotations;
+exports.isValidResourceAnnotation = isValidResourceAnnotation;
+exports.isValidToolAnnotation = isValidToolAnnotation;
+exports.isValidPromptsAnnotation = isValidPromptsAnnotation;
+exports.determineResourceOptions = determineResourceOptions;
+exports.parseResourceElements = parseResourceElements;
+exports.parseOperationElements = parseOperationElements;
+exports.parseEntityKeys = parseEntityKeys;
+const constants_1 = require("./constants");
+const logger_1 = require("../logger");
+function splitDefinitionName(definition) {
+    const splitted = definition.split(".");
+    return {
+        serviceName: splitted[0],
+        target: splitted[1],
+    };
+}
+function containsMcpAnnotation(definition) {
+    for (const key of Object.keys(definition)) {
+        if (!key.includes(constants_1.MCP_ANNOTATION_KEY))
+            continue;
+        return true;
+    }
+    return false;
+}
+function containsRequiredAnnotations(annotations) {
+    if (annotations.definition?.kind === "service")
+        return true;
+    if (!annotations?.name || annotations.name.length <= 0) {
+        throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing required property 'name'`);
+    }
+    if (!annotations?.description || annotations.description.length <= 0) {
+        throw new Error("Invalid annotation - Missing required property 'description'");
+    }
+    return true;
+}
+function isValidResourceAnnotation(annotations) {
+    if (!annotations?.resource) {
+        throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing required flag 'resource'`);
+    }
+    if (Array.isArray(annotations.resource)) {
+        for (const el of annotations.resource) {
+            if (constants_1.DEFAULT_ALL_RESOURCE_OPTIONS.has(el))
+                continue;
+            throw new Error(`Invalid annotation '${annotations.definition?.target}' - Invalid resource option: ${el}`);
+        }
+    }
+    return true;
+}
+function isValidToolAnnotation(annotations) {
+    if (!annotations?.tool) {
+        throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing required flag 'tool'`);
+    }
+    return true;
+}
+function isValidPromptsAnnotation(annotations) {
+    if (!annotations?.prompts) {
+        throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing prompts annotations`);
+    }
+    for (const prompt of annotations.prompts) {
+        if (!prompt.template || prompt.template.length <= 0) {
+            throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing valid template`);
+        }
+        if (!prompt.name || prompt.name.length <= 0) {
+            throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing valid name`);
+        }
+        if (!prompt.title || prompt.title.length <= 0) {
+            throw new Error(`Invalid annotation '${annotations.definition?.target}' - Missing valid title`);
+        }
+        if (!prompt.role ||
+            (prompt.role !== "user" && prompt.role !== "assistant")) {
+            throw new Error(`Invalid annotation '${annotations.definition?.target}' - Role must be 'user' or 'assistant'`);
+        }
+        prompt.inputs?.forEach((el) => {
+            if (!el.key || el.key.length <= 0) {
+                throw new Error(`Invalid annotation '${annotations.definition?.target}' - missing input key`);
+            }
+            if (!el.type || el.type.length <= 0) {
+                throw new Error(`Invalid annotation '${annotations.definition?.target}' - missing input type`);
+            }
+            // TODO: Verify the input type against valid data types
+        });
+    }
+    return true;
+}
+function determineResourceOptions(annotations) {
+    if (!Array.isArray(annotations.resource))
+        return constants_1.DEFAULT_ALL_RESOURCE_OPTIONS;
+    return new Set(annotations.resource);
+}
+function parseResourceElements(definition) {
+    const properties = new Map();
+    const resourceKeys = new Map();
+    for (const [key, value] of Object.entries(definition.elements)) {
+        if (!value.type)
+            continue;
+        const parsedType = value.type.replace("cds.", "");
+        properties.set(key, parsedType);
+        if (!value.key)
+            continue;
+        resourceKeys.set(key, parsedType);
+    }
+    return {
+        properties,
+        resourceKeys,
+    };
+}
+function parseOperationElements(annotations) {
+    let parameters;
+    const params = annotations.definition["params"];
+    if (params && Object.entries(params).length > 0) {
+        parameters = new Map();
+        for (const [k, v] of Object.entries(params)) {
+            parameters.set(k, v.type.replace("cds.", ""));
+        }
+    }
+    return {
+        parameters,
+        operationKind: annotations.definition.kind,
+    };
+}
+function parseEntityKeys(definition) {
+    const result = new Map();
+    for (const [k, v] of Object.entries(definition.elements)) {
+        if (!v.key)
+            continue;
+        if (!v.type) {
+            logger_1.LOGGER.error("Invalid key type", k);
+            throw new Error("Invalid key type found for bound operation");
+        }
+        result.set(k, v.type.replace("cds.", ""));
+    }
+    return result;
+}

package/lib/annotations.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpPromptAnnotation = exports.McpToolAnnotation = exports.McpResourceAnnotation = exports.McpAnnotation = exports.McpAnnotations = exports.McpAnnotationKey = void 0;
+exports.parseAnnotations = parseAnnotations;
+const utils_1 = require("./utils");
+const DEFAULT_ALL_RESOURCE_OPTIONS = new Set([
+    "filter",
+    "sort",
+    "top",
+    "skip",
+    "select",
+]);
+exports.McpAnnotationKey = "@mcp";
+exports.McpAnnotations = {
+    // Resource annotations for MCP
+    MCP_RESOURCE: "@mcp.resource",
+    // Tool annotations for MCP
+    MCP_TOOL_NAME: "@mcp.tool.name",
+    MCP_TOOL_DESCRIPTION: "@mcp.tool.description",
+    // Prompt annotations for MCP
+    MCP_PROMPT: "@mcp.prompt",
+};
+class McpAnnotation {
+    _target;
+    _serviceName;
+    constructor(target, serviceName) {
+        this._target = target;
+        this._serviceName = serviceName;
+    }
+    get target() {
+        return this._target;
+    }
+    get serviceName() {
+        return this._serviceName;
+    }
+}
+exports.McpAnnotation = McpAnnotation;
+class McpResourceAnnotation extends McpAnnotation {
+    _includeAll;
+    _functionalities;
+    _properties;
+    constructor(target, serviceName, includeAll, functionalities, properties) {
+        super(target, serviceName);
+        this._includeAll = includeAll;
+        this._functionalities = functionalities;
+        this._properties = properties;
+    }
+    get includeAll() {
+        return this._includeAll;
+    }
+    get functionalities() {
+        return this._functionalities;
+    }
+    get properties() {
+        return this._properties;
+    }
+}
+exports.McpResourceAnnotation = McpResourceAnnotation;
+class McpToolAnnotation extends McpAnnotation {
+    _name;
+    _description;
+    _parameters;
+    _entityKey;
+    _operationKind;
+    _keyTypeMap;
+    constructor(name, description, operation, serviceName, parameters, entityKey, operationKind, keyTypeMap) {
+        super(operation, serviceName);
+        this._name = name;
+        this._description = description;
+        this._parameters = parameters;
+        this._entityKey = entityKey;
+        this._operationKind = operationKind;
+        this._keyTypeMap = keyTypeMap;
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get parameters() {
+        return this._parameters;
+    }
+    get entityKey() {
+        return this._entityKey;
+    }
+    get operationKind() {
+        return this._operationKind;
+    }
+    get keyTypeMap() {
+        return this._keyTypeMap;
+    }
+}
+exports.McpToolAnnotation = McpToolAnnotation;
+class McpPromptAnnotation extends McpAnnotation {
+    _name;
+    _template;
+    constructor(target, serviceName, name, template) {
+        super(target, serviceName);
+        this._name = name;
+        this._template = template;
+    }
+    get name() {
+        return this._name;
+    }
+    get template() {
+        return this._template;
+    }
+}
+exports.McpPromptAnnotation = McpPromptAnnotation;
+function parseAnnotations(services) {
+    const annotations = [];
+    for (const serviceName of Object.keys(services)) {
+        const srv = services[serviceName];
+        if (srv.name === "CatalogService") {
+            utils_1.LOGGER.debug("SERVICE: ", srv.model.definitions);
+        }
+        const entities = srv.entities;
+        const operations = srv.operations; // Refers to action and function imports
+        // Find entities
+        for (const entityName of Object.keys(entities)) {
+            const target = entities[entityName];
+            const res = findEntityAnnotations(target, entityName, srv);
+            if (target.actions) {
+                const bound = parseBoundOperations(target.actions, entityName, target, srv);
+                if (bound && bound.length > 0) {
+                    annotations.push(...bound);
+                }
+            }
+            if (!res)
+                continue;
+            annotations.push(res);
+        }
+        // Find operations
+        for (const operationName of Object.keys(operations)) {
+            const op = operations[operationName];
+            const res = findOperationAnnotations(op, operationName, srv);
+            if (!res)
+                continue;
+            annotations.push(res);
+        }
+    }
+    const result = formatAnnotations(annotations);
+    return result;
+}
+function formatAnnotations(annotationList) {
+    const result = new Map();
+    for (const annotation of annotationList) {
+        if (annotation.operation) {
+            if (!annotation.annotations[exports.McpAnnotations.MCP_TOOL_NAME] ||
+                !annotation.annotations[exports.McpAnnotations.MCP_TOOL_DESCRIPTION]) {
+                utils_1.LOGGER.error(`Invalid annotation found for operation`, annotation);
+                throw new Error(`Invalid annotations for operation '${annotation.operation}'`);
+            }
+            else if (typeof annotation.annotations[exports.McpAnnotations.MCP_TOOL_NAME] !==
+                "string" ||
+                typeof annotation.annotations[exports.McpAnnotations.MCP_TOOL_DESCRIPTION] !==
+                    "string") {
+                utils_1.LOGGER.error("Invalid data for annotations", annotation);
+                throw new Error(`Invalid annotation data for operation '${annotation.operation}'`);
+            }
+            const entry = new McpToolAnnotation(annotation.annotations[exports.McpAnnotations.MCP_TOOL_NAME], annotation.annotations[exports.McpAnnotations.MCP_TOOL_DESCRIPTION], annotation.operation, annotation.serviceName, mapOperationInput(annotation.context), // TODO: Parse the parameters from the context and place them in the class
+            annotation.entityKey, annotation.operationKind, annotation.keyTypeMap);
+            result.set(entry.target, entry);
+            continue;
+        }
+        if (!annotation.entityKey) {
+            utils_1.LOGGER.error("Invalid entry", annotation);
+            throw new Error(`Invalid annotated entry found with no target`);
+        }
+        if (!annotation.annotations[exports.McpAnnotations.MCP_RESOURCE]) {
+            utils_1.LOGGER.error("No valid annotations found for entry", annotation);
+            throw new Error(`Invalid annotations for entry target: '${annotation.entityKey}'`);
+        }
+        const includeAll = annotation.annotations[exports.McpAnnotations.MCP_RESOURCE] === true;
+        const functionalities = Array.isArray(annotation.annotations[exports.McpAnnotations.MCP_RESOURCE])
+            ? new Set(annotation.annotations[exports.McpAnnotations.MCP_RESOURCE])
+            : DEFAULT_ALL_RESOURCE_OPTIONS;
+        const entry = new McpResourceAnnotation(annotation.entityKey, annotation.serviceName, includeAll, functionalities, (0, utils_1.parseEntityElements)(annotation.context));
+        result.set(entry.target, entry);
+    }
+    utils_1.LOGGER.debug("Formatted annotations", result);
+    return result;
+}
+function findEntityAnnotations(entry, entityKey, service) {
+    const annotations = findAnnotations(entry);
+    return Object.keys(annotations).length > 0
+        ? {
+            serviceName: service.name,
+            annotations: annotations,
+            entityKey: entityKey,
+            context: entry,
+        }
+        : undefined;
+}
+function findOperationAnnotations(operation, operationName, service) {
+    const annotations = findAnnotations(operation);
+    return Object.keys(annotations).length > 0
+        ? {
+            serviceName: service.name,
+            annotations: annotations,
+            operation: operationName,
+            operationKind: operation.kind,
+            context: operation,
+        }
+        : undefined;
+}
+function parseBoundOperations(operations, entityKey, entity, service) {
+    const res = new Array();
+    for (const [operationName, operation] of Object.entries(operations)) {
+        const annotation = findBoundOperationAnnotations(operation, operationName, entityKey, service);
+        if (!annotation)
+            continue;
+        annotation.keyTypeMap = new Map();
+        for (const [k, v] of Object.entries(entity.keys)) {
+            if (!v.type) {
+                utils_1.LOGGER.error("Invalid key type", k);
+                throw new Error("Invalid key type found for bound operation");
+            }
+            annotation.keyTypeMap.set(k, v.type.replace("cds.", ""));
+        }
+        res.push(annotation);
+    }
+    return res;
+}
+function findBoundOperationAnnotations(operation, operationName, entityKey, service) {
+    const annotations = findAnnotations(operation);
+    return Object.keys(annotations).length > 0
+        ? {
+            serviceName: service.name,
+            annotations: annotations,
+            operation: operationName,
+            operationKind: operation.kind,
+            entityKey: entityKey,
+            context: operation,
+        }
+        : undefined;
+}
+function findAnnotations(entry) {
+    const annotations = {};
+    for (const [k, v] of Object.entries(entry)) {
+        if (!k.includes(exports.McpAnnotationKey))
+            continue;
+        annotations[k] = v;
+    }
+    return annotations;
+}
+function mapOperationInput(ctx) {
+    const params = ctx["params"];
+    if (!params)
+        return undefined;
+    const result = new Map();
+    for (const [k, v] of Object.entries(params)) {
+        result.set(k, v.type.replace("cds.", ""));
+    }
+    return result.size > 0 ? result : undefined;
+}

package/lib/auth/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/loader.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfiguration = loadConfiguration;
+const logger_1 = require("../logger");
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+const ENV_NPM_PACKAGE_NAME = "npm_package_name";
+const ENV_NPM_PACKAGE_VERSION = "npm_package_version";
+const DEFAULT_PROJECT_INFO = {
+    name: "cap-mcp-server",
+    version: "1.0.0",
+};
+function loadConfiguration() {
+    const packageInfo = getProjectInfo();
+    const cdsEnv = loadCdsEnvConfiguration();
+    return {
+        name: cdsEnv?.name ?? packageInfo.name,
+        version: cdsEnv?.version ?? packageInfo.version,
+        capabilities: {
+            tools: cdsEnv?.capabilities?.tools ?? { listChanged: true },
+            resources: cdsEnv?.capabilities?.resources ?? { listChanged: true },
+            prompts: cdsEnv?.capabilities?.prompts ?? { listChanged: true },
+        },
+    };
+}
+/**
+ * Retrieves the current runtime's project information.
+ * This is used to distinguish the MCP server, by associating it with its parent application.
+ *
+ * In case of an error, the project info will default to plugin defaults.
+ * See constants for reference.
+ */
+function getProjectInfo() {
+    try {
+        return {
+            name: process.env[ENV_NPM_PACKAGE_NAME] ?? DEFAULT_PROJECT_INFO.name,
+            version: process.env[ENV_NPM_PACKAGE_VERSION] ?? DEFAULT_PROJECT_INFO.version,
+        };
+    }
+    catch (e) {
+        logger_1.LOGGER.warn("Failed to dynamically load project info, reverting to defaults. Error: ", e);
+        return DEFAULT_PROJECT_INFO;
+    }
+}
+function loadCdsEnvConfiguration() {
+    const config = cds.env.mcp;
+    if (!config)
+        return undefined;
+    else if (typeof config === "object")
+        return config;
+    try {
+        return JSON.parse(config);
+    }
+    catch (_) {
+        logger_1.LOGGER.warn("Could not parse the configuration object from cdsrc");
+        return undefined;
+    }
+}

package/lib/config/types.js

@@ -0,0 +1,27 @@
+"use strict";
+/* ======================================
+ * How it will look in the .cdsrc or package.json
+ * "cds": {
+ *  ...
+ *    "mcp": {
+ *      "name": "my-mcp-server", // This is optional - otherwise grabbed from package.json name
+ *      "version": "1.0.0", // Optional, otherwise grabbed from package.json version
+ *      "auth": "inherit", // By default this will inherit auth from CAP, otherwise values can be 'inherit'|'api-key'|'none'
+ *      "capabilities": {
+ *        "resources": {
+ *          "listChanged": true, // If not provided - default value = true
+ *          "subscribe": true, // If not provided - default value = false
+ *        },
+ *        "tools": {
+ *          "listChanged": true // If not provided - default value = true
+ *        },
+ *        "prompts": {
+ *          "listChanged": true // If not provided - default value = true
+ *        }
+ *      }
+ *    },
+ *  ...
+ * }
+ * ======================================
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGGER = void 0;
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+exports.LOGGER = cds.log("cds-mcp");

package/lib/mcp/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEW_LINE = exports.MCP_SESSION_HEADER = exports.ERR_MISSING_SERVICE = void 0;
+exports.ERR_MISSING_SERVICE = "Error: Service could not be found";
+exports.MCP_SESSION_HEADER = "mcp-session-id";
+exports.NEW_LINE = "\n";

package/lib/mcp/factory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_1 = require("../logger");
+const structures_1 = require("../annotations/structures");
+const tools_1 = require("./tools");
+const resources_1 = require("./resources");
+const prompts_1 = require("./prompts");
+function createMcpServer(config, annotations) {
+    logger_1.LOGGER.debug("Creating MCP server instance");
+    const server = new mcp_js_1.McpServer({
+        name: config.name,
+        version: config.version,
+        capabilities: config.capabilities,
+    });
+    if (!annotations)
+        return server;
+    logger_1.LOGGER.debug("Annotations found for server: ", annotations);
+    // TODO: Handle the parsed annotations
+    // TODO: Error handling
+    // TODO: This should only be mapped once, not per each server instance. Maybe this should be pre-packaged on load?
+    // TODO: Handle auth
+    for (const entry of annotations.values()) {
+        switch (entry.constructor) {
+            case structures_1.McpToolAnnotation:
+                (0, tools_1.assignToolToServer)(entry, server);
+                continue;
+            case structures_1.McpResourceAnnotation:
+                (0, resources_1.assignResourceToServer)(entry, server);
+                continue;
+            case structures_1.McpPromptAnnotation:
+                (0, prompts_1.assignPromptToServer)(entry, server);
+                continue;
+            default:
+                logger_1.LOGGER.warn("Invalid annotation entry - Cannot be parsed by MCP server, skipping...");
+                continue;
+        }
+    }
+    return server;
+}

package/lib/mcp/prompts.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignPromptToServer = assignPromptToServer;
+const logger_1 = require("../logger");
+const utils_1 = require("./utils");
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+// NOTE: Not satisfied with below implementation, will need to be revised for full effect
+/*
+annotate CatalogService with @mcp.prompts: [{
+  name      : 'give-me-book-abstract',
+  title     : 'Book Abstract',
+  description: 'Gives an abstract of a book based on the title',
+  template  : 'Search the internet and give me an abstract of the book {{book-id}}', = template
+  inputs    : [{ Inputs = Args
+    key : 'book-id',
+    type: 'String'
+  }]
+}];
+ */
+function assignPromptToServer(model, server) {
+    logger_1.LOGGER.debug("Adding prompt", model);
+    for (const prompt of model.prompts) {
+        const inputs = constructInputArgs(prompt.inputs);
+        server.registerPrompt(prompt.name, {
+            title: prompt.title,
+            description: prompt.description,
+            argsSchema: inputs,
+        }, async (args) => {
+            let parsedMsg = prompt.template;
+            for (const [k, v] of Object.entries(args)) {
+                parsedMsg = parsedMsg.replaceAll(`{{${k}}}`, String(v));
+            }
+            return {
+                messages: [
+                    {
+                        role: prompt.role,
+                        content: {
+                            type: "text",
+                            text: parsedMsg,
+                        },
+                    },
+                ],
+            };
+        });
+    }
+}
+function constructInputArgs(inputs) {
+    // Not happy with using any here, but zod types are hard to figure out....
+    if (!inputs || inputs.length <= 0)
+        return undefined;
+    const result = {};
+    for (const el of inputs) {
+        result[el.key] = (0, utils_1.determineMcpParameterType)(el.type);
+    }
+    return result;
+}