@gavdi/cap-mcp 1.0.2 → 1.1.1

package/README.md

@@ -1,4 +1,7 @@
 # CAP MCP Plugin - AI With Ease
+![NPM Version](https://img.shields.io/npm/v/%40gavdi%2Fcap-mcp) ![NPM License](https://img.shields.io/npm/l/%40gavdi%2Fcap-mcp) ![GitHub commits since latest release](https://img.shields.io/github/commits-since/gavdilabs/cap-mcp-plugin/latest)
+
+
 
 > This implementation is based on the Model Context Protocol (MCP) put forward by Anthropic.
 > For more information on MCP, please have a look at their [official documentation.](https://modelcontextprotocol.io/introduction)

package/cds-plugin.js

@@ -1,5 +1,9 @@
 const cds = global.cds; // enforce host app cds instance
 const McpPlugin = require("./lib/mcp").default;
+const McpBuild = require("./lib/config/build");
+
+// Build tasks
+McpBuild.registerBuildTask();
 
 const plugin = new McpPlugin();
 

package/lib/annotations/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ALL_RESOURCE_OPTIONS = exports.CDS_AUTH_ANNOTATIONS = exports.MCP_ANNOTATION_PROPS = exports.MCP_ANNOTATION_KEY = void 0;
+exports.DEFAULT_ALL_RESOURCE_OPTIONS = exports.MCP_ANNOTATION_MAPPING = exports.MCP_ANNOTATION_KEY = void 0;
 /**
  * MCP annotation constants and default configurations
  * Defines the standard annotation keys and default values used throughout the plugin
@@ -11,37 +11,27 @@ exports.DEFAULT_ALL_RESOURCE_OPTIONS = exports.CDS_AUTH_ANNOTATIONS = exports.MC
  */
 exports.MCP_ANNOTATION_KEY = "@mcp";
 /**
- * Complete set of supported MCP annotation property names
- * Maps logical names to their actual annotation keys used in CDS files
+ * Mapping of the custom annotations + CDS specific annotations and their correlated mapping for MCP usage
  */
-exports.MCP_ANNOTATION_PROPS = {
-    /** Name identifier annotation - required for all MCP elements */
-    MCP_NAME: "@mcp.name",
-    /** Description annotation - required for all MCP elements */
-    MCP_DESCRIPTION: "@mcp.description",
-    /** Resource configuration annotation for CAP entities */
-    MCP_RESOURCE: "@mcp.resource",
-    /** Tool configuration annotation for CAP functions/actions */
-    MCP_TOOL: "@mcp.tool",
-    /** Prompt templates annotation for CAP services */
-    MCP_PROMPT: "@mcp.prompts",
-    /** Wrapper configuration for exposing entities as tools - tools prop*/
-    MCP_WRAP_TOOLS: "@mcp.wrap.tools",
-    /** Wrapper configuration for exposing entities as tools - modes prop*/
-    MCP_WRAP_MODES: "@mcp.wrap.modes",
-    /** Wrapper configuration for exposing entities as tools - hint prop*/
-    MCP_WRAP_HINT: "@mcp.wrap.hint",
-    /** Elicited user input annotation for tools in CAP services */
-    MCP_ELICIT: "@mcp.elicit",
-};
-/**
- * Set of annotations used for CDS auth annotations
- * Maps logical names to their actual annotation keys used in CDS files.
- */
-exports.CDS_AUTH_ANNOTATIONS = {
-    REQUIRES: "@requires",
-    RESTRICT: "@restrict",
-};
+exports.MCP_ANNOTATION_MAPPING = new Map([
+    ["@mcp.name", "name"],
+    ["@mcp.description", "description"],
+    ["@mcp.resource", "resource"],
+    ["@mcp.tool", "tool"],
+    ["@mcp.prompts", "prompts"],
+    ["@mcp.wrap", "wrap"],
+    ["@mcp.wrap.tools", "wrap.tools"],
+    ["@mcp.wrap.modes", "wrap.modes"],
+    ["@mcp.wrap.hint", "wrap.hint"],
+    ["@mcp.wrap.hint.get", "wrap.hint.get"],
+    ["@mcp.wrap.hint.query", "wrap.hint.query"],
+    ["@mcp.wrap.hint.create", "wrap.hint.create"],
+    ["@mcp.wrap.hint.update", "wrap.hint.update"],
+    ["@mcp.wrap.hint.delete", "wrap.hint.delete"],
+    ["@mcp.elicit", "elicit"],
+    ["@requires", "requires"],
+    ["@restrict", "restrict"],
+]);
 /**
  * Default set of all available OData query options for MCP resources
  * Used when @mcp.resource is set to `true` to enable all capabilities

package/lib/annotations/parser.js

@@ -36,7 +36,7 @@ function parseDefinitions(model) {
         const verifiedAnnotations = parsedAnnotations;
         switch (def.kind) {
             case "entity":
-                const resourceAnnotation = constructResourceAnnotation(serviceName, target, verifiedAnnotations, def);
+                const resourceAnnotation = constructResourceAnnotation(serviceName, target, verifiedAnnotations, def, model);
                 if (!resourceAnnotation)
                     continue;
                 result.set(resourceAnnotation.target, resourceAnnotation);
@@ -65,6 +65,40 @@ function parseDefinitions(model) {
     }
     return result;
 }
+function mapToMcpAnnotationStructure(obj) {
+    const result = {};
+    // Helper function to set nested properties
+    const setNestedValue = (target, path, value) => {
+        const keys = path.split(".");
+        const lastKey = keys.pop();
+        const nestedTarget = keys.reduce((current, key) => {
+            if (!(key in current)) {
+                current[key] = {};
+            }
+            return current[key];
+        }, target);
+        // If the target already has a value and both are objects, merge them
+        if (typeof nestedTarget[lastKey] === "object" &&
+            typeof value === "object" &&
+            nestedTarget[lastKey] !== null &&
+            value !== null &&
+            !Array.isArray(nestedTarget[lastKey]) &&
+            !Array.isArray(value)) {
+            nestedTarget[lastKey] = { ...nestedTarget[lastKey], ...value };
+        }
+        else {
+            nestedTarget[lastKey] = value;
+        }
+    };
+    // Loop through object keys and map them
+    for (const key in obj) {
+        if (constants_1.MCP_ANNOTATION_MAPPING.has(key)) {
+            const mappedPath = constants_1.MCP_ANNOTATION_MAPPING.get(key);
+            setNestedValue(result, mappedPath, obj[key]);
+        }
+    }
+    return result;
+}
 /**
  * Parses MCP annotations from a definition object
  * @param definition - The definition object to parse annotations from
@@ -73,64 +107,11 @@ function parseDefinitions(model) {
 function parseAnnotations(definition) {
     if (!(0, utils_1.containsMcpAnnotation)(definition))
         return undefined;
+    const parsed = mapToMcpAnnotationStructure(definition);
     const annotations = {
         definition: definition,
+        ...parsed,
     };
-    for (const [k, v] of Object.entries(definition)) {
-        // Process MCP annotations and CDS auth annotations
-        if (!k.includes(constants_1.MCP_ANNOTATION_KEY) &&
-            !k.startsWith("@requires") &&
-            !k.startsWith("@restrict")) {
-            continue;
-        }
-        logger_1.LOGGER.debug("Parsing: ", k, v);
-        switch (k) {
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_NAME:
-                annotations.name = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_DESCRIPTION:
-                annotations.description = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_RESOURCE:
-                annotations.resource = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_TOOL:
-                annotations.tool = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_PROMPT:
-                annotations.prompts = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_WRAP_TOOLS:
-                if (!annotations.wrap) {
-                    annotations.wrap = {};
-                }
-                annotations.wrap.tools = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_WRAP_HINT:
-                if (!annotations.wrap) {
-                    annotations.wrap = {};
-                }
-                annotations.wrap.hint = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_WRAP_MODES:
-                if (!annotations.wrap) {
-                    annotations.wrap = {};
-                }
-                annotations.wrap.modes = v;
-                continue;
-            case constants_1.MCP_ANNOTATION_PROPS.MCP_ELICIT:
-                annotations.elicit = v;
-                continue;
-            case constants_1.CDS_AUTH_ANNOTATIONS.REQUIRES:
-                annotations.requires = v;
-                continue;
-            case constants_1.CDS_AUTH_ANNOTATIONS.RESTRICT:
-                annotations.restrict = v;
-                continue;
-            default:
-                continue;
-        }
-    }
     return annotations;
 }
 /**
@@ -141,11 +122,11 @@ function parseAnnotations(definition) {
  * @param definition - CSN definition object
  * @returns Resource annotation or undefined if invalid
  */
-function constructResourceAnnotation(serviceName, target, annotations, definition) {
+function constructResourceAnnotation(serviceName, target, annotations, definition, model) {
     if (!(0, utils_1.isValidResourceAnnotation)(annotations))
         return undefined;
     const functionalities = (0, utils_1.determineResourceOptions)(annotations);
-    const { properties, resourceKeys } = (0, utils_1.parseResourceElements)(definition);
+    const { properties, resourceKeys } = (0, utils_1.parseResourceElements)(definition, model);
     const restrictions = (0, utils_1.parseCdsRestrictions)(annotations.restrict, annotations.requires);
     return new structures_1.McpResourceAnnotation(annotations.name, annotations.description, target, serviceName, functionalities, properties, resourceKeys, annotations.wrap, restrictions);
 }

package/lib/annotations/utils.js

@@ -153,18 +153,42 @@ function determineResourceOptions(annotations) {
  * @param definition - The definition to parse
  * @returns Object containing properties and resource keys maps
  */
-function parseResourceElements(definition) {
+function parseResourceElements(definition, model) {
     const properties = new Map();
     const resourceKeys = new Map();
-    for (const [key, value] of Object.entries(definition.elements || {})) {
-        if (!value.type)
+    const parseParam = (k, v, suffix) => {
+        let result = "";
+        if (typeof v.type !== "string") {
+            const referencedType = parseTypedReference(v.type, model);
+            result = `${referencedType}${suffix ?? ""}`;
+        }
+        else {
+            result = `${v.type.replace("cds.", "")}${suffix ?? ""}`;
+        }
+        properties?.set(k, result);
+        return result;
+    };
+    for (const [k, v] of Object.entries(definition.elements || {})) {
+        if (v.items) {
+            const result = parseParam(k, v.items, "Array");
+            if (!v.key)
+                continue;
+            resourceKeys.set(k, result);
             continue;
-        const parsedType = value.type.replace("cds.", "");
-        properties.set(key, parsedType);
-        if (!value.key)
+        }
+        const result = parseParam(k, v);
+        if (!v.key)
             continue;
-        resourceKeys.set(key, parsedType);
+        resourceKeys.set(k, result);
     }
+    // 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,
@@ -177,21 +201,23 @@ function parseResourceElements(definition) {
  */
 function parseOperationElements(annotations, model) {
     let parameters;
+    const parseParam = (k, v, suffix) => {
+        if (typeof v.type !== "string") {
+            const referencedType = parseTypedReference(v.type, model);
+            parameters?.set(k, `${referencedType}${suffix ?? ""}`);
+            return;
+        }
+        parameters?.set(k, `${v.type.replace("cds.", "")}${suffix ?? ""}`);
+    };
     const params = annotations.definition["params"];
     if (params && Object.entries(params).length > 0) {
         parameters = new Map();
         for (const [k, v] of Object.entries(params)) {
-            if (typeof v.type !== "string") {
-                // const references = v.type.ref;
-                // const typeReference =
-                //   model.definitions?.[references[0]].elements[references[1]];
-                // parameters.set(k, typeReference?.type?.replace("cds.", "") as string);
-                const referencedType = parseTypedReference(v.type, model);
-                parameters.set(k, referencedType);
-                logger_1.LOGGER.debug("Typed reference found", referencedType);
+            if (v.items) {
+                parseParam(k, v.items, "Array");
                 continue;
             }
-            parameters.set(k, v.type.replace("cds.", ""));
+            parseParam(k, v);
         }
     }
     return {

package/lib/config/build.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuildTask = registerBuildTask;
+const logger_1 = require("../logger");
+const json_parser_1 = require("./json-parser");
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+function registerBuildTask() {
+    cds.build?.register("mcp", class McpBuildPlugin extends cds.build.Plugin {
+        static taskDefaults = {};
+        static instructionsPath;
+        static hasTask() {
+            const config = cds.env.mcp;
+            if (!config) {
+                return false;
+            }
+            else if (typeof config === "object") {
+                this.instructionsPath =
+                    typeof config.instructions === "object"
+                        ? config.instructions.file
+                        : undefined;
+                return (this.instructionsPath !== undefined &&
+                    this.instructionsPath.length > 0);
+            }
+            const parsed = (0, json_parser_1.parseCAPConfiguration)(config);
+            if (!parsed || typeof parsed.instructions !== "object") {
+                return false;
+            }
+            this.instructionsPath =
+                typeof parsed.instructions === "object"
+                    ? parsed.instructions.file
+                    : undefined;
+            return (this.instructionsPath !== undefined &&
+                this.instructionsPath.length > 0);
+        }
+        async build() {
+            logger_1.LOGGER.debug("Performing build task - copy MCP instructions");
+            if (!McpBuildPlugin.instructionsPath) {
+                return;
+            }
+            if (cds.utils.fs.existsSync(this.task.src, McpBuildPlugin.instructionsPath)) {
+                await this.copy(McpBuildPlugin.instructionsPath).to(cds.utils.path.join("srv", McpBuildPlugin.instructionsPath));
+            }
+        }
+    });
+}

package/lib/config/instructions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMcpInstructions = getMcpInstructions;
+exports.readInstructionsFile = readInstructionsFile;
+const cds_1 = require("@sap/cds");
+function getMcpInstructions(config) {
+    if (!config.instructions) {
+        return undefined;
+    }
+    if (typeof config.instructions === "string") {
+        return config.instructions;
+    }
+    return config.instructions.file
+        ? readInstructionsFile(config.instructions.file)
+        : undefined;
+}
+function readInstructionsFile(path) {
+    if (!containsMarkdownType(path)) {
+        throw new Error("Invalid file type provided for instructions");
+    }
+    else if (!cds_1.utils.fs.existsSync(path)) {
+        throw new Error("Instructions file not found");
+    }
+    const file = cds_1.utils.fs.readFileSync(path);
+    return file.toString("utf8");
+}
+function containsMarkdownType(path) {
+    const extension = path.substring(path.length - 3);
+    return extension === ".md";
+}

package/lib/mcp/describe-model.js

@@ -30,24 +30,26 @@ function registerDescribeModelTool(server) {
         const refl = CDS.reflect(CDS.model);
         const listServices = () => {
             const names = Object.values(CDS.services || {})
-                .map((s) => s?.definition?.name || s?.name)
+                .map((s) => s?.namespace || s?.definition?.name || s?.name)
                 .filter(Boolean);
             return { services: [...new Set(names)].sort() };
         };
         const listEntities = (service) => {
-            const all = Object.values(refl.entities || {}) || [];
+            const all = Object.entries(refl.definitions || {})
+                .filter((x) => x[1].kind == "entity" && !x[0].startsWith("cds.")) // ignore entities such as "cds.outbox.Messages"
+                .map((x) => x[0]);
             const filtered = service
-                ? all.filter((e) => String(e.name).startsWith(service + "."))
+                ? all.filter((e) => e.startsWith(service + "."))
                 : all;
             return {
-                entities: filtered.map((e) => e.name).sort(),
+                entities: filtered.sort(),
             };
         };
         const describeEntity = (service, entity) => {
             if (!entity)
                 return { error: "Please provide 'entity'." };
             const fqn = service && !entity.includes(".") ? `${service}.${entity}` : entity;
-            const ent = (refl.entities || {})[fqn] || (refl.entities || {})[entity];
+            const ent = (refl.definitions || {})[fqn] || (refl.definitions || {})[entity];
             if (!ent)
                 return {
                     error: `Entity not found: ${entity}${service ? ` (service ${service})` : ""}`,

package/lib/mcp/entity-tools.js

@@ -247,8 +247,8 @@ function registerQueryTool(resAnno, server, authEnabled) {
         aggregate: inputZod.shape.aggregate,
         explain: inputZod.shape.explain,
     };
-    const hint = resAnno.wrap?.hint ? ` Hint: ${resAnno.wrap?.hint}` : "";
-    const desc = `${buildEnhancedQueryDescription(resAnno)} CRITICAL: Use foreign key fields (e.g., author_ID) for associations - association names (e.g., author) won't work in filters.` +
+    const hint = constructHintMessage(resAnno, "query");
+    const desc = `Resource description: ${resAnno.description}. ${buildEnhancedQueryDescription(resAnno)} CRITICAL: Use foreign key fields (e.g., author_ID) for associations - association names (e.g., author) won't work in filters.` +
         hint;
     const queryHandler = async (rawArgs) => {
         const parsed = inputZod.safeParse(rawArgs);
@@ -298,8 +298,8 @@ function registerGetTool(resAnno, server, authEnabled) {
         inputSchema[k] = (0, utils_2.determineMcpParameterType)(cdsType).describe(`Key ${k}`);
     }
     const keyList = Array.from(resAnno.resourceKeys.keys()).join(", ");
-    const hint = resAnno.wrap?.hint ? ` Hint: ${resAnno.wrap?.hint}` : "";
-    const desc = `Get one ${resAnno.target} by key(s): ${keyList}. For fields & examples call cap_describe_model.${hint}`;
+    const hint = constructHintMessage(resAnno, "get");
+    const desc = `Resource description: ${resAnno.description}. Get one ${resAnno.target} by key(s): ${keyList}. For fields & examples call cap_describe_model.${hint}`;
     const getHandler = async (args) => {
         const startTime = Date.now();
         const CDS = global.cds;
@@ -376,12 +376,12 @@ function registerCreateTool(resAnno, server, authEnabled) {
                 .optional();
             continue;
         }
-        inputSchema[propName] = (0, utils_2.determineMcpParameterType)(cdsType)
+        inputSchema[propName] = (0, utils_2.determineMcpParameterType)(cdsType, propName, `${resAnno.serviceName}.${resAnno.target}`)
             .optional()
             .describe(`Field ${propName}`);
     }
-    const hint = resAnno.wrap?.hint ? ` Hint: ${resAnno.wrap?.hint}` : "";
-    const desc = `Create a new ${resAnno.target}. Provide fields; service applies defaults.${hint}`;
+    const hint = constructHintMessage(resAnno, "create");
+    const desc = `Resource description: ${resAnno.description}. Create a new ${resAnno.target}. Provide fields; service applies defaults.${hint}`;
     const createHandler = async (args) => {
         const CDS = global.cds;
         const { INSERT } = CDS.ql;
@@ -465,13 +465,13 @@ function registerUpdateTool(resAnno, server, authEnabled) {
                 .optional();
             continue;
         }
-        inputSchema[propName] = (0, utils_2.determineMcpParameterType)(cdsType)
+        inputSchema[propName] = (0, utils_2.determineMcpParameterType)(cdsType, propName, `${resAnno.serviceName}.${resAnno.target}`)
             .optional()
             .describe(`Field ${propName}`);
     }
     const keyList = Array.from(resAnno.resourceKeys.keys()).join(", ");
-    const hint = resAnno.wrap?.hint ? ` Hint: ${resAnno.wrap?.hint}` : "";
-    const desc = `Update ${resAnno.target} by key(s): ${keyList}. Provide fields to update.${hint}`;
+    const hint = constructHintMessage(resAnno, "update");
+    const desc = `Resource description: ${resAnno.description}. Update ${resAnno.target} by key(s): ${keyList}. Provide fields to update.${hint}`;
     const updateHandler = async (args) => {
         const CDS = global.cds;
         const { UPDATE } = CDS.ql;
@@ -559,8 +559,8 @@ function registerDeleteTool(resAnno, server, authEnabled) {
         inputSchema[k] = (0, utils_2.determineMcpParameterType)(cdsType).describe(`Key ${k}`);
     }
     const keyList = Array.from(resAnno.resourceKeys.keys()).join(", ");
-    const hint = resAnno.wrap?.hint ? ` Hint: ${resAnno.wrap?.hint}` : "";
-    const desc = `Delete ${resAnno.target} by key(s): ${keyList}. This operation cannot be undone.${hint}`;
+    const hint = constructHintMessage(resAnno, "delete");
+    const desc = `Resource description: ${resAnno.description}. Delete ${resAnno.target} by key(s): ${keyList}. This operation cannot be undone.${hint}`;
     const deleteHandler = async (args) => {
         const CDS = global.cds;
         const { DELETE } = CDS.ql;
@@ -687,7 +687,11 @@ async function executeQuery(CDS, svc, args, baseQuery) {
     const { SELECT } = CDS.ql;
     switch (args.return) {
         case "count": {
-            const countQuery = SELECT.from(baseQuery.SELECT.from).columns("count(1) as count");
+            const countQuery = SELECT.from(baseQuery.SELECT.from)
+                .columns("count(1) as count")
+                .where(baseQuery.SELECT.where)
+                .limit(baseQuery.SELECT.limit?.rows?.val, baseQuery.SELECT.limit?.offset?.val)
+                .orderBy(baseQuery.SELECT.orderBy);
             const result = await svc.run(countQuery);
             const row = Array.isArray(result) ? result[0] : result;
             return { count: row?.count ?? 0 };
@@ -696,10 +700,26 @@ async function executeQuery(CDS, svc, args, baseQuery) {
             if (!args.aggregate?.length)
                 return [];
             const cols = args.aggregate.map((a) => `${a.fn}(${a.field}) as ${a.fn}_${a.field}`);
-            const aggQuery = SELECT.from(baseQuery.SELECT.from).columns(...cols);
-            return svc.run(aggQuery);
+            const aggQuery = SELECT.from(baseQuery.SELECT.from)
+                .columns(...cols)
+                .where(baseQuery.SELECT.where)
+                .limit(baseQuery.SELECT.limit?.rows?.val, baseQuery.SELECT.limit?.offset?.val)
+                .orderBy(baseQuery.SELECT.orderBy);
+            return await svc.run(aggQuery);
         }
         default:
-            return svc.run(baseQuery);
+            return await svc.run(baseQuery);
     }
 }
+function constructHintMessage(resAnno, wrapAction) {
+    if (!resAnno.wrap?.hint) {
+        return "";
+    }
+    else if (typeof resAnno.wrap.hint === "string") {
+        return ` Hint: ${resAnno.wrap?.hint}`;
+    }
+    if (typeof resAnno.wrap.hint !== "object") {
+        throw new Error(`Unparseable hint provided for entity: ${resAnno.name}`);
+    }
+    return ` Hint: ${resAnno.wrap.hint[wrapAction] ?? ""}`;
+}

package/lib/mcp/factory.js

@@ -12,6 +12,7 @@ const utils_1 = require("../auth/utils");
 // Use relative import without extension for ts-jest resolver compatibility
 const entity_tools_1 = require("./entity-tools");
 const describe_model_1 = require("./describe-model");
+const instructions_1 = require("../config/instructions");
 /**
  * Creates and configures an MCP server instance with the given configuration and annotations
  * @param config - CAP configuration object
@@ -24,7 +25,7 @@ function createMcpServer(config, annotations) {
         name: config.name,
         version: config.version,
         capabilities: config.capabilities,
-    }, { instructions: config.instructions });
+    }, { instructions: (0, instructions_1.getMcpInstructions)(config) });
     if (!annotations) {
         logger_1.LOGGER.debug("No annotations provided, skipping registration...");
         return server;

package/lib/mcp/utils.js

@@ -7,23 +7,125 @@ exports.toolError = toolError;
 exports.asMcpResult = asMcpResult;
 const constants_1 = require("./constants");
 const zod_1 = require("zod");
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
 /**
  * Converts a CDS type string to the corresponding Zod schema type
  * @param cdsType - The CDS type name (e.g., 'String', 'Integer')
  * @returns Zod schema instance for the given type
  */
-function determineMcpParameterType(cdsType) {
+function determineMcpParameterType(cdsType, key, target) {
     switch (cdsType) {
         case "String":
             return zod_1.z.string();
+        case "UUID":
+            return zod_1.z.string();
+        case "Date":
+            return zod_1.z.date();
+        case "Time":
+            return zod_1.z.date();
+        case "DateTime":
+            return zod_1.z.date();
+        case "Timestamp":
+            return zod_1.z.number();
         case "Integer":
             return zod_1.z.number();
+        case "Int16":
+            return zod_1.z.number();
+        case "Int32":
+            return zod_1.z.number();
+        case "Int64":
+            return zod_1.z.number();
+        case "UInt8":
+            return zod_1.z.number();
+        case "Decimal":
+            return zod_1.z.number();
+        case "Double":
+            return zod_1.z.number();
         case "Boolean":
             return zod_1.z.boolean();
+        case "Binary":
+            return zod_1.z.string();
+        case "LargeBinary":
+            return zod_1.z.string();
+        case "LargeString":
+            return zod_1.z.string();
+        case "Map":
+            return zod_1.z.object({});
+        case "StringArray":
+            return zod_1.z.array(zod_1.z.string());
+        case "DateArray":
+            return zod_1.z.array(zod_1.z.date());
+        case "TimeArray":
+            return zod_1.z.array(zod_1.z.date());
+        case "DateTimeArray":
+            return zod_1.z.array(zod_1.z.date());
+        case "TimestampArray":
+            return zod_1.z.array(zod_1.z.number());
+        case "UUIDArray":
+            return zod_1.z.array(zod_1.z.string());
+        case "IntegerArray":
+            return zod_1.z.array(zod_1.z.number());
+        case "Int16Array":
+            return zod_1.z.array(zod_1.z.number());
+        case "Int32Array":
+            return zod_1.z.array(zod_1.z.number());
+        case "Int64Array":
+            return zod_1.z.array(zod_1.z.number());
+        case "UInt8Array":
+            return zod_1.z.array(zod_1.z.number());
+        case "DecimalArray":
+            return zod_1.z.array(zod_1.z.number());
+        case "BooleanArray":
+            return zod_1.z.array(zod_1.z.boolean());
+        case "DoubleArray":
+            return zod_1.z.array(zod_1.z.number());
+        case "BinaryArray":
+            return zod_1.z.array(zod_1.z.string());
+        case "LargeBinaryArray":
+            return zod_1.z.array(zod_1.z.string());
+        case "LargeStringArray":
+            return zod_1.z.array(zod_1.z.string());
+        case "MapArray":
+            return zod_1.z.array(zod_1.z.object({}));
+        case "Composition":
+            return buildCompositionZodType(key, target);
         default:
             return zod_1.z.string();
     }
 }
+/**
+ * Builds the complex ZodType for a CDS type of 'Composition'
+ * @param key
+ * @param target
+ * @returns ZodType
+ */
+function buildCompositionZodType(key, target) {
+    const model = cds.model;
+    if (!model.definitions || !target || !key) {
+        return zod_1.z.object({}); // fallback, might have to reconsider type later
+    }
+    const targetDef = model.definitions[target];
+    const targetProp = targetDef.elements[key];
+    const comp = model.definitions[targetProp.target];
+    if (!comp) {
+        return zod_1.z.object({});
+    }
+    const isArray = targetProp.cardinality !== undefined;
+    const compProperties = new Map();
+    for (const [k, v] of Object.entries(comp.elements)) {
+        if (!v.type)
+            continue;
+        const parsedType = v.type.replace("cds.", "");
+        if (parsedType === "Association" || parsedType === "Composition")
+            continue; // We will not support nested compositions for now
+        const isOptional = !v.key && !v.notNull;
+        const paramType = determineMcpParameterType(parsedType);
+        compProperties.set(k, isOptional ? paramType.optional() : paramType);
+    }
+    const zodType = zod_1.z.object(Object.fromEntries(compProperties));
+    return isArray ? zod_1.z.array(zodType) : zodType;
+}
 /**
  * Handles incoming MCP session requests by validating session IDs and routing to appropriate session
  * @param req - Express request object containing session headers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavdi/cap-mcp",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "MCP Pluging for CAP",
   "keywords": [
     "MCP",