@mcp-abap-adt/proxy 0.1.5 → 0.1.8

package/dist/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 /**
  * MCP ABAP ADT Proxy Server
@@ -6,24 +5,31 @@
  * Proxies local MCP requests to MCP servers with optional JWT authentication.
  * Routes requests based on authentication headers:
  * - x-btp-destination (or --btp): BTP Cloud authorization with JWT token
- * - x-mcp-destination (or --mcp): SAP ABAP connection configuration
  *
- * Supports two modes:
- * 1. BTP authentication mode: Requires x-btp-destination or --btp parameter
- * 2. Local testing mode: Works with only x-mcp-destination or --mcp parameter (no BTP authentication)
+ * Supports BTP authentication mode: Requires x-btp-destination or --btp parameter
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpAbapAdtProxyServer = void 0;
+const node_http_1 = require("node:http");
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
-const http_1 = require("http");
-const transportConfig_js_1 = require("./lib/transportConfig.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const config_js_1 = require("./lib/config.js");
 const logger_js_1 = require("./lib/logger.js");
-const requestInterceptor_js_1 = require("./router/requestInterceptor.js");
+const transportConfig_js_1 = require("./lib/transportConfig.js");
+const btpProxy_js_1 = require("./proxy/btpProxy.js");
 const headerAnalyzer_js_1 = require("./router/headerAnalyzer.js");
-const cloudLlmHubProxy_js_1 = require("./proxy/cloudLlmHubProxy.js");
+const requestInterceptor_js_1 = require("./router/requestInterceptor.js");
+/**
+ * Safely extract id from unknown body object
+ */
+function getBodyId(body) {
+    if (body && typeof body === 'object' && body !== null && 'id' in body) {
+        return body.id;
+    }
+    return null;
+}
 /**
  * MCP ABAP ADT Proxy Server
  */
@@ -32,30 +38,31 @@ class McpAbapAdtProxyServer {
     transportConfig;
     config;
     httpServer;
-    cloudLlmHubProxy;
+    btpProxy;
     constructor(transportConfig, configPath) {
         this.transportConfig = transportConfig || (0, transportConfig_js_1.parseTransportConfig)();
         this.config = (0, config_js_1.loadConfig)(configPath);
         // Validate configuration
-        if (this.transportConfig.type === "streamable-http" || this.transportConfig.type === "sse") {
+        if (this.transportConfig.type === 'streamable-http' ||
+            this.transportConfig.type === 'sse') {
             const validation = (0, config_js_1.validateConfig)(this.config);
             if (!validation.valid) {
-                logger_js_1.logger.error("Configuration validation failed", {
-                    type: "CONFIG_VALIDATION_ERROR",
+                logger_js_1.logger?.error('Configuration validation failed', {
+                    type: 'CONFIG_VALIDATION_ERROR',
                     errors: validation.errors,
                 });
-                throw new Error(`Configuration validation failed: ${validation.errors.join(", ")}`);
+                throw new Error(`Configuration validation failed: ${validation.errors.join(', ')}`);
             }
             if (validation.warnings.length > 0) {
-                logger_js_1.logger.warn("Configuration validation warnings", {
-                    type: "CONFIG_VALIDATION_WARNINGS",
+                logger_js_1.logger?.warn('Configuration validation warnings', {
+                    type: 'CONFIG_VALIDATION_WARNINGS',
                     warnings: validation.warnings,
                 });
             }
         }
         this.server = new mcp_js_1.McpServer({
-            name: "@mcp-abap-adt/proxy",
-            version: "0.1.0",
+            name: '@mcp-abap-adt/proxy',
+            version: '0.1.0',
         }, {
             capabilities: {
                 tools: {},
@@ -71,92 +78,21 @@ class McpAbapAdtProxyServer {
         // The server automatically handles initialize and tools/list requests
         // For stdio, we'll intercept requests through server.server message handler
     }
-    /**
-     * Handle stdio request by proxying to MCP server
-     * Supports both BTP authentication mode (--btp) and local testing mode (--mcp without --btp)
-     */
-    async handleStdioRequest(method, params, id) {
-        // Create fake headers with config overrides (--btp, --mcp, and/or --mcp-url)
-        const fakeHeaders = {};
-        if (this.config.btpDestination) {
-            fakeHeaders["x-btp-destination"] = this.config.btpDestination;
-        }
-        if (this.config.mcpDestination) {
-            fakeHeaders["x-mcp-destination"] = this.config.mcpDestination;
-        }
-        if (this.config.mcpUrl) {
-            fakeHeaders["x-mcp-url"] = this.config.mcpUrl;
-        }
-        // Create routing decision using config overrides
-        const configOverrides = {
-            btpDestination: this.config.btpDestination,
-            mcpDestination: this.config.mcpDestination,
-            mcpUrl: this.config.mcpUrl,
-        };
-        const { analyzeHeaders } = await import("./router/headerAnalyzer.js");
-        const routingDecision = analyzeHeaders(fakeHeaders, configOverrides);
-        // Check if routing is valid
-        if (routingDecision.strategy !== headerAnalyzer_js_1.RoutingStrategy.PROXY) {
-            logger_js_1.logger.error("Routing decision failed for stdio request", {
-                type: "STDIO_ROUTING_DECISION_FAILED",
-                reason: routingDecision.reason,
-            });
-            return {
-                jsonrpc: "2.0",
-                id: id || null,
-                error: {
-                    code: -32602,
-                    message: routingDecision.reason || "Routing decision failed",
-                },
-            };
-        }
-        // Ensure proxy is initialized
-        if (!this.cloudLlmHubProxy) {
-            const baseUrl = this.config.cloudLlmHubUrl || "https://default.example.com";
-            this.cloudLlmHubProxy = await (0, cloudLlmHubProxy_js_1.createCloudLlmHubProxy)(baseUrl, this.config);
-        }
-        // Build MCP request
-        const mcpRequest = {
-            method: method || "",
-            params: params || {},
-            id: id || null,
-            jsonrpc: "2.0",
-        };
-        // Proxy request to cloud-llm-hub
-        try {
-            const proxyResponse = await this.cloudLlmHubProxy.proxyRequest(mcpRequest, routingDecision, fakeHeaders);
-            return proxyResponse;
-        }
-        catch (error) {
-            logger_js_1.logger.error("Failed to proxy stdio request", {
-                type: "STDIO_PROXY_ERROR",
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                jsonrpc: "2.0",
-                id: id || null,
-                error: {
-                    code: -32000,
-                    message: error instanceof Error ? error.message : "Unknown error",
-                },
-            };
-        }
-    }
     /**
      * Run the proxy server
      */
     async run() {
-        if (this.transportConfig.type === "stdio") {
-            // Check if either --btp, --mcp, or --mcp-url parameter is provided (required for stdio)
-            if (!this.config.btpDestination && !this.config.mcpDestination && !this.config.mcpUrl) {
-                logger_js_1.logger.error("Either --btp, --mcp, or --mcp-url parameter is required for stdio transport", {
-                    type: "STDIO_DESTINATION_REQUIRED",
+        if (this.transportConfig.type === 'stdio') {
+            // Check if --btp parameter is provided (required for stdio)
+            if (!this.config.btpDestination) {
+                logger_js_1.logger?.error('--btp parameter is required for stdio transport', {
+                    type: 'STDIO_DESTINATION_REQUIRED',
                 });
-                throw new Error("Either --btp, --mcp, or --mcp-url parameter is required for stdio transport. Use --btp=<destination> for BTP destination, --mcp=<destination> for MCP destination, or --mcp-url=<url> for direct MCP server URL (local testing).");
+                throw new Error('--btp parameter is required for stdio transport. Use --btp=<destination> for BTP destination.');
             }
             // For stdio, we need to register a proxy tool that forwards all requests
             // Since we can't intercept all requests directly, we'll register a tool
-            // that the client can call, which will proxy to cloud-llm-hub
+            // that the client can call, which will proxy to BtpProxy
             // Note: This requires the client to know about the proxy tool
             // Alternatively, we could use a custom transport wrapper
             // Simple stdio setup - MCP SDK will handle JSON-RPC protocol
@@ -166,23 +102,38 @@ class McpAbapAdtProxyServer {
             // For now, we'll just connect and let the SDK handle it
             // The actual proxying will need to be done through registered tools
             const transport = new stdio_js_1.StdioServerTransport();
-            await this.server.server.connect(transport);
-            logger_js_1.logger.info("MCP Proxy Server started (stdio transport)", {
-                type: "SERVER_STARTED",
-                transport: "stdio",
+            const msg = `MCP Proxy Server started (Transport: stdio)
+Authorization source: BTP destination "${this.config.btpDestination}"`;
+            console.error(msg);
+            logger_js_1.logger?.info('MCP Proxy Server started (stdio transport)', {
+                type: 'SERVER_STARTED',
+                transport: 'stdio',
                 btpDestination: this.config.btpDestination,
-                mcpDestination: this.config.mcpDestination,
-                mcpUrl: this.config.mcpUrl,
-                note: "For stdio transport, --btp, --mcp, and/or --mcp-url parameters are used as default destinations",
-                mode: this.config.btpDestination ? "BTP authentication" : "Local testing (no BTP authentication)",
+                note: 'For stdio transport, --btp parameter is used as default destination',
+                mode: 'BTP authentication',
             });
             return;
         }
-        if (this.transportConfig.type === "streamable-http") {
+        // Eager initialization of BTP authentication
+        if (this.config.btpDestination) {
+            try {
+                if (!this.btpProxy) {
+                    this.btpProxy = await (0, btpProxy_js_1.createBtpProxy)(this.config);
+                }
+                // Trigger initialization (background) - this will open the browser
+                this.btpProxy.initialize(this.config.btpDestination);
+            }
+            catch (error) {
+                logger_js_1.logger?.error('Failed to initialize BTP proxy for eager auth', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        if (this.transportConfig.type === 'streamable-http') {
             await this.startHttpServer();
             return;
         }
-        if (this.transportConfig.type === "sse") {
+        if (this.transportConfig.type === 'sse') {
             await this.startSseServer();
             return;
         }
@@ -193,25 +144,23 @@ class McpAbapAdtProxyServer {
      */
     async startHttpServer() {
         const httpConfig = this.transportConfig;
-        this.httpServer = (0, http_1.createServer)(async (req, res) => {
-            // Log incoming HTTP request (if debug enabled)
-            const debugHttpEnabled = process.env.DEBUG_HTTP_REQUESTS === "true";
-            if (debugHttpEnabled) {
-                const sanitizedHeaders = (0, requestInterceptor_js_1.sanitizeHeadersForLogging)(req.headers);
-                logger_js_1.logger.info("HTTP Request received", {
-                    type: "HTTP_REQUEST",
-                    method: req.method,
-                    url: req.url,
-                    headers: sanitizedHeaders,
-                    remoteAddress: req.socket.remoteAddress,
-                });
-            }
-            // Only handle POST requests
-            if (req.method !== "POST") {
-                res.writeHead(405, { "Content-Type": "text/plain" });
-                res.end("Method not allowed");
-                return;
-            }
+        this.httpServer = (0, node_http_1.createServer)(async (req, res) => {
+            // Log incoming HTTP request (always log in DEBUG mode)
+            const _debugEnabled = process.env.DEBUG === 'true' ||
+                process.env.DEBUG_HTTP_REQUESTS === 'true';
+            const sanitizedHeaders = (0, requestInterceptor_js_1.sanitizeHeadersForLogging)(req.headers);
+            logger_js_1.logger?.info('=== HTTP REQUEST RECEIVED ===', {
+                type: 'HTTP_REQUEST_RECEIVED',
+                method: req.method,
+                url: req.url,
+                headers: sanitizedHeaders,
+                remoteAddress: req.socket.remoteAddress,
+            });
+            // Allow all HTTP methods (GET, POST, PUT, DELETE, etc.)
+            // if (req.method !== 'POST') {
+            //   logger?.warn('Non-POST request rejected', { ... });
+            //   ...
+            // }
             // Read request body
             let body;
             try {
@@ -219,36 +168,93 @@ class McpAbapAdtProxyServer {
                 for await (const chunk of req) {
                     chunks.push(chunk);
                 }
-                const bodyString = Buffer.concat(chunks).toString("utf-8");
-                body = JSON.parse(bodyString);
+                const bodyString = Buffer.concat(chunks).toString('utf-8');
+                logger_js_1.logger?.info('=== PARSING REQUEST BODY ===', {
+                    type: 'REQUEST_BODY_PARSING',
+                    bodyLength: bodyString.length,
+                    bodyPreview: bodyString.substring(0, 200),
+                });
+                if (bodyString.trim().length > 0) {
+                    body = JSON.parse(bodyString);
+                }
+                else {
+                    body = undefined;
+                }
+                // Sanitize body for logging
+                const sanitizedBody = {};
+                if (body && typeof body === 'object' && body !== null) {
+                    const bodyObj = body;
+                    sanitizedBody.method = bodyObj.method;
+                    sanitizedBody.id = bodyObj.id;
+                    sanitizedBody.jsonrpc = bodyObj.jsonrpc;
+                    if (bodyObj.params &&
+                        typeof bodyObj.params === 'object' &&
+                        bodyObj.params !== null) {
+                        const params = bodyObj.params;
+                        sanitizedBody.params = {};
+                        const sanitizedParams = sanitizedBody.params;
+                        if (params.arguments &&
+                            typeof params.arguments === 'object' &&
+                            params.arguments !== null) {
+                            sanitizedParams.arguments = {};
+                            const sanitizedArgs = sanitizedParams.arguments;
+                            for (const [key, value] of Object.entries(params.arguments)) {
+                                const lowerKey = key.toLowerCase();
+                                if (lowerKey.includes('password') ||
+                                    lowerKey.includes('token') ||
+                                    lowerKey.includes('secret')) {
+                                    sanitizedArgs[key] = '[REDACTED]';
+                                }
+                                else {
+                                    sanitizedArgs[key] = value;
+                                }
+                            }
+                        }
+                        for (const [key, value] of Object.entries(params)) {
+                            if (key === 'arguments')
+                                continue;
+                            sanitizedParams[key] = value;
+                        }
+                    }
+                }
+                logger_js_1.logger?.info('=== REQUEST BODY PARSED ===', {
+                    type: 'REQUEST_BODY_PARSED',
+                    body: sanitizedBody,
+                });
             }
             catch (error) {
-                logger_js_1.logger.error("Failed to parse request body", {
-                    type: "REQUEST_PARSE_ERROR",
+                logger_js_1.logger?.error('=== FAILED TO PARSE REQUEST BODY ===', {
+                    type: 'REQUEST_PARSE_ERROR',
                     error: error instanceof Error ? error.message : String(error),
+                    errorStack: error instanceof Error ? error.stack : undefined,
                 });
-                res.writeHead(400, { "Content-Type": "text/plain" });
-                res.end("Invalid request body");
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Invalid request body');
                 return;
             }
             // Intercept and analyze request
-            // Pass config overrides (--btp, --mcp, and --mcp-url) to header analyzer
             const configOverrides = {
                 btpDestination: this.config.btpDestination,
-                mcpDestination: this.config.mcpDestination,
-                mcpUrl: this.config.mcpUrl,
+                targetUrl: this.config.targetUrl,
             };
+            logger_js_1.logger?.info('=== INTERCEPTING REQUEST ===', {
+                type: 'REQUEST_INTERCEPTING',
+                configOverrides,
+            });
             const intercepted = (0, requestInterceptor_js_1.interceptRequest)(req, body, configOverrides);
             // Check routing decision
             if (intercepted.routingDecision.strategy === headerAnalyzer_js_1.RoutingStrategy.UNKNOWN) {
-                logger_js_1.logger.error("Routing decision failed", {
-                    type: "ROUTING_DECISION_FAILED",
+                logger_js_1.logger?.error('Routing decision failed', {
+                    type: 'ROUTING_DECISION_FAILED',
                     reason: intercepted.routingDecision.reason,
                 });
-                res.writeHead(400, { "Content-Type": "application/json" });
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                const bodyId = body && typeof body === 'object' && body !== null && 'id' in body
+                    ? body.id
+                    : null;
                 res.end(JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: body?.id || null,
+                    jsonrpc: '2.0',
+                    id: bodyId || null,
                     error: {
                         code: -32602,
                         message: intercepted.routingDecision.reason,
@@ -257,43 +263,47 @@ class McpAbapAdtProxyServer {
                 return;
             }
             // Log proxy request
-            logger_js_1.logger.debug("Proxying request", {
-                type: "PROXY_REQUEST",
+            logger_js_1.logger?.info('=== PROXYING REQUEST ===', {
+                type: 'PROXY_REQUEST_START',
                 btpDestination: intercepted.routingDecision.btpDestination,
-                mcpDestination: intercepted.routingDecision.mcpDestination,
-                requiresSapConfig: (0, requestInterceptor_js_1.requiresSapConfig)(body),
             });
             // Handle proxy request - add JWT and forward to x-mcp-url
             try {
                 await this.handleProxyRequest(intercepted, req, res);
             }
             catch (error) {
-                logger_js_1.logger.error("Failed to process request", {
-                    type: "REQUEST_PROCESS_ERROR",
+                logger_js_1.logger?.error('Failed to process request', {
+                    type: 'REQUEST_PROCESS_ERROR',
                     error: error instanceof Error ? error.message : String(error),
                     strategy: intercepted.routingDecision.strategy,
                 });
                 if (!res.headersSent) {
-                    res.writeHead(500, { "Content-Type": "text/plain" });
-                    res.end("Internal server error");
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('Internal server error');
                 }
             }
         });
         const port = httpConfig.port || 3001;
-        const host = httpConfig.host || "0.0.0.0";
+        const host = httpConfig.host || '0.0.0.0';
         return new Promise((resolve, reject) => {
-            this.httpServer.listen(port, host, () => {
-                logger_js_1.logger.info("MCP Proxy Server started (HTTP transport)", {
-                    type: "SERVER_STARTED",
-                    transport: "streamable-http",
+            this.httpServer?.listen(port, host, () => {
+                const authSourceObj = this.config.btpDestination
+                    ? `BTP destination "${this.config.btpDestination}"`
+                    : 'Waiting for "x-btp-destination" header in requests';
+                const msg = `MCP Proxy Server started on port ${port} (Transport: http)
+Authorization source: ${authSourceObj}`;
+                console.log(msg);
+                logger_js_1.logger?.info('MCP Proxy Server started (HTTP transport)', {
+                    type: 'SERVER_STARTED',
+                    transport: 'streamable-http',
                     host,
                     port,
                 });
                 resolve();
             });
-            this.httpServer.on("error", (error) => {
-                logger_js_1.logger.error("Failed to start HTTP server", {
-                    type: "SERVER_START_ERROR",
+            this.httpServer?.on('error', (error) => {
+                logger_js_1.logger?.error('Failed to start HTTP server', {
+                    type: 'SERVER_START_ERROR',
                     error: error.message,
                 });
                 reject(error);
@@ -305,57 +315,184 @@ class McpAbapAdtProxyServer {
      */
     async handleProxyRequest(intercepted, req, res) {
         const btpDestination = intercepted.routingDecision.btpDestination;
-        const mcpDestination = intercepted.routingDecision.mcpDestination;
-        const mcpUrl = intercepted.routingDecision.mcpUrl;
-        logger_js_1.logger.info("Handling proxy request", {
-            type: "PROXY_REQUEST",
+        // Log incoming request details
+        const incomingHeaders = {};
+        for (const [key, value] of Object.entries(intercepted.headers)) {
+            const lowerKey = key.toLowerCase();
+            if (lowerKey.includes('token') ||
+                lowerKey.includes('authorization') ||
+                lowerKey.includes('password') ||
+                lowerKey.includes('secret')) {
+                incomingHeaders[key] = '[REDACTED]';
+            }
+            else {
+                incomingHeaders[key] = Array.isArray(value)
+                    ? value.join(', ')
+                    : value || '';
+            }
+        }
+        const sanitizedBody = {};
+        if (intercepted.body &&
+            typeof intercepted.body === 'object' &&
+            intercepted.body !== null) {
+            const bodyObj = intercepted.body;
+            if (bodyObj.params &&
+                typeof bodyObj.params === 'object' &&
+                bodyObj.params !== null) {
+                const params = bodyObj.params;
+                sanitizedBody.params = {};
+                const sanitizedParams = sanitizedBody.params;
+                // For tools/call, log arguments
+                if (params.arguments &&
+                    typeof params.arguments === 'object' &&
+                    params.arguments !== null) {
+                    sanitizedParams.arguments = {};
+                    const sanitizedArgs = sanitizedParams.arguments;
+                    for (const [key, value] of Object.entries(params.arguments)) {
+                        const lowerKey = key.toLowerCase();
+                        if (lowerKey.includes('password') ||
+                            lowerKey.includes('token') ||
+                            lowerKey.includes('secret')) {
+                            sanitizedArgs[key] = '[REDACTED]';
+                        }
+                        else {
+                            sanitizedArgs[key] = value;
+                        }
+                    }
+                }
+                // Log other params
+                for (const [key, value] of Object.entries(params)) {
+                    if (key === 'arguments')
+                        continue;
+                    sanitizedParams[key] = value;
+                }
+            }
+            sanitizedBody.method = bodyObj.method;
+            sanitizedBody.id = bodyObj.id;
+            sanitizedBody.jsonrpc = bodyObj.jsonrpc;
+        }
+        // Use original request body structure for proxying (generic support)
+        // We do NOT enforce JSON-RPC structure here anymore, to support REST/OData
+        const proxyRequestData = intercepted.body;
+        logger_js_1.logger?.info('=== INCOMING REQUEST ===', {
+            type: 'PROXY_REQUEST_INCOMING',
+            method: req.method,
+            url: req.url,
             btpDestination,
-            mcpDestination,
-            mcpUrl,
             sessionId: intercepted.sessionId,
-            mode: btpDestination ? "BTP authentication" : "Local testing (no BTP authentication)",
+            headers: incomingHeaders,
+            body: sanitizedBody,
+            mode: 'BTP authentication',
         });
         try {
             // Ensure proxy is initialized (URL will be obtained from service key for btpDestination or mcpDestination)
-            if (!this.cloudLlmHubProxy) {
-                // Use default base URL from config as fallback (actual URL comes from service key)
-                const baseUrl = this.config.cloudLlmHubUrl || "https://default.example.com";
-                this.cloudLlmHubProxy = await (0, cloudLlmHubProxy_js_1.createCloudLlmHubProxy)(baseUrl, this.config);
+            if (!this.btpProxy) {
+                this.btpProxy = await (0, btpProxy_js_1.createBtpProxy)(this.config);
             }
             // Build MCP request from intercepted request
-            const mcpRequest = {
-                method: intercepted.body?.method || "",
-                params: intercepted.body?.params || {},
-                id: intercepted.body?.id || null,
-                jsonrpc: intercepted.body?.jsonrpc || "2.0",
+            // Note: Use ?? instead of || to preserve falsy values like 0
+            const interceptedBodyId = getBodyId(intercepted.body);
+            const interceptedBodyIdType = typeof interceptedBodyId;
+            const interceptedBodyIdUndefined = interceptedBodyId === undefined;
+            logger_js_1.logger?.info('=== BEFORE BUILDING MCP REQUEST ===', {
+                type: 'BEFORE_BUILD_MCP_REQUEST',
+                interceptedBodyId,
+                interceptedBodyIdType,
+                interceptedBodyIdUndefined,
+                interceptedBodyIdNull: interceptedBodyId === null,
+                interceptedBodyIdZero: interceptedBodyId === 0,
+                interceptedBodyIdFalsy: !interceptedBodyId,
+                fullInterceptedBody: JSON.stringify(intercepted.body),
+            });
+            // Preserve id correctly - 0 is a valid id value
+            let mcpRequestId;
+            if (interceptedBodyId === undefined) {
+                mcpRequestId = null;
+            }
+            else if (typeof interceptedBodyId === 'string' ||
+                typeof interceptedBodyId === 'number') {
+                mcpRequestId = interceptedBodyId;
+            }
+            else {
+                mcpRequestId = null;
+            }
+            // Proxy request to BtpProxy
+            // Pass the original request data directly
+            const proxyRequest = {
+                method: intercepted.method, // Use original HTTP method (GET, POST, etc.)
+                url: intercepted.url, // Pass request URL (path)
+                data: proxyRequestData, // Use original body (or undefined)
+                id: mcpRequestId, // Keep ID for logging context if available
+            };
+            const proxyResponse = await this.btpProxy.proxyRequest(proxyRequest, intercepted.routingDecision, intercepted.headers);
+            // Fix: If backend returned null ID but we entered with a valid ID (e.g. 0), restore it.
+            // Cline/Zod schemas reject null ID for successful responses if request had an ID.
+            if ((proxyResponse.id === null || proxyResponse.id === undefined) &&
+                mcpRequestId !== null &&
+                mcpRequestId !== undefined) {
+                logger_js_1.logger?.debug('Restoring original request ID in response', {
+                    originalId: mcpRequestId,
+                    receivedId: proxyResponse.id,
+                });
+                proxyResponse.id = mcpRequestId;
+            }
+            logger_js_1.logger?.info('=== FORWARDING REQUEST ===', {
+                type: 'PROXY_REQUEST_FORWARDING',
+                interceptedBodyIdAtForward: getBodyId(intercepted.body),
+                proxyRequest,
+                routingDecision: intercepted.routingDecision,
+                headers: intercepted.headers,
+            });
+            // Log response
+            const sanitizedResponse = {
+                jsonrpc: proxyResponse.jsonrpc,
+                id: proxyResponse.id,
             };
-            // Proxy request to cloud-llm-hub
-            const proxyResponse = await this.cloudLlmHubProxy.proxyRequest(mcpRequest, intercepted.routingDecision, intercepted.headers);
+            if (proxyResponse.result) {
+                sanitizedResponse.result = proxyResponse.result;
+            }
+            if (proxyResponse.error) {
+                sanitizedResponse.error = {
+                    code: proxyResponse.error.code,
+                    message: proxyResponse.error.message,
+                    data: proxyResponse.error.data,
+                };
+            }
+            logger_js_1.logger?.info('=== RESPONSE FROM TARGET SERVICE ===', {
+                type: 'PROXY_RESPONSE_RECEIVED',
+                response: sanitizedResponse,
+                hasResult: !!proxyResponse.result,
+                hasError: !!proxyResponse.error,
+            });
             // Send response back to client
-            res.writeHead(200, { "Content-Type": "application/json" });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify(proxyResponse));
-            logger_js_1.logger.debug("Cloud-llm-hub proxy request completed", {
-                type: "CLOUD_LLM_HUB_PROXY_COMPLETED",
+            logger_js_1.logger?.info('=== RESPONSE SENT TO CLIENT ===', {
+                type: 'PROXY_RESPONSE_SENT',
+                statusCode: 200,
+            });
+            logger_js_1.logger?.debug('BtpProxy request completed', {
+                type: 'BTP_PROXY_COMPLETED',
                 hasResult: !!proxyResponse.result,
                 hasError: !!proxyResponse.error,
             });
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            logger_js_1.logger.error("Failed to handle cloud-llm-hub proxy request", {
-                type: "CLOUD_LLM_HUB_PROXY_ERROR",
+            logger_js_1.logger?.error('Failed to handle BtpProxy request', {
+                type: 'BTP_PROXY_ERROR',
                 error: errorMessage,
                 stack: error instanceof Error ? error.stack : undefined,
             });
             // Output error to stderr for user visibility (only if verbose mode is enabled)
-            if ((0, cloudLlmHubProxy_js_1.shouldWriteStderr)()) {
+            if ((0, btpProxy_js_1.shouldWriteStderr)()) {
                 process.stderr.write(`[MCP Proxy] ✗ Connection error: ${errorMessage}\n`);
             }
             if (!res.headersSent) {
-                res.writeHead(500, { "Content-Type": "application/json" });
+                res.writeHead(500, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: intercepted.body?.id || null,
+                    jsonrpc: '2.0',
+                    id: getBodyId(intercepted.body) || null,
                     error: {
                         code: -32000,
                         message: errorMessage,
@@ -370,36 +507,38 @@ class McpAbapAdtProxyServer {
     async startSseServer() {
         const sseConfig = this.transportConfig;
         const streamPathMap = new Map([
-            ["/", "/messages"],
-            ["/mcp/events", "/mcp/messages"],
-            ["/sse", "/messages"],
+            ['/', '/messages'],
+            ['/mcp/events', '/mcp/messages'],
+            ['/sse', '/messages'],
         ]);
-        const streamPaths = Array.from(streamPathMap.keys());
+        const _streamPaths = Array.from(streamPathMap.keys());
         const postPathSet = new Set(streamPathMap.values());
-        postPathSet.add("/messages");
-        postPathSet.add("/mcp/messages");
-        const httpServer = (0, http_1.createServer)(async (req, res) => {
+        postPathSet.add('/messages');
+        postPathSet.add('/mcp/messages');
+        const httpServer = (0, node_http_1.createServer)(async (req, res) => {
             // SSE: Always restrict to local connections only
             const remoteAddress = req.socket.remoteAddress;
-            const isLocal = remoteAddress === "127.0.0.1" ||
-                remoteAddress === "::1" ||
-                remoteAddress === "localhost" ||
-                (remoteAddress && remoteAddress.startsWith("127."));
+            const isLocal = remoteAddress === '127.0.0.1' ||
+                remoteAddress === '::1' ||
+                remoteAddress === 'localhost' ||
+                remoteAddress?.startsWith('127.');
             if (!isLocal) {
-                logger_js_1.logger.warn("SSE: Non-local connection rejected", {
-                    type: "SSE_NON_LOCAL_REJECTED",
+                logger_js_1.logger?.warn('SSE: Non-local connection rejected', {
+                    type: 'SSE_NON_LOCAL_REJECTED',
                     remoteAddress,
                 });
-                res.writeHead(403, { "Content-Type": "text/plain" });
-                res.end("Forbidden: SSE transport only accepts local connections");
+                res.writeHead(403, { 'Content-Type': 'text/plain' });
+                res.end('Forbidden: SSE transport only accepts local connections');
                 return;
             }
-            const requestUrl = req.url ? new URL(req.url, `http://${req.headers.host ?? `${sseConfig.host}:${sseConfig.port}`}`) : undefined;
-            let pathname = requestUrl?.pathname ?? "/";
-            if (pathname.length > 1 && pathname.endsWith("/")) {
+            const requestUrl = req.url
+                ? new URL(req.url, `http://${req.headers.host ?? `${sseConfig.host}:${sseConfig.port}`}`)
+                : undefined;
+            let pathname = requestUrl?.pathname ?? '/';
+            if (pathname.length > 1 && pathname.endsWith('/')) {
                 pathname = pathname.slice(0, -1);
             }
-            // Apply config overrides (--btp, --mcp, and --mcp-url) to headers if not present
+            // Apply config overrides (--btp) to headers if not present
             const headers = {};
             for (const [key, value] of Object.entries(req.headers)) {
                 if (value) {
@@ -407,33 +546,27 @@ class McpAbapAdtProxyServer {
                 }
             }
             // Add config overrides if not present in headers
-            if (this.config.btpDestination && !headers["x-btp-destination"]) {
-                headers["x-btp-destination"] = this.config.btpDestination;
-            }
-            if (this.config.mcpDestination && !headers["x-mcp-destination"]) {
-                headers["x-mcp-destination"] = this.config.mcpDestination;
-            }
-            if (this.config.mcpUrl && !headers["x-mcp-url"]) {
-                headers["x-mcp-url"] = this.config.mcpUrl;
+            if (this.config.btpDestination && !headers[interfaces_1.HEADER_BTP_DESTINATION]) {
+                headers[interfaces_1.HEADER_BTP_DESTINATION] = this.config.btpDestination;
             }
-            logger_js_1.logger.debug("SSE request received", {
-                type: "SSE_HTTP_REQUEST",
+            logger_js_1.logger?.debug('SSE request received', {
+                type: 'SSE_HTTP_REQUEST',
                 method: req.method,
                 pathname,
                 originalUrl: req.url,
             });
             // GET /sse, /mcp/events, or / - establish SSE connection
-            if (req.method === "GET" && streamPathMap.has(pathname)) {
-                const postEndpoint = streamPathMap.get(pathname) ?? "/messages";
-                logger_js_1.logger.debug("SSE client connecting", {
-                    type: "SSE_CLIENT_CONNECTING",
+            if (req.method === 'GET' && streamPathMap.has(pathname)) {
+                const postEndpoint = streamPathMap.get(pathname) ?? '/messages';
+                logger_js_1.logger?.debug('SSE client connecting', {
+                    type: 'SSE_CLIENT_CONNECTING',
                     pathname,
                     postEndpoint,
                 });
                 // Create new McpServer instance for this session
                 const sessionServer = new mcp_js_1.McpServer({
-                    name: "@mcp-abap-adt/proxy",
-                    version: "0.1.0",
+                    name: '@mcp-abap-adt/proxy',
+                    version: '0.1.0',
                 }, {
                     capabilities: {
                         tools: {},
@@ -446,29 +579,29 @@ class McpAbapAdtProxyServer {
                     enableDnsRebindingProtection: sseConfig.enableDnsRebindingProtection,
                 });
                 const sessionId = transport.sessionId;
-                logger_js_1.logger.info("New SSE session created", {
-                    type: "SSE_SESSION_CREATED",
+                logger_js_1.logger?.info('New SSE session created', {
+                    type: 'SSE_SESSION_CREATED',
                     sessionId,
                     pathname,
                 });
                 // Connect transport to server
                 try {
                     await sessionServer.server.connect(transport);
-                    logger_js_1.logger.info("SSE transport connected", {
-                        type: "SSE_CONNECTION_READY",
+                    logger_js_1.logger?.info('SSE transport connected', {
+                        type: 'SSE_CONNECTION_READY',
                         sessionId,
                         pathname,
                         postEndpoint,
                     });
                 }
                 catch (error) {
-                    logger_js_1.logger.error("Failed to connect SSE transport", {
-                        type: "SSE_CONNECT_ERROR",
+                    logger_js_1.logger?.error('Failed to connect SSE transport', {
+                        type: 'SSE_CONNECT_ERROR',
                         error: error instanceof Error ? error.message : String(error),
                         sessionId,
                     });
                     if (!res.headersSent) {
-                        res.writeHead(500).end("Internal Server Error");
+                        res.writeHead(500).end('Internal Server Error');
                     }
                     else {
                         res.end();
@@ -476,17 +609,17 @@ class McpAbapAdtProxyServer {
                     return;
                 }
                 // Cleanup on connection close
-                res.on("close", () => {
-                    logger_js_1.logger.info("SSE connection closed", {
-                        type: "SSE_CONNECTION_CLOSED",
+                res.on('close', () => {
+                    logger_js_1.logger?.info('SSE connection closed', {
+                        type: 'SSE_CONNECTION_CLOSED',
                         sessionId,
                         pathname,
                     });
                     sessionServer.server.close();
                 });
                 transport.onerror = (error) => {
-                    logger_js_1.logger.error("SSE transport error", {
-                        type: "SSE_TRANSPORT_ERROR",
+                    logger_js_1.logger?.error('SSE transport error', {
+                        type: 'SSE_TRANSPORT_ERROR',
                         error: error instanceof Error ? error.message : String(error),
                         sessionId,
                     });
@@ -494,30 +627,30 @@ class McpAbapAdtProxyServer {
                 return;
             }
             // POST /messages or /mcp/messages - handle client messages
-            if (req.method === "POST" && postPathSet.has(pathname)) {
+            if (req.method === 'POST' && postPathSet.has(pathname)) {
                 // Extract sessionId from query string or header
                 let sessionId;
                 if (requestUrl) {
-                    sessionId = requestUrl.searchParams.get("sessionId") || undefined;
+                    sessionId = requestUrl.searchParams.get('sessionId') || undefined;
                 }
                 if (!sessionId) {
-                    sessionId = req.headers["x-session-id"];
+                    sessionId = req.headers['x-session-id'];
                 }
-                logger_js_1.logger.debug("SSE POST request received", {
-                    type: "SSE_POST_REQUEST",
+                logger_js_1.logger?.debug('SSE POST request received', {
+                    type: 'SSE_POST_REQUEST',
                     sessionId,
                     pathname,
                 });
                 if (!sessionId) {
-                    logger_js_1.logger.error("Missing sessionId in SSE POST request", {
-                        type: "SSE_MISSING_SESSION_ID",
+                    logger_js_1.logger?.error('Missing sessionId in SSE POST request', {
+                        type: 'SSE_MISSING_SESSION_ID',
                         pathname,
                     });
-                    res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({
-                        jsonrpc: "2.0",
+                    res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({
+                        jsonrpc: '2.0',
                         error: {
                             code: -32000,
-                            message: "Missing sessionId",
+                            message: 'Missing sessionId',
                         },
                         id: null,
                     }));
@@ -531,20 +664,20 @@ class McpAbapAdtProxyServer {
                         chunks.push(chunk);
                     }
                     if (chunks.length > 0) {
-                        const bodyString = Buffer.concat(chunks).toString("utf-8");
+                        const bodyString = Buffer.concat(chunks).toString('utf-8');
                         body = JSON.parse(bodyString);
                     }
                 }
                 catch (error) {
-                    logger_js_1.logger.error("Failed to parse SSE POST request body", {
-                        type: "SSE_POST_PARSE_ERROR",
+                    logger_js_1.logger?.error('Failed to parse SSE POST request body', {
+                        type: 'SSE_POST_PARSE_ERROR',
                         error: error instanceof Error ? error.message : String(error),
                     });
-                    res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({
-                        jsonrpc: "2.0",
+                    res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({
+                        jsonrpc: '2.0',
                         error: {
                             code: -32700,
-                            message: "Parse error",
+                            message: 'Parse error',
                         },
                         id: null,
                     }));
@@ -553,19 +686,17 @@ class McpAbapAdtProxyServer {
                 // Intercept and analyze request with config overrides
                 const configOverrides = {
                     btpDestination: this.config.btpDestination,
-                    mcpDestination: this.config.mcpDestination,
-                    mcpUrl: this.config.mcpUrl,
                 };
                 const intercepted = (0, requestInterceptor_js_1.interceptRequest)(req, body, configOverrides);
                 // Check routing decision
                 if (intercepted.routingDecision.strategy === headerAnalyzer_js_1.RoutingStrategy.UNKNOWN) {
-                    logger_js_1.logger.error("Routing decision failed for SSE POST", {
-                        type: "SSE_POST_ROUTING_FAILED",
+                    logger_js_1.logger?.error('Routing decision failed for SSE POST', {
+                        type: 'SSE_POST_ROUTING_FAILED',
                         reason: intercepted.routingDecision.reason,
                     });
-                    res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({
-                        jsonrpc: "2.0",
-                        id: body?.id || null,
+                    res.writeHead(400, { 'Content-Type': 'application/json' }).end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: getBodyId(body) || null,
                         error: {
                             code: -32602,
                             message: intercepted.routingDecision.reason,
@@ -578,18 +709,18 @@ class McpAbapAdtProxyServer {
                     await this.handleProxyRequest(intercepted, req, res);
                 }
                 catch (error) {
-                    logger_js_1.logger.error("Failed to process SSE POST request", {
-                        type: "SSE_POST_PROCESS_ERROR",
+                    logger_js_1.logger?.error('Failed to process SSE POST request', {
+                        type: 'SSE_POST_PROCESS_ERROR',
                         error: error instanceof Error ? error.message : String(error),
                     });
                     if (!res.headersSent) {
-                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({
-                            jsonrpc: "2.0",
-                            id: body?.id || null,
+                            jsonrpc: '2.0',
+                            id: getBodyId(body) || null,
                             error: {
                                 code: -32000,
-                                message: error instanceof Error ? error.message : "Unknown error",
+                                message: error instanceof Error ? error.message : 'Unknown error',
                             },
                         }));
                     }
@@ -597,25 +728,31 @@ class McpAbapAdtProxyServer {
                 return;
             }
             // Unknown path or method
-            res.writeHead(404, { "Content-Type": "text/plain" });
-            res.end("Not found");
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not found');
         });
         const port = sseConfig.port || 3002;
-        const host = sseConfig.host || "0.0.0.0";
+        const host = sseConfig.host || '0.0.0.0';
         return new Promise((resolve, reject) => {
             httpServer.listen(port, host, () => {
-                logger_js_1.logger.info("MCP Proxy Server started (SSE transport)", {
-                    type: "SERVER_STARTED",
-                    transport: "sse",
+                const authSourceObj = this.config.btpDestination
+                    ? `BTP destination "${this.config.btpDestination}"`
+                    : 'Waiting for "x-btp-destination" header in requests';
+                const msg = `MCP Proxy Server started on port ${port} (Transport: sse)
+Authorization source: ${authSourceObj}`;
+                console.log(msg);
+                logger_js_1.logger?.info('MCP Proxy Server started (SSE transport)', {
+                    type: 'SERVER_STARTED',
+                    transport: 'sse',
                     host,
                     port,
                 });
                 this.httpServer = httpServer;
                 resolve();
             });
-            httpServer.on("error", (error) => {
-                logger_js_1.logger.error("Failed to start SSE server", {
-                    type: "SERVER_START_ERROR",
+            httpServer.on('error', (error) => {
+                logger_js_1.logger?.error('Failed to start SSE server', {
+                    type: 'SERVER_START_ERROR',
                     error: error.message,
                 });
                 reject(error);
@@ -630,15 +767,15 @@ class McpAbapAdtProxyServer {
             await this.server.close();
         }
         catch (error) {
-            logger_js_1.logger.error("Failed to close MCP server", {
-                type: "SERVER_SHUTDOWN_ERROR",
+            logger_js_1.logger?.error('Failed to close MCP server', {
+                type: 'SERVER_SHUTDOWN_ERROR',
                 error: error instanceof Error ? error.message : String(error),
             });
         }
         if (this.httpServer) {
             return new Promise((resolve) => {
-                this.httpServer.close(() => {
-                    logger_js_1.logger.info("HTTP server closed");
+                this.httpServer?.close(() => {
+                    logger_js_1.logger?.info('HTTP server closed');
                     resolve();
                 });
             });
@@ -649,18 +786,18 @@ exports.McpAbapAdtProxyServer = McpAbapAdtProxyServer;
 // Export for use in bin script
 exports.default = McpAbapAdtProxyServer;
 // Auto-start server when run directly (unless MCP_SKIP_AUTO_START is set)
-if (process.env.MCP_SKIP_AUTO_START !== "true") {
+if (process.env.MCP_SKIP_AUTO_START !== 'true') {
     const server = new McpAbapAdtProxyServer();
     server.run().catch((error) => {
-        logger_js_1.logger.error("Fatal error while running MCP proxy server", {
-            type: "SERVER_FATAL_ERROR",
+        logger_js_1.logger?.error('Fatal error while running MCP proxy server', {
+            type: 'SERVER_FATAL_ERROR',
             error: error instanceof Error ? error.message : String(error),
         });
         // Always write fatal errors to stderr (even in non-verbose mode, as these are critical)
         // But skip in test environment
-        const isTestEnv = process.env.NODE_ENV === "test" ||
+        const isTestEnv = process.env.NODE_ENV === 'test' ||
             process.env.JEST_WORKER_ID !== undefined ||
-            typeof globalThis.jest !== "undefined";
+            typeof globalThis.jest !== 'undefined';
         if (!isTestEnv) {
             process.stderr.write(`[MCP Proxy] ✗ Fatal error: ${error instanceof Error ? error.message : String(error)}\n`);
         }