@gavdi/cap-mcp 0.9.1 → 0.9.3

package/README.md

@@ -23,15 +23,10 @@ By integrating MCP with your CAP applications, you unlock:
 
 ## ⚠️ Development Status
 
-**This plugin is currently in active development (v0.9.0) and is not ready for production use.**
-APIs and annotations may change in future releases. Use in development and testing environments only.
+**This plugin is currently in active development (v0.9.2) and approaching production readiness.**
+APIs and annotations may change in future releases. Authentication and security features are implemented and tested.
 
-Version 1.0 of the plugin is planned to release shortly after auth integration is complete.
-
-### 👾 Known Bugs
-
-> ❗Currently there is a bug in the `@modelcontextprotocol/sdk` package that breaks the RFC template strings. The issue has been reported.
-> Until this issue is fixed, the resource reads for dynamic queries are only possible if all query options are provided.
+Version 1.0 of the plugin is scheduled for release in Summer 2025 after final stability testing and documentation completion.
 
 ## 📦 Installation
 
@@ -41,6 +36,78 @@ npm install @gavdi/cap-mcp
 
 The plugin follows CAP's standard plugin architecture and will automatically integrate with your CAP application.
 
+## 🚀 Quick Setup
+
+### Prerequisites
+
+- **Node.js**: Version 18 or higher
+- **SAP CAP**: Version 9 or higher
+- **Express**: Version 4 or higher
+- **TypeScript**: Optional but recommended
+
+### Step 1: Install the Plugin
+
+```bash
+npm install @gavdi/cap-mcp
+```
+
+### Step 2: Configure Your CAP Application
+
+Add MCP configuration to your `package.json`:
+
+```json
+{
+  "cds": {
+    "mcp": {
+      "name": "my-bookshop-mcp",
+      "auth": "inherit"
+    }
+  }
+}
+```
+
+### Step 3: Add MCP Annotations
+
+Annotate your CAP services with `@mcp` annotations:
+
+```cds
+// srv/catalog-service.cds
+service CatalogService {
+
+  @mcp: {
+    name: 'books',
+    description: 'Book catalog with search and filtering',
+    resource: ['filter', 'orderby', 'select', 'top', 'skip']
+  }
+  entity Books as projection on my.Books;
+
+  @mcp: {
+    name: 'get-book-recommendations',
+    description: 'Get personalized book recommendations',
+    tool: true
+  }
+  function getRecommendations(genre: String, limit: Integer) returns array of String;
+}
+```
+
+### Step 4: Start Your Application
+
+```bash
+cds serve
+```
+
+The MCP server will be available at:
+- **MCP Endpoint**: `http://localhost:4004/mcp`
+- **Health Check**: `http://localhost:4004/mcp/health`
+
+### Step 5: Test with MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector
+```
+
+Connect to `http://localhost:4004/mcp` to explore your generated MCP resources, tools, and prompts.
+
 ## 🎯 Features
 
 This plugin transforms your annotated CAP services into a fully functional MCP server that can be consumed by any MCP-compatible AI client.
@@ -142,10 +209,97 @@ annotate CatalogService with @mcp.prompts: [{
 
 ## 🔧 Configuration
 
+### Plugin Configuration
+
+Configure the MCP plugin through your CAP application's `package.json` or `.cdsrc` file:
+
+```json
+{
+  "cds": {
+    "mcp": {
+      "name": "my-mcp-server",
+      "version": "1.0.0",
+      "auth": "inherit",
+      "capabilities": {
+        "resources": {
+          "listChanged": true,
+          "subscribe": false
+        },
+        "tools": {
+          "listChanged": true
+        },
+        "prompts": {
+          "listChanged": true
+        }
+      }
+    }
+  }
+}
+```
+
+### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `name` | string | package.json name | MCP server name |
+| `version` | string | package.json version | MCP server version |
+| `auth` | `"inherit"` \| `"none"` | `"inherit"` | Authentication mode |
+| `capabilities.resources.listChanged` | boolean | `true` | Enable resource list change notifications |
+| `capabilities.resources.subscribe` | boolean | `false` | Enable resource subscriptions |
+| `capabilities.tools.listChanged` | boolean | `true` | Enable tool list change notifications |
+| `capabilities.prompts.listChanged` | boolean | `true` | Enable prompt list change notifications |
+
+### Authentication Configuration
+
+The plugin supports two authentication modes:
+
+#### `"inherit"` Mode (Default)
+Uses your CAP application's existing authentication system:
+
+```json
+{
+  "cds": {
+    "mcp": {
+      "auth": "inherit"
+    },
+    "requires": {
+      "auth": {
+        "kind": "xsuaa"
+      }
+    }
+  }
+}
+```
+
+#### `"none"` Mode (Development/Testing)
+Disables authentication completely:
+
+```json
+{
+  "cds": {
+    "mcp": {
+      "auth": "none"
+    }
+  }
+}
+```
+
+**⚠️ Security Warning**: Only use `"none"` mode in development environments. Never deploy to production without proper authentication.
+
+#### Authentication Flow
+1. MCP client connects to `/mcp` endpoint
+2. CAP authentication middleware validates credentials (if `auth: "inherit"`)
+3. MCP session established with authenticated user context
+4. All MCP operations (resources, tools, prompts) inherit the authenticated user's permissions
+
+### Automatic Features
+
 The plugin automatically:
 - Scans your CAP service definitions for `@mcp` annotations
 - Generates appropriate MCP resources, tools, and prompts
 - Creates ResourceTemplates with proper OData v4 query parameter support
+- Sets up HTTP endpoints at `/mcp` and `/mcp/health`
+- Manages MCP session lifecycle and cleanup
 
 ## 🌟 Example AI Interactions
 
@@ -233,11 +387,13 @@ Would you like me to help you review any of these in detail?"
 - **Integration Ready**: Works with existing CAP-based workflow systems
 - **Mobile Friendly**: Access approvals from any MCP-compatible AI client
 
-## 🧰 Testing Locally
+## 🧰 Development & Testing
+
+### Testing Your MCP Implementation
 
 If you want to test the MCP implementation you have made on your CAP application locally, you have 2 options available (that does not involve direct integration with AI Agent).
 
-### Option #1 - MCP Inspector
+#### Option #1 - MCP Inspector
 
 You can inspect the MCP implementation by utilizing the official `@modelcontextprotocol/inspector`.
 
@@ -247,10 +403,28 @@ For plugin implementation implementation in your own project it is recommended t
 
 For more information on the inspector, please [see the official documentation](https://github.com/modelcontextprotocol/inspector).
 
-### Option #2 - Bruno Collection
+#### Option #2 - Bruno Collection
 
 This repository comes with a Bruno collection available that includes some example queries you can use to verify your MCP implementation. These can be found in the `bruno` directory.
 
+#### Option #3 - Automated Testing
+
+Run the comprehensive test suite to validate your implementation:
+
+```bash
+# Test specific components
+npm test -- --testPathPattern=annotations  # Test annotation parsing
+npm test -- --testPathPattern=mcp          # Test MCP functionality
+npm test -- --testPathPattern=security     # Test security boundaries
+npm test -- --testPathPattern=auth         # Test authentication
+
+# Run with detailed output
+npm test -- --verbose
+
+# Run in watch mode for development
+npm test -- --watch
+```
+
 ## 🤝 Contributing
 
 Contributions are welcome! This is an open-source project aimed at bridging CAP applications with the AI ecosystem.
@@ -264,11 +438,90 @@ Contributions are welcome! This is an open-source project aimed at bridging CAP
 
 This project is licensed under the Apache-2.0 License - see the [LICENSE.md](LICENSE.md) file for details.
 
+## 🔧 Troubleshooting
+
+### Common Issues
+
+#### MCP Server Not Starting
+- **Check Port Availability**: Ensure port 4004 is not in use by another process
+- **Verify CAP Service**: Make sure your CAP application starts successfully with `cds serve`
+- **Authentication Issues**: If using `auth: "inherit"`, ensure your CAP authentication is properly configured
+
+#### MCP Client Connection Failures
+```bash
+# Check if MCP endpoint is accessible
+curl http://localhost:4004/mcp/health
+
+# Expected response:
+# {"status": "healthy", "timestamp": "2025-01-XX..."}
+```
+
+#### Annotation Not Working
+- **Syntax Check**: Verify your `@mcp` annotation syntax matches the examples
+- **Service Deployment**: Ensure annotated entities/functions are properly deployed
+- **Case Sensitivity**: Check that annotation properties use correct casing (`resource`, `tool`, `prompts`)
+
+#### OData Query Issues
+- **SDK Bug Workaround**: Due to the known `@modelcontextprotocol/sdk` bug, provide all query parameters when using dynamic queries
+- **Parameter Validation**: Ensure query parameters match OData v4 syntax
+
+#### Performance Issues
+- **Resource Filtering**: Use specific `resource` arrays instead of `true` for large datasets
+- **Query Optimization**: Implement proper database indexes for frequently queried fields
+
+### Debugging
+
+#### Enable Debug Logging
+```json
+{
+  "cds": {
+    "log": {
+      "levels": {
+        "mcp": "debug"
+      }
+    }
+  }
+}
+```
+
+#### Test MCP Implementation
+```bash
+# Use MCP Inspector for interactive testing
+npm run inspect
+
+# Or run integration tests
+npm test -- --testPathPattern=integration
+```
+
+### Getting Help
+
+- **GitHub Issues**: Report bugs at [gavdilabs/cap-mcp-plugin](https://github.com/gavdilabs/cap-mcp-plugin/issues)
+- **Documentation**: Check [MCP Specification](https://modelcontextprotocol.io) for protocol details
+- **CAP Support**: Refer to [SAP CAP Documentation](https://cap.cloud.sap) for CAP-specific issues
+
+## 🚨 Performance & Limitations
+
+### Known Limitations
+- **SDK Bug**: Dynamic resource queries require all query parameters due to `@modelcontextprotocol/sdk` RFC template string issue
+- **Authentication Inheritance**: MCP authentication is tightly coupled to CAP's authentication system
+- **Session Cleanup**: MCP sessions are cleaned up on HTTP connection close, not on explicit disconnect
+
+### Performance Considerations
+- **Large Datasets**: Use `resource: ['top']` or similar constraints for entities with many records
+- **Complex Queries**: OData query parsing adds overhead - consider caching for frequently accessed data
+- **Concurrent Sessions**: Each MCP client creates a separate session - monitor memory usage with many clients
+
+### Scale Recommendations
+- **Development**: No specific limits
+- **Production**: Test with expected concurrent MCP client count
+- **Enterprise**: Consider load balancing for high-availability scenarios
+
 ## 🔗 Resources
 
 - [Model Context Protocol Specification](https://modelcontextprotocol.io)
 - [SAP CAP Documentation](https://cap.cloud.sap)
 - [OData v4 Specification](https://odata.org)
+- [MCP Inspector Tool](https://github.com/modelcontextprotocol/inspector)
 
 ---
 (c) Copyright by Gavdi Labs 2025 - All Rights Reserved

package/lib/auth/adapter.js

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

package/lib/auth/handler.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authHandlerFactory = authHandlerFactory;
+exports.errorHandlerFactory = errorHandlerFactory;
+/** JSON-RPC 2.0 error code for unauthorized requests */
+const RPC_UNAUTHORIZED = 10;
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+/**
+ * Creates an Express middleware for MCP authentication validation.
+ *
+ * This handler validates that requests are properly authenticated based on the CAP authentication
+ * configuration. It checks for authorization headers (except for 'dummy' auth), validates the
+ * CAP context, and ensures a valid user is present.
+ *
+ * The middleware performs the following validations:
+ * 1. Checks for Authorization header (unless CAP auth is 'dummy')
+ * 2. Validates that CAP context is properly initialized
+ * 3. Ensures an authenticated user exists and is not anonymous
+ *
+ * @returns Express RequestHandler middleware function
+ *
+ * @example
+ * ```typescript
+ * const authMiddleware = authHandlerFactory();
+ * app.use('/mcp', authMiddleware);
+ * ```
+ *
+ * @throws {401} When authorization header is missing (non-dummy auth)
+ * @throws {401} When user is not authenticated or is anonymous
+ * @throws {500} When CAP context is not properly loaded
+ */
+function authHandlerFactory() {
+    const authKind = cds.env.requires.auth.kind;
+    return (req, res, next) => {
+        if (!req.headers.authorization && authKind !== "dummy") {
+            res.status(401).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: RPC_UNAUTHORIZED,
+                    message: "Unauthorized",
+                    id: null,
+                },
+            });
+            return;
+        }
+        const ctx = cds.context;
+        if (!ctx) {
+            res.status(500).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32603,
+                    message: "Internal Error: Context not correctly loaded",
+                    id: null,
+                },
+            });
+            return;
+        }
+        const user = ctx.user;
+        if (!user || user === cds.User.anonymous) {
+            res.status(401).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: RPC_UNAUTHORIZED,
+                    message: "Unauthorized",
+                    id: null,
+                },
+            });
+            return;
+        }
+        return next();
+    };
+}
+/**
+ * Creates an Express error handling middleware for CAP authentication errors.
+ *
+ * This error handler catches authentication and authorization errors thrown by CAP
+ * middleware and converts them to JSON-RPC 2.0 compliant error responses. It handles
+ * both 401 (Unauthorized) and 403 (Forbidden) errors specifically.
+ *
+ * @returns Express ErrorRequestHandler middleware function
+ *
+ * @example
+ * ```typescript
+ * const errorHandler = errorHandlerFactory();
+ * app.use('/mcp', errorHandler);
+ * ```
+ *
+ * @param err - The error object, expected to be 401 or 403 for auth errors
+ * @param req - Express request object (unused, marked with underscore)
+ * @param res - Express response object for sending error responses
+ * @param next - Express next function for passing unhandled errors
+ */
+function errorHandlerFactory() {
+    return (err, _, res, next) => {
+        if (err === 401 || err === 403) {
+            res.status(err).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: RPC_UNAUTHORIZED,
+                    message: err === 401 ? "Unauthorized" : "Forbidden",
+                    id: null,
+                },
+            });
+            return;
+        }
+        next(err);
+    };
+}

package/lib/auth/mock.js

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

package/lib/auth/utils.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthEnabled = isAuthEnabled;
+exports.getAccessRights = getAccessRights;
+exports.registerAuthMiddleware = registerAuthMiddleware;
+const handler_1 = require("./handler");
+/**
+ * @fileoverview Authentication utilities for MCP-CAP integration.
+ *
+ * This module provides utilities for integrating CAP authentication with MCP servers.
+ * It supports all standard CAP authentication types and provides functions for:
+ * - Determining authentication status
+ * - Managing user access rights
+ * - Registering authentication middleware
+ *
+ * Supported CAP authentication types:
+ * - 'dummy': No authentication (privileged access)
+ * - 'mocked': Mock users with predefined credentials
+ * - 'basic': HTTP Basic Authentication
+ * - 'jwt': Generic JWT token validation
+ * - 'xsuaa': SAP BTP XSUAA OAuth2/JWT authentication
+ * - 'ias': SAP Identity Authentication Service
+ * - Custom string types for user-defined authentication strategies
+ *
+ * Access CAP auth configuration via: cds.env.requires.auth.kind
+ */
+/* @ts-ignore */
+const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
+/**
+ * Determines whether authentication is enabled for the MCP plugin.
+ *
+ * This function checks the plugin configuration to determine if authentication
+ * should be enforced. When authentication is disabled ('none'), the plugin
+ * operates with privileged access. For security reasons, this function defaults
+ * to enabling authentication unless explicitly disabled.
+ *
+ * @param configEnabled - The MCP authentication configuration type
+ * @returns true if authentication is enabled, false if disabled
+ *
+ * @example
+ * ```typescript
+ * const authEnabled = isAuthEnabled('inherit'); // true
+ * const noAuth = isAuthEnabled('none');         // false
+ * ```
+ *
+ * @since 1.0.0
+ */
+function isAuthEnabled(configEnabled) {
+    if (configEnabled === "none")
+        return false;
+    return true; // For now this will always default to true, as we do not want to falsely give access
+}
+/**
+ * Retrieves the appropriate user context for CAP service operations.
+ *
+ * This function returns the correct user context based on whether authentication
+ * is enabled. When authentication is enabled, it uses the current authenticated
+ * user from the CAP context. When disabled, it provides privileged access.
+ *
+ * The returned User object is used for:
+ * - Authorization checks in CAP services
+ * - Audit logging and traceability
+ * - Row-level security and data filtering
+ *
+ * @param authEnabled - Whether authentication is currently enabled
+ * @returns CAP User object with appropriate access rights
+ *
+ * @example
+ * ```typescript
+ * const user = getAccessRights(true);  // Returns cds.context.user
+ * const admin = getAccessRights(false); // Returns cds.User.privileged
+ *
+ * // Use in CAP service calls
+ * const result = await service.tx({ user }).run(query);
+ * ```
+ *
+ * @throws {Error} When authentication is enabled but no user context exists
+ * @since 1.0.0
+ */
+function getAccessRights(authEnabled) {
+    return authEnabled ? cds.context.user : cds.User.privileged;
+}
+/**
+ * Registers comprehensive authentication middleware for MCP endpoints.
+ *
+ * This function sets up the complete authentication middleware chain for MCP endpoints.
+ * It integrates with CAP's authentication system by:
+ *
+ * 1. Applying all CAP 'before' middleware (including auth middleware)
+ * 2. Adding error handling for authentication failures
+ * 3. Adding MCP-specific authentication validation
+ *
+ * The middleware chain handles all CAP authentication types automatically and
+ * converts authentication errors to JSON-RPC 2.0 compliant responses.
+ *
+ * Middleware execution order:
+ * 1. CAP middleware chain (authentication, logging, etc.)
+ * 2. Authentication error handler
+ * 3. MCP authentication validator
+ *
+ * @param expressApp - Express application instance to register middleware on
+ *
+ * @example
+ * ```typescript
+ * const app = express();
+ * registerAuthMiddleware(app);
+ *
+ * // Now all /mcp routes are protected with CAP authentication
+ * app.post('/mcp', mcpHandler);
+ * ```
+ *
+ * @throws {Error} When CAP middleware chain is not properly initialized
+ * @since 1.0.0
+ */
+function registerAuthMiddleware(expressApp) {
+    const middlewares = cds.middlewares.before; // No types exists for this part of the CDS library
+    // Build array of auth middleware to apply
+    const authMiddleware = [];
+    // Add CAP middleware
+    middlewares.forEach((mw) => {
+        const process = mw.factory();
+        if (process && process.length > 0) {
+            authMiddleware.push(process);
+        }
+    });
+    // Add MCP auth middleware
+    authMiddleware.push((0, handler_1.errorHandlerFactory)());
+    authMiddleware.push((0, handler_1.authHandlerFactory)());
+    // Apply auth middleware to all /mcp routes EXCEPT health
+    expressApp?.use(/^\/mcp(?!\/health).*/, ...authMiddleware);
+}

package/lib/config/json-parser.js

@@ -12,6 +12,7 @@ const logger_1 = require("../logger");
 const CAPConfigurationSchema = zod_1.z.object({
     name: zod_1.z.string(),
     version: zod_1.z.string(),
+    auth: zod_1.z.custom(),
     capabilities: zod_1.z.object({
         tools: zod_1.z.object({
             listChanged: zod_1.z.boolean().optional(),

package/lib/config/loader.js

@@ -22,6 +22,7 @@ function loadConfiguration() {
     return {
         name: cdsEnv?.name ?? packageInfo.name,
         version: cdsEnv?.version ?? packageInfo.version,
+        auth: cdsEnv?.auth ?? "inherit",
         capabilities: {
             tools: cdsEnv?.capabilities?.tools ?? { listChanged: true },
             resources: cdsEnv?.capabilities?.resources ?? { listChanged: true },

package/lib/mcp/factory.js

@@ -7,6 +7,7 @@ const structures_1 = require("../annotations/structures");
 const tools_1 = require("./tools");
 const resources_1 = require("./resources");
 const prompts_1 = require("./prompts");
+const utils_1 = require("../auth/utils");
 /**
  * Creates and configures an MCP server instance with the given configuration and annotations
  * @param config - CAP configuration object
@@ -25,14 +26,14 @@ function createMcpServer(config, annotations) {
         return server;
     }
     logger_1.LOGGER.debug("Annotations found for server: ", annotations);
-    // TODO: Handle auth
+    const authEnabled = (0, utils_1.isAuthEnabled)(config.auth);
     for (const entry of annotations.values()) {
         if (entry instanceof structures_1.McpToolAnnotation) {
-            (0, tools_1.assignToolToServer)(entry, server);
+            (0, tools_1.assignToolToServer)(entry, server, authEnabled);
             continue;
         }
         else if (entry instanceof structures_1.McpResourceAnnotation) {
-            (0, resources_1.assignResourceToServer)(entry, server);
+            (0, resources_1.assignResourceToServer)(entry, server, authEnabled);
             continue;
         }
         else if (entry instanceof structures_1.McpPromptAnnotation) {

package/lib/mcp/resources.js

@@ -5,6 +5,7 @@ const custom_resource_template_1 = require("./custom-resource-template");
 const logger_1 = require("../logger");
 const utils_1 = require("./utils");
 const validation_1 = require("./validation");
+const utils_2 = require("../auth/utils");
 // import cds from "@sap/cds";
 /* @ts-ignore */
 const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
@@ -14,10 +15,10 @@ const cds = global.cds || require("@sap/cds"); // This is a work around for miss
  * @param model - The resource annotation containing entity metadata and query options
  * @param server - The MCP server instance to register the resource with
  */
-function assignResourceToServer(model, server) {
+function assignResourceToServer(model, server, authEnabled) {
     logger_1.LOGGER.debug("Adding resource", model);
     if (model.functionalities.size <= 0) {
-        registerStaticResource(model, server);
+        registerStaticResource(model, server, authEnabled);
         return;
     }
     // Dynamic resource registration
@@ -83,7 +84,8 @@ function assignResourceToServer(model, server) {
             };
         }
         try {
-            const response = await service.run(query);
+            const accessRights = (0, utils_2.getAccessRights)(authEnabled);
+            const response = await service.tx({ user: accessRights }).run(query);
             return {
                 contents: [
                     {
@@ -112,7 +114,7 @@ function assignResourceToServer(model, server) {
  * @param model - The resource annotation with entity metadata
  * @param server - The MCP server instance to register with
  */
-function registerStaticResource(model, server) {
+function registerStaticResource(model, server, authEnabled) {
     server.registerResource(model.name, `odata://${model.serviceName}/${model.name}`, { title: model.target, description: model.description }, async (uri, extra) => {
         const queryParameters = extra;
         const service = cds.services[model.serviceName];
@@ -122,7 +124,8 @@ function registerStaticResource(model, server) {
             const query = SELECT.from(model.target).limit(queryParameters.top
                 ? validator.validateTop(queryParameters.top)
                 : 100);
-            const response = await service.run(query);
+            const accessRights = (0, utils_2.getAccessRights)(authEnabled);
+            const response = await service.tx({ user: accessRights }).run(query);
             return {
                 contents: [
                     {

package/lib/mcp/tools.js

@@ -5,6 +5,7 @@ const utils_1 = require("./utils");
 const logger_1 = require("../logger");
 const constants_1 = require("./constants");
 const zod_1 = require("zod");
+const utils_2 = require("../auth/utils");
 /* @ts-ignore */
 const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
 /**
@@ -13,15 +14,15 @@ const cds = global.cds || require("@sap/cds"); // This is a work around for miss
  * @param model - The tool annotation containing operation metadata and parameters
  * @param server - The MCP server instance to register the tool with
  */
-function assignToolToServer(model, server) {
+function assignToolToServer(model, server, authEnabled) {
     logger_1.LOGGER.debug("Adding tool", model);
     const parameters = buildToolParameters(model.parameters);
     if (model.entityKey) {
         // Assign tool as bound operation
-        assignBoundOperation(parameters, model, server);
+        assignBoundOperation(parameters, model, server, authEnabled);
         return;
     }
-    assignUnboundOperation(parameters, model, server);
+    assignUnboundOperation(parameters, model, server, authEnabled);
 }
 /**
  * Registers a bound operation that operates on a specific entity instance
@@ -30,7 +31,7 @@ function assignToolToServer(model, server) {
  * @param model - Tool annotation with bound operation metadata
  * @param server - MCP server instance to register with
  */
-function assignBoundOperation(params, model, server) {
+function assignBoundOperation(params, model, server, authEnabled) {
     if (!model.keyTypeMap || model.keyTypeMap.size <= 0) {
         logger_1.LOGGER.error("Invalid tool assignment - missing key map for bound operation");
         throw new Error("Bound operation cannot be assigned to tool list, missing keys");
@@ -65,7 +66,8 @@ function assignBoundOperation(params, model, server) {
                 continue;
             operationInput[k] = v;
         }
-        const response = await service.send({
+        const accessRights = (0, utils_2.getAccessRights)(authEnabled);
+        const response = await service.tx({ user: accessRights }).send({
             event: model.target,
             entity: model.entityKey,
             data: operationInput,
@@ -73,8 +75,11 @@ function assignBoundOperation(params, model, server) {
         });
         return {
             content: Array.isArray(response)
-                ? response.map((el) => ({ type: "text", text: String(el) }))
-                : [{ type: "text", text: String(response) }],
+                ? response.map((el) => ({
+                    type: "text",
+                    text: formatResponseValue(el),
+                }))
+                : [{ type: "text", text: formatResponseValue(response) }],
         };
     });
 }
@@ -85,7 +90,7 @@ function assignBoundOperation(params, model, server) {
  * @param model - Tool annotation with unbound operation metadata
  * @param server - MCP server instance to register with
  */
-function assignUnboundOperation(params, model, server) {
+function assignUnboundOperation(params, model, server, authEnabled) {
     const inputSchema = buildZodSchema(params);
     server.registerTool(model.name, {
         title: model.name,
@@ -105,11 +110,17 @@ function assignUnboundOperation(params, model, server) {
                 ],
             };
         }
-        const response = await service.send(model.target, args);
+        const accessRights = (0, utils_2.getAccessRights)(authEnabled);
+        const response = await service
+            .tx({ user: accessRights })
+            .send(model.target, args);
         return {
             content: Array.isArray(response)
-                ? response.map((el) => ({ type: "text", text: String(el) }))
-                : [{ type: "text", text: String(response) }],
+                ? response.map((el) => ({
+                    type: "text",
+                    text: formatResponseValue(el),
+                }))
+                : [{ type: "text", text: formatResponseValue(response) }],
         };
     });
 }
@@ -127,6 +138,27 @@ function buildToolParameters(params) {
     }
     return result;
 }
+/**
+ * Converts a value to a string representation suitable for MCP responses
+ * Handles objects and arrays by JSON stringifying them instead of using String()
+ * @param value - The value to convert to string
+ * @returns String representation of the value
+ */
+function formatResponseValue(value) {
+    if (value === null || value === undefined) {
+        return String(value);
+    }
+    if (typeof value === "object") {
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch (error) {
+            // Fallback to String() if JSON.stringify fails (e.g., circular references)
+            return String(value);
+        }
+    }
+    return String(value);
+}
 /**
  * Constructs a complete Zod schema object for MCP tool input validation
  * @param params - Record of parameter names to Zod schema types

package/lib/mcp.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const cds_1 = __importDefault(require("@sap/cds"));
 const logger_1 = require("./logger");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const express_1 = __importDefault(require("express"));
@@ -11,6 +12,9 @@ const utils_1 = require("./mcp/utils");
 const constants_1 = require("./mcp/constants");
 const loader_1 = require("./config/loader");
 const session_manager_1 = require("./mcp/session-manager");
+const utils_2 = require("./auth/utils");
+/* @ts-ignore */
+// const cds = global.cds || require("@sap/cds"); // This is a work around for missing cds context
 // TODO: Handle auth
 /**
  * Main MCP plugin class that integrates CAP services with Model Context Protocol
@@ -38,6 +42,9 @@ class McpPlugin {
         logger_1.LOGGER.debug("Event received for 'bootstrap'");
         this.expressApp = app;
         this.expressApp.use(express_1.default.json());
+        if (this.config.auth === "inherit") {
+            (0, utils_2.registerAuthMiddleware)(this.expressApp);
+        }
         await this.registerApiEndpoints();
         logger_1.LOGGER.debug("Bootstrap complete");
     }
@@ -76,7 +83,6 @@ class McpPlugin {
                 status: "UP",
             });
         });
-        logger_1.LOGGER.debug("TESTING - Annotations", this.annotations);
         this.registerMcpSessionRoute();
         this.expressApp?.get("/mcp", (req, res) => (0, utils_1.handleMcpSessionRequest)(req, res, this.sessionManager.getSessions()));
         this.expressApp?.delete("/mcp", (req, res) => (0, utils_1.handleMcpSessionRequest)(req, res, this.sessionManager.getSessions()));
@@ -88,6 +94,7 @@ class McpPlugin {
     registerMcpSessionRoute() {
         logger_1.LOGGER.debug("Registering MCP entry point");
         this.expressApp?.post("/mcp", async (req, res) => {
+            logger_1.LOGGER.debug("CONTEXT", cds_1.default.context); // TODO: Remove this line after testing
             const sessionIdHeader = req.headers[constants_1.MCP_SESSION_HEADER];
             logger_1.LOGGER.debug("MCP request received", {
                 hasSessionId: !!sessionIdHeader,

package/package.json

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