@mcp-abap-adt/core 2.5.0 → 2.5.2

package/dist/index.js

@@ -0,0 +1,2453 @@
+#!/usr/bin/env node
+"use strict";
+// Simple stdio mode detection (like reference implementation)
+// No output suppression needed - dotenv removed, manual .env parsing used
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcp_abap_adt_server = void 0;
+exports.setSapConfigOverride = setSapConfigOverride;
+exports.setAbapConnectionOverride = setAbapConnectionOverride;
+exports.getConfig = getConfig;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const z = __importStar(require("zod"));
+const path_1 = __importDefault(require("path"));
+// dotenv removed - using manual .env parsing for all modes to avoid stdout pollution
+const http_1 = require("http");
+const crypto_1 = require("crypto");
+// Import handler functions
+// Import handler functions
+const handleGetProgram_1 = require("./handlers/program/readonly/handleGetProgram");
+const handleGetClass_1 = require("./handlers/class/readonly/handleGetClass");
+const handleGetFunctionGroup_1 = require("./handlers/function/readonly/handleGetFunctionGroup");
+const handleGetFunction_1 = require("./handlers/function/readonly/handleGetFunction");
+const handleGetTable_1 = require("./handlers/table/readonly/handleGetTable");
+const handleGetStructure_1 = require("./handlers/structure/readonly/handleGetStructure");
+const handleGetTableContents_1 = require("./handlers/table/readonly/handleGetTableContents");
+const handleGetPackage_1 = require("./handlers/package/readonly/handleGetPackage");
+const handleCreatePackage_1 = require("./handlers/package/high/handleCreatePackage");
+const handleGetInclude_1 = require("./handlers/include/readonly/handleGetInclude");
+const handleGetIncludesList_1 = require("./handlers/include/readonly/handleGetIncludesList");
+const handleGetTypeInfo_1 = require("./handlers/system/readonly/handleGetTypeInfo");
+const handleGetInterface_1 = require("./handlers/interface/readonly/handleGetInterface");
+const handleGetTransaction_1 = require("./handlers/system/readonly/handleGetTransaction");
+const handleSearchObject_1 = require("./handlers/search/readonly/handleSearchObject");
+const handleGetEnhancements_1 = require("./handlers/enhancement/readonly/handleGetEnhancements");
+const handleGetEnhancementImpl_1 = require("./handlers/enhancement/readonly/handleGetEnhancementImpl");
+const handleGetEnhancementSpot_1 = require("./handlers/enhancement/readonly/handleGetEnhancementSpot");
+const handleGetBdef_1 = require("./handlers/behavior_definition/readonly/handleGetBdef");
+const handleGetSqlQuery_1 = require("./handlers/system/readonly/handleGetSqlQuery");
+const handleGetWhereUsed_1 = require("./handlers/system/readonly/handleGetWhereUsed");
+const handleGetObjectInfo_1 = require("./handlers/system/readonly/handleGetObjectInfo");
+const handleGetAbapAST_1 = require("./handlers/system/readonly/handleGetAbapAST");
+const handleGetAbapSemanticAnalysis_1 = require("./handlers/system/readonly/handleGetAbapSemanticAnalysis");
+const handleGetAbapSystemSymbols_1 = require("./handlers/system/readonly/handleGetAbapSystemSymbols");
+const handleGetDomain_1 = require("./handlers/domain/readonly/handleGetDomain");
+const handleCreateDomain_1 = require("./handlers/domain/high/handleCreateDomain");
+const handleUpdateDomain_1 = require("./handlers/domain/high/handleUpdateDomain");
+const handleCreateDataElement_1 = require("./handlers/data_element/high/handleCreateDataElement");
+const handleUpdateDataElement_1 = require("./handlers/data_element/high/handleUpdateDataElement");
+const handleGetDataElement_1 = require("./handlers/data_element/readonly/handleGetDataElement");
+const handleCreateTransport_1 = require("./handlers/transport/high/handleCreateTransport");
+const handleGetTransport_1 = require("./handlers/transport/readonly/handleGetTransport");
+const handleCreateTable_1 = require("./handlers/table/high/handleCreateTable");
+const handleCreateStructure_1 = require("./handlers/structure/high/handleCreateStructure");
+const handleCreateView_1 = require("./handlers/view/high/handleCreateView");
+const handleGetView_1 = require("./handlers/view/readonly/handleGetView");
+const handleGetServiceDefinition_1 = require("./handlers/service_definition/readonly/handleGetServiceDefinition");
+const handleCreateClass_1 = require("./handlers/class/high/handleCreateClass");
+const handleCreateProgram_1 = require("./handlers/program/high/handleCreateProgram");
+const handleCreateInterface_1 = require("./handlers/interface/high/handleCreateInterface");
+const handleCreateFunctionGroup_1 = require("./handlers/function/high/handleCreateFunctionGroup");
+const handleCreateFunctionModule_1 = require("./handlers/function/high/handleCreateFunctionModule");
+const handleActivateObject_1 = require("./handlers/common/low/handleActivateObject");
+const handleDeleteObject_1 = require("./handlers/common/low/handleDeleteObject");
+const handleCheckObject_1 = require("./handlers/common/low/handleCheckObject");
+const handleUpdateClass_1 = require("./handlers/class/high/handleUpdateClass");
+const handleUpdateProgram_1 = require("./handlers/program/high/handleUpdateProgram");
+const handleUpdateView_1 = require("./handlers/view/high/handleUpdateView");
+const handleUpdateInterface_1 = require("./handlers/interface/high/handleUpdateInterface");
+const handleUpdateFunctionModule_1 = require("./handlers/function/high/handleUpdateFunctionModule");
+const handleUpdateStructure_1 = require("./handlers/structure/low/handleUpdateStructure");
+const handleUpdatePackage_1 = require("./handlers/package/low/handleUpdatePackage");
+const handleUpdateTable_1 = require("./handlers/table/low/handleUpdateTable");
+const handleUnlockPackage_1 = require("./handlers/package/low/handleUnlockPackage");
+const handleUpdateClass_2 = require("./handlers/class/low/handleUpdateClass");
+const handleUpdateProgram_2 = require("./handlers/program/low/handleUpdateProgram");
+const handleUpdateInterface_2 = require("./handlers/interface/low/handleUpdateInterface");
+const handleUpdateFunctionModule_2 = require("./handlers/function/low/handleUpdateFunctionModule");
+const handleUpdateView_2 = require("./handlers/view/low/handleUpdateView");
+const handleUpdateDomain_2 = require("./handlers/domain/low/handleUpdateDomain");
+const handleUpdateDataElement_2 = require("./handlers/data_element/low/handleUpdateDataElement");
+const handleUpdateBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleUpdateBehaviorDefinition");
+const handleUpdateMetadataExtension_1 = require("./handlers/ddlx/low/handleUpdateMetadataExtension");
+const handleGetSession_1 = require("./handlers/system/readonly/handleGetSession");
+const handleValidateObject_1 = require("./handlers/common/low/handleValidateObject");
+const handleLockObject_1 = require("./handlers/common/low/handleLockObject");
+const handleUnlockObject_1 = require("./handlers/common/low/handleUnlockObject");
+const handleValidateClass_1 = require("./handlers/class/low/handleValidateClass");
+const handleCheckClass_1 = require("./handlers/class/low/handleCheckClass");
+const handleValidateTable_1 = require("./handlers/table/low/handleValidateTable");
+const handleCheckTable_1 = require("./handlers/table/low/handleCheckTable");
+const handleValidateFunctionModule_1 = require("./handlers/function/low/handleValidateFunctionModule");
+const handleCheckFunctionModule_1 = require("./handlers/function/low/handleCheckFunctionModule");
+const handleCreateBehaviorDefinition_1 = require("./handlers/behavior_definition/high/handleCreateBehaviorDefinition");
+const handleUpdateBehaviorDefinition_2 = require("./handlers/behavior_definition/high/handleUpdateBehaviorDefinition");
+const handleCreateMetadataExtension_1 = require("./handlers/ddlx/high/handleCreateMetadataExtension");
+const handleUpdateMetadataExtension_2 = require("./handlers/ddlx/high/handleUpdateMetadataExtension");
+const handleGetInactiveObjects_1 = require("./handlers/system/readonly/handleGetInactiveObjects");
+// New low-level handlers imports
+const handleDeleteClass_1 = require("./handlers/class/low/handleDeleteClass");
+const handleLockClass_1 = require("./handlers/class/low/handleLockClass");
+const handleUnlockClass_1 = require("./handlers/class/low/handleUnlockClass");
+const handleCreateClass_2 = require("./handlers/class/low/handleCreateClass");
+const handleLockClassTestClasses_1 = require("./handlers/class/low/handleLockClassTestClasses");
+const handleUnlockClassTestClasses_1 = require("./handlers/class/low/handleUnlockClassTestClasses");
+const handleUpdateClassTestClasses_1 = require("./handlers/class/low/handleUpdateClassTestClasses");
+const handleActivateClassTestClasses_1 = require("./handlers/class/low/handleActivateClassTestClasses");
+const handleRunClassUnitTests_1 = require("./handlers/class/low/handleRunClassUnitTests");
+const handleGetClassUnitTestStatus_1 = require("./handlers/class/low/handleGetClassUnitTestStatus");
+const handleGetClassUnitTestResult_1 = require("./handlers/class/low/handleGetClassUnitTestResult");
+const handleCheckProgram_1 = require("./handlers/program/low/handleCheckProgram");
+const handleDeleteProgram_1 = require("./handlers/program/low/handleDeleteProgram");
+const handleLockProgram_1 = require("./handlers/program/low/handleLockProgram");
+const handleUnlockProgram_1 = require("./handlers/program/low/handleUnlockProgram");
+const handleValidateProgram_1 = require("./handlers/program/low/handleValidateProgram");
+const handleCreateProgram_2 = require("./handlers/program/low/handleCreateProgram");
+const handleCheckInterface_1 = require("./handlers/interface/low/handleCheckInterface");
+const handleDeleteInterface_1 = require("./handlers/interface/low/handleDeleteInterface");
+const handleLockInterface_1 = require("./handlers/interface/low/handleLockInterface");
+const handleUnlockInterface_1 = require("./handlers/interface/low/handleUnlockInterface");
+const handleValidateInterface_1 = require("./handlers/interface/low/handleValidateInterface");
+const handleCreateInterface_2 = require("./handlers/interface/low/handleCreateInterface");
+const handleCheckFunctionGroup_1 = require("./handlers/function/low/handleCheckFunctionGroup");
+const handleDeleteFunctionGroup_1 = require("./handlers/function/low/handleDeleteFunctionGroup");
+const handleDeleteFunctionModule_1 = require("./handlers/function/low/handleDeleteFunctionModule");
+const handleLockFunctionGroup_1 = require("./handlers/function/low/handleLockFunctionGroup");
+const handleLockFunctionModule_1 = require("./handlers/function/low/handleLockFunctionModule");
+const handleUnlockFunctionGroup_1 = require("./handlers/function/low/handleUnlockFunctionGroup");
+const handleUnlockFunctionModule_1 = require("./handlers/function/low/handleUnlockFunctionModule");
+const handleValidateFunctionGroup_1 = require("./handlers/function/low/handleValidateFunctionGroup");
+const handleCreateFunctionGroup_2 = require("./handlers/function/low/handleCreateFunctionGroup");
+const handleCreateFunctionModule_2 = require("./handlers/function/low/handleCreateFunctionModule");
+const handleCheckDataElement_1 = require("./handlers/data_element/low/handleCheckDataElement");
+const handleDeleteDataElement_1 = require("./handlers/data_element/low/handleDeleteDataElement");
+const handleLockDataElement_1 = require("./handlers/data_element/low/handleLockDataElement");
+const handleUnlockDataElement_1 = require("./handlers/data_element/low/handleUnlockDataElement");
+const handleValidateDataElement_1 = require("./handlers/data_element/low/handleValidateDataElement");
+const handleCreateDataElement_2 = require("./handlers/data_element/low/handleCreateDataElement");
+const handleCheckDomain_1 = require("./handlers/domain/low/handleCheckDomain");
+const handleDeleteDomain_1 = require("./handlers/domain/low/handleDeleteDomain");
+const handleLockDomain_1 = require("./handlers/domain/low/handleLockDomain");
+const handleUnlockDomain_1 = require("./handlers/domain/low/handleUnlockDomain");
+const handleValidateDomain_1 = require("./handlers/domain/low/handleValidateDomain");
+const handleCreateDomain_2 = require("./handlers/domain/low/handleCreateDomain");
+const handleCheckStructure_1 = require("./handlers/structure/low/handleCheckStructure");
+const handleDeleteStructure_1 = require("./handlers/structure/low/handleDeleteStructure");
+const handleLockStructure_1 = require("./handlers/structure/low/handleLockStructure");
+const handleUnlockStructure_1 = require("./handlers/structure/low/handleUnlockStructure");
+const handleValidateStructure_1 = require("./handlers/structure/low/handleValidateStructure");
+const handleCreateStructure_2 = require("./handlers/structure/low/handleCreateStructure");
+const handleDeleteTable_1 = require("./handlers/table/low/handleDeleteTable");
+const handleLockTable_1 = require("./handlers/table/low/handleLockTable");
+const handleUnlockTable_1 = require("./handlers/table/low/handleUnlockTable");
+const handleCreateTable_2 = require("./handlers/table/low/handleCreateTable");
+const handleCheckView_1 = require("./handlers/view/low/handleCheckView");
+const handleDeleteView_1 = require("./handlers/view/low/handleDeleteView");
+const handleLockView_1 = require("./handlers/view/low/handleLockView");
+const handleUnlockView_1 = require("./handlers/view/low/handleUnlockView");
+const handleValidateView_1 = require("./handlers/view/low/handleValidateView");
+const handleCreateView_2 = require("./handlers/view/low/handleCreateView");
+const handleCheckPackage_1 = require("./handlers/package/low/handleCheckPackage");
+const handleDeletePackage_1 = require("./handlers/package/low/handleDeletePackage");
+const handleLockPackage_1 = require("./handlers/package/low/handleLockPackage");
+const handleValidatePackage_1 = require("./handlers/package/low/handleValidatePackage");
+const handleCreatePackage_2 = require("./handlers/package/low/handleCreatePackage");
+const handleCreateTransport_2 = require("./handlers/transport/low/handleCreateTransport");
+const handleCheckBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleCheckBehaviorDefinition");
+const handleDeleteBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleDeleteBehaviorDefinition");
+const handleLockBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleLockBehaviorDefinition");
+const handleUnlockBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleUnlockBehaviorDefinition");
+const handleValidateBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleValidateBehaviorDefinition");
+const handleCreateBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleCreateBehaviorDefinition");
+const handleCheckMetadataExtension_1 = require("./handlers/ddlx/low/handleCheckMetadataExtension");
+const handleDeleteMetadataExtension_1 = require("./handlers/ddlx/low/handleDeleteMetadataExtension");
+const handleLockMetadataExtension_1 = require("./handlers/ddlx/low/handleLockMetadataExtension");
+const handleUnlockMetadataExtension_1 = require("./handlers/ddlx/low/handleUnlockMetadataExtension");
+const handleValidateMetadataExtension_1 = require("./handlers/ddlx/low/handleValidateMetadataExtension");
+const handleCreateMetadataExtension_2 = require("./handlers/ddlx/low/handleCreateMetadataExtension");
+const handleActivateProgram_1 = require("./handlers/program/low/handleActivateProgram");
+const handleActivateClass_1 = require("./handlers/class/low/handleActivateClass");
+const handleActivateInterface_1 = require("./handlers/interface/low/handleActivateInterface");
+const handleActivateFunctionModule_1 = require("./handlers/function/low/handleActivateFunctionModule");
+const handleActivateFunctionGroup_1 = require("./handlers/function/low/handleActivateFunctionGroup");
+const handleActivateDataElement_1 = require("./handlers/data_element/low/handleActivateDataElement");
+const handleActivateDomain_1 = require("./handlers/domain/low/handleActivateDomain");
+const handleActivateStructure_1 = require("./handlers/structure/low/handleActivateStructure");
+const handleActivateTable_1 = require("./handlers/table/low/handleActivateTable");
+const handleActivateView_1 = require("./handlers/view/low/handleActivateView");
+const handleActivateBehaviorDefinition_1 = require("./handlers/behavior_definition/low/handleActivateBehaviorDefinition");
+const handleActivateMetadataExtension_1 = require("./handlers/ddlx/low/handleActivateMetadataExtension");
+// Import shared utility functions and types
+const utils_1 = require("./lib/utils");
+// Import logger
+const logger_1 = require("./lib/logger");
+// Import tool registry
+// Import TOOL_DEFINITION from handlers
+const handleGetProgram_2 = require("./handlers/program/readonly/handleGetProgram");
+const handleGetClass_2 = require("./handlers/class/readonly/handleGetClass");
+const handleGetFunction_2 = require("./handlers/function/readonly/handleGetFunction");
+const handleGetFunctionGroup_2 = require("./handlers/function/readonly/handleGetFunctionGroup");
+const handleGetTable_2 = require("./handlers/table/readonly/handleGetTable");
+const handleGetStructure_2 = require("./handlers/structure/readonly/handleGetStructure");
+const handleGetTableContents_2 = require("./handlers/table/readonly/handleGetTableContents");
+const handleGetPackage_2 = require("./handlers/package/readonly/handleGetPackage");
+const handleCreatePackage_3 = require("./handlers/package/high/handleCreatePackage");
+const handleGetInclude_2 = require("./handlers/include/readonly/handleGetInclude");
+const handleGetIncludesList_2 = require("./handlers/include/readonly/handleGetIncludesList");
+const handleGetTypeInfo_2 = require("./handlers/system/readonly/handleGetTypeInfo");
+const handleGetInterface_2 = require("./handlers/interface/readonly/handleGetInterface");
+const handleGetTransaction_2 = require("./handlers/system/readonly/handleGetTransaction");
+const handleSearchObject_2 = require("./handlers/search/readonly/handleSearchObject");
+const handleGetEnhancements_2 = require("./handlers/enhancement/readonly/handleGetEnhancements");
+const handleGetEnhancementImpl_2 = require("./handlers/enhancement/readonly/handleGetEnhancementImpl");
+const handleGetEnhancementSpot_2 = require("./handlers/enhancement/readonly/handleGetEnhancementSpot");
+const handleGetBdef_2 = require("./handlers/behavior_definition/readonly/handleGetBdef");
+const handleGetSqlQuery_2 = require("./handlers/system/readonly/handleGetSqlQuery");
+const handleGetWhereUsed_2 = require("./handlers/system/readonly/handleGetWhereUsed");
+const handleGetObjectInfo_2 = require("./handlers/system/readonly/handleGetObjectInfo");
+const handleGetAbapAST_2 = require("./handlers/system/readonly/handleGetAbapAST");
+const handleGetAbapSemanticAnalysis_2 = require("./handlers/system/readonly/handleGetAbapSemanticAnalysis");
+const handleGetAbapSystemSymbols_2 = require("./handlers/system/readonly/handleGetAbapSystemSymbols");
+const handleGetDomain_2 = require("./handlers/domain/readonly/handleGetDomain");
+const handleCreateDomain_3 = require("./handlers/domain/high/handleCreateDomain");
+const handleUpdateDomain_3 = require("./handlers/domain/high/handleUpdateDomain");
+const handleCreateDataElement_3 = require("./handlers/data_element/high/handleCreateDataElement");
+const handleUpdateDataElement_3 = require("./handlers/data_element/high/handleUpdateDataElement");
+const handleGetDataElement_2 = require("./handlers/data_element/readonly/handleGetDataElement");
+const handleCreateTransport_3 = require("./handlers/transport/high/handleCreateTransport");
+const handleGetTransport_2 = require("./handlers/transport/readonly/handleGetTransport");
+const handleCreateTable_3 = require("./handlers/table/high/handleCreateTable");
+const handleCreateStructure_3 = require("./handlers/structure/high/handleCreateStructure");
+const handleCreateView_3 = require("./handlers/view/high/handleCreateView");
+const handleGetView_2 = require("./handlers/view/readonly/handleGetView");
+const handleGetServiceDefinition_2 = require("./handlers/service_definition/readonly/handleGetServiceDefinition");
+const handleCreateClass_3 = require("./handlers/class/high/handleCreateClass");
+const handleCreateProgram_3 = require("./handlers/program/high/handleCreateProgram");
+const handleCreateInterface_3 = require("./handlers/interface/high/handleCreateInterface");
+const handleCreateFunctionGroup_3 = require("./handlers/function/high/handleCreateFunctionGroup");
+const handleCreateFunctionModule_3 = require("./handlers/function/high/handleCreateFunctionModule");
+const handleActivateObject_2 = require("./handlers/common/low/handleActivateObject");
+const handleDeleteObject_2 = require("./handlers/common/low/handleDeleteObject");
+const handleCheckObject_2 = require("./handlers/common/low/handleCheckObject");
+const handleUpdateClass_3 = require("./handlers/class/high/handleUpdateClass");
+const handleUpdateProgram_3 = require("./handlers/program/high/handleUpdateProgram");
+const handleUpdateView_3 = require("./handlers/view/high/handleUpdateView");
+const handleUpdateInterface_3 = require("./handlers/interface/high/handleUpdateInterface");
+const handleUpdateFunctionModule_3 = require("./handlers/function/high/handleUpdateFunctionModule");
+const handleUpdateStructure_2 = require("./handlers/structure/low/handleUpdateStructure");
+const handleUpdatePackage_2 = require("./handlers/package/low/handleUpdatePackage");
+const handleUpdateTable_2 = require("./handlers/table/low/handleUpdateTable");
+const handleUnlockPackage_2 = require("./handlers/package/low/handleUnlockPackage");
+const handleUpdateClass_4 = require("./handlers/class/low/handleUpdateClass");
+const handleUpdateProgram_4 = require("./handlers/program/low/handleUpdateProgram");
+const handleUpdateInterface_4 = require("./handlers/interface/low/handleUpdateInterface");
+const handleUpdateFunctionModule_4 = require("./handlers/function/low/handleUpdateFunctionModule");
+const handleUpdateView_4 = require("./handlers/view/low/handleUpdateView");
+const handleUpdateDomain_4 = require("./handlers/domain/low/handleUpdateDomain");
+const handleUpdateDataElement_4 = require("./handlers/data_element/low/handleUpdateDataElement");
+const handleUpdateBehaviorDefinition_3 = require("./handlers/behavior_definition/low/handleUpdateBehaviorDefinition");
+const handleUpdateMetadataExtension_3 = require("./handlers/ddlx/low/handleUpdateMetadataExtension");
+const handleGetSession_2 = require("./handlers/system/readonly/handleGetSession");
+const handleValidateObject_2 = require("./handlers/common/low/handleValidateObject");
+const handleLockObject_2 = require("./handlers/common/low/handleLockObject");
+const handleUnlockObject_2 = require("./handlers/common/low/handleUnlockObject");
+const handleValidateClass_2 = require("./handlers/class/low/handleValidateClass");
+const handleCheckClass_2 = require("./handlers/class/low/handleCheckClass");
+const handleValidateTable_2 = require("./handlers/table/low/handleValidateTable");
+const handleCheckTable_2 = require("./handlers/table/low/handleCheckTable");
+const handleValidateFunctionModule_2 = require("./handlers/function/low/handleValidateFunctionModule");
+const handleCheckFunctionModule_2 = require("./handlers/function/low/handleCheckFunctionModule");
+const handleActivateProgram_2 = require("./handlers/program/low/handleActivateProgram");
+const handleActivateClass_2 = require("./handlers/class/low/handleActivateClass");
+const handleActivateInterface_2 = require("./handlers/interface/low/handleActivateInterface");
+const handleActivateFunctionModule_2 = require("./handlers/function/low/handleActivateFunctionModule");
+const handleActivateFunctionGroup_2 = require("./handlers/function/low/handleActivateFunctionGroup");
+const handleActivateDataElement_2 = require("./handlers/data_element/low/handleActivateDataElement");
+const handleActivateDomain_2 = require("./handlers/domain/low/handleActivateDomain");
+const handleActivateStructure_2 = require("./handlers/structure/low/handleActivateStructure");
+const handleActivateTable_2 = require("./handlers/table/low/handleActivateTable");
+const handleActivateView_2 = require("./handlers/view/low/handleActivateView");
+const handleActivateBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleActivateBehaviorDefinition");
+const handleActivateMetadataExtension_2 = require("./handlers/ddlx/low/handleActivateMetadataExtension");
+const handleCreateBehaviorDefinition_3 = require("./handlers/behavior_definition/high/handleCreateBehaviorDefinition");
+const handleUpdateBehaviorDefinition_4 = require("./handlers/behavior_definition/high/handleUpdateBehaviorDefinition");
+const handleCreateMetadataExtension_3 = require("./handlers/ddlx/high/handleCreateMetadataExtension");
+const handleUpdateMetadataExtension_4 = require("./handlers/ddlx/high/handleUpdateMetadataExtension");
+const handleGetInactiveObjects_2 = require("./handlers/system/readonly/handleGetInactiveObjects");
+// New low-level handlers TOOL_DEFINITION imports
+const handleDeleteClass_2 = require("./handlers/class/low/handleDeleteClass");
+const handleLockClass_2 = require("./handlers/class/low/handleLockClass");
+const handleUnlockClass_2 = require("./handlers/class/low/handleUnlockClass");
+const handleCreateClass_4 = require("./handlers/class/low/handleCreateClass");
+const handleLockClassTestClasses_2 = require("./handlers/class/low/handleLockClassTestClasses");
+const handleUnlockClassTestClasses_2 = require("./handlers/class/low/handleUnlockClassTestClasses");
+const handleUpdateClassTestClasses_2 = require("./handlers/class/low/handleUpdateClassTestClasses");
+const handleActivateClassTestClasses_2 = require("./handlers/class/low/handleActivateClassTestClasses");
+const handleRunClassUnitTests_2 = require("./handlers/class/low/handleRunClassUnitTests");
+const handleGetClassUnitTestStatus_2 = require("./handlers/class/low/handleGetClassUnitTestStatus");
+const handleGetClassUnitTestResult_2 = require("./handlers/class/low/handleGetClassUnitTestResult");
+const handleCheckProgram_2 = require("./handlers/program/low/handleCheckProgram");
+const handleDeleteProgram_2 = require("./handlers/program/low/handleDeleteProgram");
+const handleLockProgram_2 = require("./handlers/program/low/handleLockProgram");
+const handleUnlockProgram_2 = require("./handlers/program/low/handleUnlockProgram");
+const handleValidateProgram_2 = require("./handlers/program/low/handleValidateProgram");
+const handleCreateProgram_4 = require("./handlers/program/low/handleCreateProgram");
+const handleCheckInterface_2 = require("./handlers/interface/low/handleCheckInterface");
+const handleDeleteInterface_2 = require("./handlers/interface/low/handleDeleteInterface");
+const handleLockInterface_2 = require("./handlers/interface/low/handleLockInterface");
+const handleUnlockInterface_2 = require("./handlers/interface/low/handleUnlockInterface");
+const handleValidateInterface_2 = require("./handlers/interface/low/handleValidateInterface");
+const handleCreateInterface_4 = require("./handlers/interface/low/handleCreateInterface");
+const handleCheckFunctionGroup_2 = require("./handlers/function/low/handleCheckFunctionGroup");
+const handleDeleteFunctionGroup_2 = require("./handlers/function/low/handleDeleteFunctionGroup");
+const handleDeleteFunctionModule_2 = require("./handlers/function/low/handleDeleteFunctionModule");
+const handleLockFunctionGroup_2 = require("./handlers/function/low/handleLockFunctionGroup");
+const handleLockFunctionModule_2 = require("./handlers/function/low/handleLockFunctionModule");
+const handleUnlockFunctionGroup_2 = require("./handlers/function/low/handleUnlockFunctionGroup");
+const handleUnlockFunctionModule_2 = require("./handlers/function/low/handleUnlockFunctionModule");
+const handleValidateFunctionGroup_2 = require("./handlers/function/low/handleValidateFunctionGroup");
+const handleCreateFunctionGroup_4 = require("./handlers/function/low/handleCreateFunctionGroup");
+const handleCreateFunctionModule_4 = require("./handlers/function/low/handleCreateFunctionModule");
+const handleCheckDataElement_2 = require("./handlers/data_element/low/handleCheckDataElement");
+const handleDeleteDataElement_2 = require("./handlers/data_element/low/handleDeleteDataElement");
+const handleLockDataElement_2 = require("./handlers/data_element/low/handleLockDataElement");
+const handleUnlockDataElement_2 = require("./handlers/data_element/low/handleUnlockDataElement");
+const handleValidateDataElement_2 = require("./handlers/data_element/low/handleValidateDataElement");
+const handleCreateDataElement_4 = require("./handlers/data_element/low/handleCreateDataElement");
+const handleCheckDomain_2 = require("./handlers/domain/low/handleCheckDomain");
+const handleDeleteDomain_2 = require("./handlers/domain/low/handleDeleteDomain");
+const handleLockDomain_2 = require("./handlers/domain/low/handleLockDomain");
+const handleUnlockDomain_2 = require("./handlers/domain/low/handleUnlockDomain");
+const handleValidateDomain_2 = require("./handlers/domain/low/handleValidateDomain");
+const handleCreateDomain_4 = require("./handlers/domain/low/handleCreateDomain");
+const handleCheckStructure_2 = require("./handlers/structure/low/handleCheckStructure");
+const handleDeleteStructure_2 = require("./handlers/structure/low/handleDeleteStructure");
+const handleLockStructure_2 = require("./handlers/structure/low/handleLockStructure");
+const handleUnlockStructure_2 = require("./handlers/structure/low/handleUnlockStructure");
+const handleValidateStructure_2 = require("./handlers/structure/low/handleValidateStructure");
+const handleCreateStructure_4 = require("./handlers/structure/low/handleCreateStructure");
+const handleDeleteTable_2 = require("./handlers/table/low/handleDeleteTable");
+const handleLockTable_2 = require("./handlers/table/low/handleLockTable");
+const handleUnlockTable_2 = require("./handlers/table/low/handleUnlockTable");
+const handleCreateTable_4 = require("./handlers/table/low/handleCreateTable");
+const handleCheckView_2 = require("./handlers/view/low/handleCheckView");
+const handleDeleteView_2 = require("./handlers/view/low/handleDeleteView");
+const handleLockView_2 = require("./handlers/view/low/handleLockView");
+const handleUnlockView_2 = require("./handlers/view/low/handleUnlockView");
+const handleValidateView_2 = require("./handlers/view/low/handleValidateView");
+const handleCreateView_4 = require("./handlers/view/low/handleCreateView");
+const handleCheckPackage_2 = require("./handlers/package/low/handleCheckPackage");
+const handleDeletePackage_2 = require("./handlers/package/low/handleDeletePackage");
+const handleLockPackage_2 = require("./handlers/package/low/handleLockPackage");
+const handleValidatePackage_2 = require("./handlers/package/low/handleValidatePackage");
+const handleCreatePackage_4 = require("./handlers/package/low/handleCreatePackage");
+const handleCreateTransport_4 = require("./handlers/transport/low/handleCreateTransport");
+const handleCheckBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleCheckBehaviorDefinition");
+const handleDeleteBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleDeleteBehaviorDefinition");
+const handleLockBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleLockBehaviorDefinition");
+const handleUnlockBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleUnlockBehaviorDefinition");
+const handleValidateBehaviorDefinition_2 = require("./handlers/behavior_definition/low/handleValidateBehaviorDefinition");
+const handleCreateBehaviorDefinition_4 = require("./handlers/behavior_definition/low/handleCreateBehaviorDefinition");
+const handleCheckMetadataExtension_2 = require("./handlers/ddlx/low/handleCheckMetadataExtension");
+const handleDeleteMetadataExtension_2 = require("./handlers/ddlx/low/handleDeleteMetadataExtension");
+const handleLockMetadataExtension_2 = require("./handlers/ddlx/low/handleLockMetadataExtension");
+const handleUnlockMetadataExtension_2 = require("./handlers/ddlx/low/handleUnlockMetadataExtension");
+const handleValidateMetadataExtension_2 = require("./handlers/ddlx/low/handleValidateMetadataExtension");
+const handleCreateMetadataExtension_4 = require("./handlers/ddlx/low/handleCreateMetadataExtension");
+// --- ENV FILE LOADING LOGIC ---
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Display help message
+ */
+function showHelp() {
+    const help = `
+MCP ABAP ADT Server - SAP ABAP Development Tools MCP Integration
+
+USAGE:
+  mcp-abap-adt [options]
+
+DESCRIPTION:
+  MCP server for interacting with SAP ABAP systems via ADT (ABAP Development Tools).
+  Supports multiple transport modes: HTTP (default), stdio, and SSE.
+
+TRANSPORT MODES:
+  Default: HTTP (can work without .env file, receives config via HTTP headers)
+  stdio:   --transport=stdio (for MCP clients like Cline, Cursor, Claude Desktop)
+  SSE:     --transport=sse
+
+OPTIONS:
+  --help                           Show this help message
+
+ENVIRONMENT FILE:
+  --env=<path>                     Path to .env file (default: ./.env)
+  --env <path>                     Alternative syntax for --env
+
+TRANSPORT SELECTION:
+  --transport=<type>               Transport type: stdio|http|streamable-http|sse
+                                   Default: http (streamable-http)
+                                   Shortcuts: --http (same as --transport=http)
+                                             --sse (same as --transport=sse)
+                                             --stdio (same as --transport=stdio)
+
+HTTP/STREAMABLE-HTTP OPTIONS:
+  --http-port=<port>               HTTP server port (default: 3000)
+  --http-host=<host>               HTTP server host (default: 0.0.0.0)
+  --http-json-response             Enable JSON response format
+  --http-allowed-origins=<list>    Comma-separated allowed origins for CORS
+                                   Example: --http-allowed-origins=http://localhost:3000,https://example.com
+  --http-allowed-hosts=<list>      Comma-separated allowed hosts
+  --http-enable-dns-protection     Enable DNS rebinding protection
+
+SSE (SERVER-SENT EVENTS) OPTIONS:
+  --sse-port=<port>                SSE server port (default: 3001)
+  --sse-host=<host>                SSE server host (default: 0.0.0.0)
+  --sse-allowed-origins=<list>     Comma-separated allowed origins for CORS
+                                   Example: --sse-allowed-origins=http://localhost:3000
+  --sse-allowed-hosts=<list>       Comma-separated allowed hosts
+  --sse-enable-dns-protection     Enable DNS rebinding protection
+
+ENVIRONMENT VARIABLES:
+  MCP_ENV_PATH                     Path to .env file
+  MCP_SKIP_ENV_LOAD                Skip automatic .env loading (true|false)
+  MCP_SKIP_AUTO_START              Skip automatic server start (true|false)
+  MCP_TRANSPORT                    Default transport type (stdio|http|sse)
+  MCP_HTTP_PORT                    Default HTTP port (default: 3000)
+  MCP_HTTP_HOST                    Default HTTP host (default: 0.0.0.0)
+  MCP_HTTP_ENABLE_JSON_RESPONSE   Enable JSON responses (true|false)
+  MCP_HTTP_ALLOWED_ORIGINS         Allowed CORS origins (comma-separated)
+  MCP_HTTP_ALLOWED_HOSTS           Allowed hosts (comma-separated)
+  MCP_HTTP_ENABLE_DNS_PROTECTION   Enable DNS protection (true|false)
+  MCP_SSE_PORT                     Default SSE port (default: 3001)
+  MCP_SSE_HOST                     Default SSE host (default: 0.0.0.0)
+  MCP_SSE_ALLOWED_ORIGINS          Allowed CORS origins for SSE (comma-separated)
+  MCP_SSE_ALLOWED_HOSTS            Allowed hosts for SSE (comma-separated)
+  MCP_SSE_ENABLE_DNS_PROTECTION    Enable DNS protection for SSE (true|false)
+
+SAP CONNECTION (.env file):
+  SAP_URL                          SAP system URL (required)
+                                   Example: https://your-system.sap.com
+  SAP_CLIENT                       SAP client number (required)
+                                   Example: 100
+  SAP_AUTH_TYPE                    Authentication type: basic|jwt (default: basic)
+  SAP_USERNAME                     SAP username (required for basic auth)
+  SAP_PASSWORD                     SAP password (required for basic auth)
+  SAP_JWT_TOKEN                    JWT token (required for jwt auth)
+
+GENERATING .ENV FROM SERVICE KEY (JWT Authentication):
+  To generate .env file from SAP BTP service key JSON file, install the
+  connection package globally:
+
+    npm install -g @mcp-abap-adt/connection
+
+  Then use the sap-abap-auth command:
+
+    sap-abap-auth auth -k path/to/service-key.json
+
+  This will create/update .env file with JWT tokens and connection details.
+
+EXAMPLES:
+  # Default HTTP mode (works without .env file)
+  mcp-abap-adt
+
+  # HTTP server on custom port
+  mcp-abap-adt --http-port=8080
+
+  # Use stdio mode (for MCP clients, requires .env file)
+  mcp-abap-adt --transport=stdio
+
+  # Use custom .env file
+  mcp-abap-adt --env=/path/to/my.env
+
+  # Start HTTP server with CORS enabled
+  mcp-abap-adt --transport=http --http-port=3000 \\
+                --http-allowed-origins=http://localhost:3000,https://example.com
+
+  # Start SSE server on custom port
+  mcp-abap-adt --transport=sse --sse-port=3001
+
+  # Start SSE server with CORS and DNS protection
+  mcp-abap-adt --transport=sse --sse-port=3001 \\
+                --sse-allowed-origins=http://localhost:3000 \\
+                --sse-enable-dns-protection
+
+  # Using shortcuts
+  mcp-abap-adt --http --http-port=8080
+  mcp-abap-adt --sse --sse-port=3001
+
+QUICK REFERENCE:
+  Transport types:
+    http            - HTTP StreamableHTTP transport (default)
+    streamable-http - Same as http
+    stdio           - Standard input/output (for MCP clients, requires .env file)
+    sse             - Server-Sent Events transport
+
+  Common use cases:
+    Web interfaces (HTTP):        mcp-abap-adt (default, no .env needed)
+    MCP clients (Cline, Cursor):  mcp-abap-adt --transport=stdio
+    Web interfaces (SSE):         mcp-abap-adt --transport=sse --sse-port=3001
+
+DOCUMENTATION:
+  https://github.com/fr0ster/mcp-abap-adt
+  Installation:    doc/installation/INSTALLATION.md
+  Configuration:   doc/user-guide/CLIENT_CONFIGURATION.md
+  Available Tools: doc/user-guide/AVAILABLE_TOOLS.md
+
+AUTHENTICATION:
+  For JWT authentication with SAP BTP service keys:
+  1. Install: npm install -g @mcp-abap-adt/connection
+  2. Run:     sap-abap-auth auth -k path/to/service-key.json
+  3. This generates .env file with JWT tokens automatically
+
+`;
+    console.log(help);
+    process.exit(0);
+}
+// Check for version/help flags
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    const packageJsonPath = path_1.default.join(__dirname, "..", "package.json");
+    const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf8"));
+    console.log(packageJson.version);
+    process.exit(0);
+}
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    showHelp();
+}
+/**
+ * Helper to determine transport type early for .env loading logic
+ * Returns the transport type if explicitly specified, or null if not specified
+ *
+ * Auto-detects stdio mode if:
+ * - stdin is not a TTY (piped/redirected, e.g., by MCP Inspector)
+ * - and no explicit transport was specified
+ */
+function getTransportType() {
+    const args = process.argv;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--transport=")) {
+            return arg.split("=")[1].toLowerCase();
+        }
+        if (arg === "--transport" && i + 1 < args.length) {
+            return args[i + 1].toLowerCase();
+        }
+        if (arg === "--http")
+            return "streamable-http";
+        if (arg === "--stdio")
+            return "stdio";
+        if (arg === "--sse")
+            return "sse";
+    }
+    // Check environment variable
+    if (process.env.MCP_TRANSPORT) {
+        return process.env.MCP_TRANSPORT.toLowerCase();
+    }
+    // Auto-detect stdio mode: if stdin is not a TTY, we're likely in stdio mode (piped by MCP Inspector)
+    if (!process.stdin.isTTY) {
+        return "stdio";
+    }
+    // Not explicitly specified
+    return null;
+}
+/**
+ * Parses command line arguments to find env file path
+ * Supports both formats:
+ * 1. --env=/path/to/.env
+ * 2. --env /path/to/.env
+ */
+function parseEnvArg() {
+    const args = process.argv;
+    for (let i = 0; i < args.length; i++) {
+        // Format: --env=/path/to/.env
+        if (args[i].startsWith("--env=")) {
+            return args[i].slice("--env=".length);
+        }
+        // Format: --env /path/to/.env
+        else if (args[i] === "--env" && i + 1 < args.length) {
+            return args[i + 1];
+        }
+    }
+    return undefined;
+}
+// Find .env file path from arguments
+// Skip .env loading if launcher already loaded it
+const skipEnvAutoload = process.env.MCP_SKIP_ENV_LOAD === "true" || process.env.MCP_ENV_LOADED_BY_LAUNCHER === "true";
+const explicitTransportType = getTransportType();
+// If transport not explicitly specified, default to HTTP mode
+// Stdio mode is only used if explicitly specified via --transport=stdio
+const transportType = explicitTransportType || "streamable-http";
+const isHttp = transportType === "http" || transportType === "streamable-http" || transportType === "server";
+const isSse = transportType === "sse";
+const isStdio = transportType === "stdio";
+// .env is mandatory only if transport is explicitly set to stdio or sse
+const isEnvMandatory = explicitTransportType !== null && (isStdio || isSse);
+let envFilePath = parseEnvArg() ?? process.env.MCP_ENV_PATH;
+if (!skipEnvAutoload) {
+    if (!envFilePath) {
+        // Only search in current working directory (where user runs the command)
+        const cwdEnvPath = path_1.default.resolve(process.cwd(), ".env");
+        if (fs_1.default.existsSync(cwdEnvPath)) {
+            envFilePath = cwdEnvPath;
+            // Only write to stderr if not in stdio mode (stdio mode requires clean JSON only)
+            if (!isStdio) {
+                process.stderr.write(`[MCP-ENV] Found .env file: ${envFilePath}\n`);
+            }
+        }
+    }
+    else {
+        // Only write to stderr if not in stdio mode
+        if (!isStdio) {
+            process.stderr.write(`[MCP-ENV] Using .env from argument/env: ${envFilePath}\n`);
+        }
+    }
+    if (envFilePath) {
+        if (!path_1.default.isAbsolute(envFilePath)) {
+            envFilePath = path_1.default.resolve(process.cwd(), envFilePath);
+            // Only write to stderr if not in stdio mode
+            if (!isStdio) {
+                process.stderr.write(`[MCP-ENV] Resolved relative path to: ${envFilePath}\n`);
+            }
+        }
+        if (fs_1.default.existsSync(envFilePath)) {
+            // For stdio mode, load .env manually to avoid any output from dotenv library
+            if (isStdio) {
+                // Manual .env parsing for stdio mode (no library output)
+                try {
+                    const envContent = fs_1.default.readFileSync(envFilePath, "utf8");
+                    const lines = envContent.split(/\r?\n/);
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        // Skip empty lines and comments
+                        if (!trimmed || trimmed.startsWith("#")) {
+                            continue;
+                        }
+                        // Parse KEY=VALUE format
+                        const eqIndex = trimmed.indexOf("=");
+                        if (eqIndex === -1) {
+                            continue;
+                        }
+                        const key = trimmed.substring(0, eqIndex).trim();
+                        let value = trimmed.substring(eqIndex + 1);
+                        // Remove inline comments (everything after #)
+                        // This handles cases like: KEY=value # comment or KEY=value#comment
+                        // Find first # and remove everything after it (including the #)
+                        const commentIndex = value.indexOf('#');
+                        if (commentIndex !== -1) {
+                            // Remove everything from # onwards, then trim trailing whitespace
+                            const beforeComment = value.substring(0, commentIndex);
+                            value = beforeComment.trim();
+                        }
+                        else {
+                            value = value.trim();
+                        }
+                        // Aggressive cleaning for Windows compatibility (same as launcher)
+                        // Step 1: Remove ALL control characters (including \r from Windows line endings)
+                        let unquotedValue = String(value).replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+                        // Step 2: Trim whitespace
+                        unquotedValue = unquotedValue.trim();
+                        // Step 3: Remove quotes (handle nested quotes)
+                        unquotedValue = unquotedValue.replace(/^["']+|["']+$/g, '');
+                        // Step 4: Trim again after quote removal
+                        unquotedValue = unquotedValue.trim();
+                        // Step 5: For URLs specifically, remove trailing slashes
+                        if (key === 'SAP_URL') {
+                            unquotedValue = unquotedValue.replace(/\/+$/, '').trim();
+                            // Debug logging for Windows
+                            if (process.platform === 'win32' && !isStdio) {
+                                process.stderr.write(`[MCP-ENV] Parsed SAP_URL: "${unquotedValue}" (length: ${unquotedValue.length})\n`);
+                            }
+                        }
+                        // Only set if not already in process.env (don't override launcher's cleaned values)
+                        if (key && !process.env[key]) {
+                            process.env[key] = unquotedValue;
+                        }
+                    }
+                }
+                catch (error) {
+                    // Silent fail for stdio mode - just exit
+                    process.exit(1);
+                }
+            }
+            else {
+                // For non-stdio modes, use manual parsing (dotenv removed to avoid stdout pollution)
+                try {
+                    const envContent = fs_1.default.readFileSync(envFilePath, "utf8");
+                    const lines = envContent.split(/\r?\n/);
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith("#")) {
+                            continue;
+                        }
+                        const eqIndex = trimmed.indexOf("=");
+                        if (eqIndex === -1) {
+                            continue;
+                        }
+                        const key = trimmed.substring(0, eqIndex).trim();
+                        let value = trimmed.substring(eqIndex + 1);
+                        // Remove inline comments (everything after #)
+                        // This handles cases like: KEY=value # comment or KEY=value#comment
+                        // Find first # and remove everything after it (including the #)
+                        const commentIndex = value.indexOf('#');
+                        if (commentIndex !== -1) {
+                            // Remove everything from # onwards, then trim trailing whitespace
+                            const beforeComment = value.substring(0, commentIndex);
+                            value = beforeComment.trim();
+                        }
+                        else {
+                            value = value.trim();
+                        }
+                        // Aggressive cleaning for Windows compatibility (same as launcher)
+                        // Step 1: Remove ALL control characters (including \r from Windows line endings)
+                        let unquotedValue = String(value).replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+                        // Step 2: Trim whitespace
+                        unquotedValue = unquotedValue.trim();
+                        // Step 3: Remove quotes (handle nested quotes)
+                        unquotedValue = unquotedValue.replace(/^["']+|["']+$/g, '');
+                        // Step 4: Trim again after quote removal
+                        unquotedValue = unquotedValue.trim();
+                        // Step 5: For URLs specifically, remove trailing slashes
+                        if (key === 'SAP_URL') {
+                            unquotedValue = unquotedValue.replace(/\/+$/, '').trim();
+                            // Debug logging for Windows
+                            if (process.platform === 'win32' && !isStdio) {
+                                process.stderr.write(`[MCP-ENV] Parsed SAP_URL: "${unquotedValue}" (length: ${unquotedValue.length})\n`);
+                            }
+                        }
+                        // Only set if not already in process.env (don't override launcher's cleaned values)
+                        if (key && !process.env[key]) {
+                            process.env[key] = unquotedValue;
+                        }
+                    }
+                    process.stderr.write(`[MCP-ENV] ✓ Successfully loaded: ${envFilePath}\n`);
+                    // Debug: log SAP_URL if loaded (for troubleshooting on Windows)
+                    if (process.env.SAP_URL) {
+                        const urlHex = Buffer.from(process.env.SAP_URL, 'utf8').toString('hex');
+                        process.stderr.write(`[MCP-ENV] SAP_URL loaded: "${process.env.SAP_URL}" (length: ${process.env.SAP_URL.length})\n`);
+                        if (process.platform === 'win32') {
+                            process.stderr.write(`[MCP-ENV] SAP_URL (hex): ${urlHex.substring(0, 60)}...\n`);
+                            // Check for comments
+                            if (process.env.SAP_URL.includes('#')) {
+                                process.stderr.write(`[MCP-ENV] ⚠ WARNING: SAP_URL contains # character (comment not removed?)\n`);
+                            }
+                        }
+                    }
+                    else {
+                        process.stderr.write(`[MCP-ENV] ⚠ WARNING: SAP_URL not found in .env file\n`);
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`[MCP-ENV] ✗ Failed to load: ${envFilePath}\n`);
+                    if (error instanceof Error) {
+                        process.stderr.write(`[MCP-ENV] Error: ${error.message}\n`);
+                    }
+                }
+            }
+        }
+        else {
+            // .env file specified but not found
+            if (isEnvMandatory) {
+                // Always write error to stderr (stderr is safe even in stdio mode, unlike stdout)
+                logger_1.logger.error(".env file not found", { path: envFilePath });
+                process.stderr.write(`[MCP-ENV] ✗ ERROR: .env file not found at: ${envFilePath}\n`);
+                process.stderr.write(`[MCP-ENV]   Current working directory: ${process.cwd()}\n`);
+                process.stderr.write(`[MCP-ENV]   Transport mode '${transportType}' requires .env file.\n`);
+                process.stderr.write(`[MCP-ENV]   Use --env=/path/to/.env to specify custom location\n`);
+                // On Windows, add a small delay before exit to allow error message to be visible
+                if (process.platform === 'win32') {
+                    setTimeout(() => process.exit(1), 100);
+                }
+                else {
+                    process.exit(1);
+                }
+            }
+            else {
+                // Always write error to stderr (stderr is safe even in stdio mode)
+                process.stderr.write(`[MCP-ENV] ✗ ERROR: .env file not found at: ${envFilePath}\n`);
+                process.stderr.write(`[MCP-ENV]   Transport mode '${transportType}' was explicitly specified but .env file is missing.\n`);
+                process.stderr.write(`[MCP-ENV]   Use --env=/path/to/.env to specify custom location\n`);
+                // On Windows, add a small delay before exit to allow error message to be visible
+                if (process.platform === 'win32') {
+                    setTimeout(() => process.exit(1), 100);
+                }
+                else {
+                    process.exit(1);
+                }
+            }
+        }
+    }
+    else {
+        // No .env file found and none specified
+        if (isEnvMandatory) {
+            // Transport explicitly set to stdio/sse but no .env found
+            const cwdEnvPath = path_1.default.resolve(process.cwd(), ".env");
+            // Always write error to stderr (stderr is safe even in stdio mode)
+            logger_1.logger.error(".env file not found", { path: cwdEnvPath });
+            process.stderr.write(`[MCP-ENV] ✗ ERROR: .env file not found in current directory: ${process.cwd()}\n`);
+            process.stderr.write(`[MCP-ENV]   Transport mode '${transportType}' requires .env file.\n`);
+            process.stderr.write(`[MCP-ENV]   Use --env=/path/to/.env to specify custom location\n`);
+            // On Windows, add a small delay before exit to allow error message to be visible
+            if (process.platform === 'win32') {
+                setTimeout(() => process.exit(1), 100);
+            }
+            else {
+                process.exit(1);
+            }
+        }
+        else {
+            // No .env found, but transport is HTTP (default) - this is OK
+            if (explicitTransportType === null) {
+                // Transport not specified, defaulting to HTTP mode
+                // For stdio mode, don't write to stderr
+                if (!isStdio) {
+                    process.stderr.write(`[MCP-ENV] NOTE: No .env file found in current directory: ${process.cwd()}\n`);
+                    process.stderr.write(`[MCP-ENV]   Starting in HTTP mode (no .env file required)\n`);
+                }
+            }
+            else {
+                // Transport explicitly set to HTTP - this is OK
+                // For stdio mode, don't write to stderr
+                if (!isStdio) {
+                    process.stderr.write(`[MCP-ENV] NOTE: No .env file found, continuing in ${transportType} mode\n`);
+                }
+            }
+        }
+    }
+}
+else if (envFilePath) {
+    if (!path_1.default.isAbsolute(envFilePath)) {
+        envFilePath = path_1.default.resolve(process.cwd(), envFilePath);
+    }
+    // For stdio mode, don't write to stderr
+    if (!isStdio) {
+        process.stderr.write(`[MCP-ENV] Environment autoload skipped; using provided path reference: ${envFilePath}\n`);
+    }
+}
+else {
+    // For stdio mode, don't write to stderr
+    if (!isStdio) {
+        process.stderr.write(`[MCP-ENV] Environment autoload skipped (MCP_SKIP_ENV_LOAD=true).\n`);
+    }
+}
+// --- END ENV FILE LOADING LOGIC ---
+// Debug: Log loaded SAP_URL and SAP_CLIENT using the MCP-compatible logger
+// Skip logging in stdio mode (MCP protocol requires clean JSON only)
+if (!isStdio) {
+    const envLogPath = envFilePath ?? "(skipped)";
+    logger_1.logger.info("SAP configuration loaded", {
+        type: "CONFIG_INFO",
+        SAP_URL: process.env.SAP_URL,
+        SAP_CLIENT: process.env.SAP_CLIENT || "(not set)",
+        SAP_AUTH_TYPE: process.env.SAP_AUTH_TYPE || "(not set)",
+        SAP_JWT_TOKEN: process.env.SAP_JWT_TOKEN ? "[set]" : "(not set)",
+        ENV_PATH: envLogPath,
+        CWD: process.cwd(),
+        DIRNAME: __dirname,
+        TRANSPORT: transportType
+    });
+}
+function getArgValue(name) {
+    const args = process.argv;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith(`${name}=`)) {
+            return arg.slice(name.length + 1);
+        }
+        if (arg === name && i + 1 < args.length) {
+            return args[i + 1];
+        }
+    }
+    return undefined;
+}
+function hasFlag(name) {
+    return process.argv.includes(name);
+}
+function parseBoolean(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function resolvePortOption(argName, envName, defaultValue) {
+    const rawValue = getArgValue(argName) ?? process.env[envName];
+    if (!rawValue) {
+        return defaultValue;
+    }
+    const port = Number.parseInt(rawValue, 10);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error(`Invalid port value for ${argName}: ${rawValue}`);
+    }
+    return port;
+}
+function resolveBooleanOption(argName, envName, defaultValue) {
+    const argValue = getArgValue(argName);
+    if (argValue !== undefined) {
+        return parseBoolean(argValue);
+    }
+    if (hasFlag(argName)) {
+        return true;
+    }
+    const envValue = process.env[envName];
+    if (envValue !== undefined) {
+        return parseBoolean(envValue);
+    }
+    return defaultValue;
+}
+function resolveListOption(argName, envName) {
+    const rawValue = getArgValue(argName) ?? process.env[envName];
+    if (!rawValue) {
+        return undefined;
+    }
+    const items = rawValue
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return items.length > 0 ? items : undefined;
+}
+function parseTransportConfig() {
+    // Use the transport type we already determined (handles explicit args, env vars, and defaults)
+    const normalized = transportType;
+    if (normalized &&
+        normalized !== "stdio" &&
+        normalized !== "http" &&
+        normalized !== "streamable-http" &&
+        normalized !== "server" &&
+        normalized !== "sse") {
+        throw new Error(`Unsupported transport: ${normalized}`);
+    }
+    const sseRequested = normalized === "sse" ||
+        hasFlag("--sse");
+    if (sseRequested) {
+        const port = resolvePortOption("--sse-port", "MCP_SSE_PORT", 3001);
+        const host = getArgValue("--sse-host") ?? process.env.MCP_SSE_HOST ?? "0.0.0.0";
+        const allowedOrigins = resolveListOption("--sse-allowed-origins", "MCP_SSE_ALLOWED_ORIGINS");
+        const allowedHosts = resolveListOption("--sse-allowed-hosts", "MCP_SSE_ALLOWED_HOSTS");
+        const enableDnsRebindingProtection = resolveBooleanOption("--sse-enable-dns-protection", "MCP_SSE_ENABLE_DNS_PROTECTION", false);
+        return {
+            type: "sse",
+            host,
+            port,
+            allowedOrigins,
+            allowedHosts,
+            enableDnsRebindingProtection,
+        };
+    }
+    const httpRequested = normalized === "http" ||
+        normalized === "streamable-http" ||
+        normalized === "server" ||
+        hasFlag("--http") ||
+        // Default to HTTP if not stdio/sse
+        (!sseRequested && normalized !== "stdio");
+    if (httpRequested) {
+        const port = resolvePortOption("--http-port", "MCP_HTTP_PORT", 3000);
+        const host = getArgValue("--http-host") ?? process.env.MCP_HTTP_HOST ?? "0.0.0.0";
+        const enableJsonResponse = resolveBooleanOption("--http-json-response", "MCP_HTTP_ENABLE_JSON_RESPONSE", false);
+        const allowedOrigins = resolveListOption("--http-allowed-origins", "MCP_HTTP_ALLOWED_ORIGINS");
+        const allowedHosts = resolveListOption("--http-allowed-hosts", "MCP_HTTP_ALLOWED_HOSTS");
+        const enableDnsRebindingProtection = resolveBooleanOption("--http-enable-dns-protection", "MCP_HTTP_ENABLE_DNS_PROTECTION", false);
+        return {
+            type: "streamable-http",
+            host,
+            port,
+            enableJsonResponse,
+            allowedOrigins,
+            allowedHosts,
+            enableDnsRebindingProtection,
+        };
+    }
+    return { type: "stdio" };
+}
+let sapConfigOverride;
+function setSapConfigOverride(config) {
+    sapConfigOverride = config;
+    (0, utils_1.setConfigOverride)(config);
+}
+function setAbapConnectionOverride(connection) {
+    (0, utils_1.setConnectionOverride)(connection);
+}
+/**
+ * Retrieves SAP configuration from environment variables.
+ * Reads configuration from process.env (caller is responsible for loading .env file if needed).
+ *
+ * @returns {SapConfig} The SAP configuration object.
+ * @throws {Error} If any required environment variable is missing.
+ */
+// Helper function for Windows-compatible logging
+function debugLog(message) {
+    // Try stderr first
+    try {
+        process.stderr.write(message);
+    }
+    catch (e) {
+        // Fallback to console.error for Windows
+        console.error(message.trim());
+    }
+    // Also try to write to a debug file on Windows
+    if (process.platform === 'win32') {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const debugFile = path.join(process.cwd(), 'mcp-debug.log');
+            fs.appendFileSync(debugFile, `${new Date().toISOString()} ${message}`, 'utf8');
+        }
+        catch (e) {
+            // Ignore file write errors
+        }
+    }
+}
+function getConfig() {
+    debugLog(`[MCP-CONFIG] getConfig() called\n`);
+    if (sapConfigOverride) {
+        debugLog(`[MCP-CONFIG] Using override config\n`);
+        return sapConfigOverride;
+    }
+    // Read from process.env (already loaded and cleaned by launcher or at startup)
+    // No need to reload .env here - it's already in process.env
+    let url = process.env.SAP_URL;
+    let client = process.env.SAP_CLIENT;
+    debugLog(`[MCP-CONFIG] Raw process.env.SAP_URL: "${url}" (type: ${typeof url}, length: ${url?.length || 0})\n`);
+    // Final cleaning for Windows compatibility (in case values weren't cleaned properly)
+    // This is a safety net, not a reload
+    if (url) {
+        const originalUrl = url;
+        // Remove inline comments (safety net - should already be removed)
+        const commentIndex = url.indexOf('#');
+        if (commentIndex !== -1) {
+            url = url.substring(0, commentIndex).trim();
+            // Log if comment was found (indicates .env parsing issue)
+            debugLog(`[MCP-CONFIG] ⚠ Found comment in URL, removed: "${originalUrl}" → "${url}"\n`);
+        }
+        // Remove ALL control characters (safety net)
+        url = String(url).replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+        url = url.trim();
+        // Remove quotes (safety net)
+        url = url.replace(/^["']+|["']+$/g, '');
+        url = url.trim();
+        // Remove trailing slashes
+        url = url.replace(/\/+$/, '');
+        url = url.trim();
+        // Log cleaned URL for debugging (always, not just Windows)
+        if (url !== originalUrl) {
+            const urlHex = Buffer.from(url, 'utf8').toString('hex');
+            debugLog(`[MCP-CONFIG] Cleaned URL: "${url}" (length: ${url.length}, hex: ${urlHex.substring(0, 60)}...)\n`);
+        }
+    }
+    else {
+        // Log if URL is missing
+        debugLog(`[MCP-CONFIG] ✗ SAP_URL is missing from process.env\n`);
+        debugLog(`[MCP-CONFIG] Available env vars: ${Object.keys(process.env).filter(k => k.startsWith('SAP_')).join(', ')}\n`);
+    }
+    if (client) {
+        client = client.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        client = client.replace(/^["']|["']$/g, '');
+    }
+    // Auto-detect auth type: if JWT token is present, use JWT; otherwise check SAP_AUTH_TYPE or default to basic
+    let authType = 'basic';
+    if (process.env.SAP_JWT_TOKEN) {
+        authType = 'jwt';
+    }
+    else if (process.env.SAP_AUTH_TYPE) {
+        const rawAuthType = process.env.SAP_AUTH_TYPE.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        authType = rawAuthType === 'xsuaa' ? 'jwt' : rawAuthType;
+    }
+    if (!url) {
+        throw new Error(`Missing SAP_URL in environment variables. Please check your .env file.`);
+    }
+    // Final validation - URL should be clean now
+    if (!/^https?:\/\//.test(url)) {
+        // Log URL in hex for debugging
+        const urlHex = Buffer.from(url, 'utf8').toString('hex');
+        throw new Error(`Invalid SAP_URL format: "${url}" (hex: ${urlHex.substring(0, 100)}...). Expected format: https://your-system.sap.com`);
+    }
+    // Additional validation: try to create URL object to catch any remaining issues
+    try {
+        const testUrl = new URL(url);
+        // If URL object creation succeeds, use the normalized URL
+        url = testUrl.href.replace(/\/$/, ''); // Remove trailing slash if present
+    }
+    catch (urlError) {
+        const urlHex = Buffer.from(url, 'utf8').toString('hex');
+        throw new Error(`Invalid SAP_URL: "${url}" (hex: ${urlHex.substring(0, 100)}...). Error: ${urlError instanceof Error ? urlError.message : urlError}`);
+    }
+    // Log cleaned URL for debugging (always)
+    const cleanedUrlHex = Buffer.from(url, 'utf8').toString('hex');
+    debugLog(`[MCP-CONFIG] Final SAP_URL: "${url}" (length: ${url.length}, hex: ${cleanedUrlHex.substring(0, 60)}...)\n`);
+    // Verify URL is clean
+    if (url.includes('#')) {
+        debugLog(`[MCP-CONFIG] ✗ ERROR: URL still contains # character!\n`);
+    }
+    if (/[\x00-\x1F\x7F-\x9F]/.test(url)) {
+        debugLog(`[MCP-CONFIG] ✗ ERROR: URL still contains control characters!\n`);
+    }
+    const config = {
+        url, // Already cleaned and validated above
+        authType,
+    };
+    if (client) {
+        config.client = client;
+    }
+    if (authType === 'jwt') {
+        const jwtToken = process.env.SAP_JWT_TOKEN;
+        if (!jwtToken) {
+            throw new Error('Missing SAP_JWT_TOKEN for JWT authentication');
+        }
+        // Clean JWT token (remove control characters)
+        config.jwtToken = jwtToken.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        const refreshToken = process.env.SAP_REFRESH_TOKEN;
+        if (refreshToken) {
+            config.refreshToken = refreshToken.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        }
+        const uaaUrl = process.env.SAP_UAA_URL || process.env.UAA_URL;
+        const uaaClientId = process.env.SAP_UAA_CLIENT_ID || process.env.UAA_CLIENT_ID;
+        const uaaClientSecret = process.env.SAP_UAA_CLIENT_SECRET || process.env.UAA_CLIENT_SECRET;
+        if (uaaUrl)
+            config.uaaUrl = uaaUrl.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        if (uaaClientId)
+            config.uaaClientId = uaaClientId.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        if (uaaClientSecret)
+            config.uaaClientSecret = uaaClientSecret.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+    }
+    else {
+        const username = process.env.SAP_USERNAME;
+        const password = process.env.SAP_PASSWORD;
+        if (!username || !password) {
+            throw new Error('Missing SAP_USERNAME or SAP_PASSWORD for basic authentication');
+        }
+        // Clean username and password (remove control characters)
+        config.username = username.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+        config.password = password.replace(/[\x00-\x1F\x7F-\x9F]/g, '').trim();
+    }
+    return config;
+}
+/**
+ * Server class for interacting with ABAP systems via ADT.
+ */
+class mcp_abap_adt_server {
+    allowProcessExit;
+    registerSignalHandlers;
+    mcpServer; // MCP server for all transports
+    sapConfig; // SAP configuration
+    hasEnvFile; // Track if .env file was found at startup
+    transportConfig;
+    httpServer;
+    shuttingDown = false;
+    // Client session tracking for StreamableHTTP (like the example)
+    streamableHttpSessions = new Map();
+    // SSE session tracking (McpServer + SSEServerTransport per session)
+    sseSessions = new Map();
+    applyAuthHeaders(headers, sessionId) {
+        if (!headers) {
+            return;
+        }
+        const getHeaderValue = (value) => {
+            if (!value) {
+                return undefined;
+            }
+            return Array.isArray(value) ? value[0] : value;
+        };
+        // Extract SAP URL and auth type from headers
+        const sapUrl = getHeaderValue(headers["x-sap-url"])?.trim();
+        const sapAuthType = getHeaderValue(headers["x-sap-auth-type"])?.trim();
+        // If no URL or auth type, skip processing
+        if (!sapUrl || !sapAuthType) {
+            return;
+        }
+        const isJwtAuth = sapAuthType === "jwt" || sapAuthType === "xsuaa";
+        const isBasicAuth = sapAuthType === "basic";
+        // Process JWT authentication
+        if (isJwtAuth) {
+            // Extract JWT token - required for JWT auth
+            const jwtToken = getHeaderValue(headers["x-sap-jwt-token"])?.trim();
+            if (!jwtToken) {
+                return; // JWT token is required for JWT authentication
+            }
+            // Extract refresh token - optional for JWT auth
+            const refreshToken = getHeaderValue(headers["x-sap-refresh-token"]);
+            // Process JWT config update
+            this.processJwtConfigUpdate(sapUrl, jwtToken, refreshToken, sessionId);
+            return;
+        }
+        // Process basic authentication
+        if (isBasicAuth) {
+            // Extract username and password - required for basic auth
+            const username = getHeaderValue(headers["x-sap-login"])?.trim();
+            const password = getHeaderValue(headers["x-sap-password"])?.trim();
+            if (!username || !password) {
+                return; // Username and password are required for basic authentication
+            }
+            // Process basic auth config update
+            this.processBasicAuthConfigUpdate(sapUrl, username, password, sessionId);
+            return;
+        }
+    }
+    processJwtConfigUpdate(sapUrl, jwtToken, refreshToken, sessionId) {
+        const sanitizeToken = (token) => token.length <= 10 ? token : `${token.substring(0, 6)}…${token.substring(token.length - 4)}`;
+        let baseConfig = this.sapConfig;
+        if (!baseConfig || baseConfig.url === "http://placeholder") {
+            try {
+                baseConfig = getConfig();
+            }
+            catch (error) {
+                logger_1.logger.warn("Failed to load base SAP config when applying headers", {
+                    type: "SAP_CONFIG_HEADER_APPLY_FAILED",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                baseConfig = {
+                    url: sapUrl,
+                    authType: "jwt",
+                };
+            }
+        }
+        // Check if any configuration changed
+        const urlChanged = sapUrl !== baseConfig.url;
+        const authTypeChanged = "jwt" !== baseConfig.authType;
+        const tokenChanged = baseConfig.jwtToken !== jwtToken ||
+            (!!refreshToken && refreshToken.trim() !== baseConfig.refreshToken);
+        if (!urlChanged && !authTypeChanged && !tokenChanged) {
+            return;
+        }
+        const newConfig = {
+            ...baseConfig,
+            url: sapUrl,
+            authType: "jwt",
+            jwtToken,
+        };
+        if (refreshToken && refreshToken.trim()) {
+            newConfig.refreshToken = refreshToken.trim();
+        }
+        setSapConfigOverride(newConfig);
+        this.sapConfig = newConfig;
+        // Store config in session if sessionId is provided
+        if (sessionId) {
+            const session = this.streamableHttpSessions.get(sessionId);
+            if (session) {
+                session.sapConfig = newConfig;
+            }
+        }
+        // Force connection cache invalidation (for backward compatibility)
+        const { invalidateConnectionCache } = require('./lib/utils');
+        try {
+            invalidateConnectionCache();
+        }
+        catch (error) {
+            logger_1.logger.debug("Connection cache invalidation failed", {
+                type: "CONNECTION_CACHE_INVALIDATION_FAILED",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        logger_1.logger.info("Updated SAP configuration from HTTP headers (JWT)", {
+            type: "SAP_CONFIG_UPDATED",
+            urlChanged: Boolean(urlChanged),
+            authTypeChanged: Boolean(authTypeChanged),
+            tokenChanged: Boolean(tokenChanged),
+            hasRefreshToken: Boolean(refreshToken),
+            jwtPreview: sanitizeToken(jwtToken),
+            sessionId: sessionId?.substring(0, 8),
+        });
+    }
+    processBasicAuthConfigUpdate(sapUrl, username, password, sessionId) {
+        let baseConfig = this.sapConfig;
+        if (!baseConfig || baseConfig.url === "http://placeholder") {
+            try {
+                baseConfig = getConfig();
+            }
+            catch (error) {
+                logger_1.logger.warn("Failed to load base SAP config when applying headers", {
+                    type: "SAP_CONFIG_HEADER_APPLY_FAILED",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                baseConfig = {
+                    url: sapUrl,
+                    authType: "basic",
+                };
+            }
+        }
+        // Check if any configuration changed
+        const urlChanged = sapUrl !== baseConfig.url;
+        const authTypeChanged = "basic" !== baseConfig.authType;
+        const credentialsChanged = baseConfig.username !== username ||
+            baseConfig.password !== password;
+        if (!urlChanged && !authTypeChanged && !credentialsChanged) {
+            return;
+        }
+        const newConfig = {
+            ...baseConfig,
+            url: sapUrl,
+            authType: "basic",
+            username,
+            password,
+        };
+        setSapConfigOverride(newConfig);
+        this.sapConfig = newConfig;
+        // Store config in session if sessionId is provided
+        if (sessionId) {
+            const session = this.streamableHttpSessions.get(sessionId);
+            if (session) {
+                session.sapConfig = newConfig;
+            }
+        }
+        // Force connection cache invalidation (for backward compatibility)
+        const { invalidateConnectionCache } = require('./lib/utils');
+        try {
+            invalidateConnectionCache();
+        }
+        catch (error) {
+            logger_1.logger.debug("Connection cache invalidation failed", {
+                type: "CONNECTION_CACHE_INVALIDATION_FAILED",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        logger_1.logger.info("Updated SAP configuration from HTTP headers (Basic)", {
+            type: "SAP_CONFIG_UPDATED",
+            urlChanged: Boolean(urlChanged),
+            authTypeChanged: Boolean(authTypeChanged),
+            credentialsChanged: Boolean(credentialsChanged),
+            hasUsername: Boolean(username),
+            sessionId: sessionId?.substring(0, 8),
+        });
+    }
+    /**
+     * Check if connection is from localhost
+     */
+    isLocalConnection(remoteAddress) {
+        if (!remoteAddress) {
+            return false;
+        }
+        // Check for IPv4 localhost
+        if (remoteAddress === "127.0.0.1" || remoteAddress === "localhost") {
+            return true;
+        }
+        // Check for IPv6 localhost
+        if (remoteAddress === "::1" || remoteAddress === "::ffff:127.0.0.1") {
+            return true;
+        }
+        // Check if it's a loopback interface
+        if (remoteAddress.startsWith("127.") || remoteAddress.startsWith("::1")) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if request has SAP connection headers
+     */
+    hasSapHeaders(headers) {
+        if (!headers) {
+            return false;
+        }
+        const sapUrl = headers["x-sap-url"];
+        const sapAuthType = headers["x-sap-auth-type"];
+        return !!(sapUrl && sapAuthType);
+    }
+    /**
+     * Constructor for the mcp_abap_adt_server class.
+     */
+    constructor(options) {
+        this.allowProcessExit = options?.allowProcessExit ?? true;
+        this.registerSignalHandlers = options?.registerSignalHandlers ?? true;
+        // Check if .env file exists (was loaded at startup)
+        // This is used to determine if we should restrict non-local connections
+        this.hasEnvFile = fs_1.default.existsSync(envFilePath || path_1.default.resolve(process.cwd(), ".env"));
+        if (options?.connection) {
+            setAbapConnectionOverride(options.connection);
+        }
+        else {
+            setAbapConnectionOverride(undefined);
+        }
+        if (!options?.connection) {
+            setSapConfigOverride(options?.sapConfig);
+        }
+        // CHANGED: Don't validate config in constructor - will validate on actual ABAP requests
+        // This allows creating server instance without .env file when using runtime config (e.g., from HTTP headers)
+        try {
+            if (options?.sapConfig) {
+                this.sapConfig = options.sapConfig;
+            }
+            else if (!options?.connection) {
+                // Try to get config, but don't fail if it's invalid - server should still initialize
+                // Invalid config will be caught when handlers try to use it
+                try {
+                    this.sapConfig = getConfig();
+                }
+                catch (configError) {
+                    // For stdio mode, we want the server to initialize even with invalid config
+                    // The error will be shown when user tries to use a tool
+                    // Check stdio mode using environment variable or stdin check (transportConfig not set yet)
+                    const isStdioMode = process.env.MCP_TRANSPORT === "stdio" || !process.stdin.isTTY;
+                    if (isStdioMode) {
+                        // In stdio mode, write error to stderr (safe for MCP protocol)
+                        process.stderr.write(`[MCP] ⚠ WARNING: Invalid SAP configuration: ${configError instanceof Error ? configError.message : String(configError)}\n`);
+                        process.stderr.write(`[MCP]   Server will start, but tools will fail until configuration is fixed.\n`);
+                    }
+                    logger_1.logger.warn("SAP config invalid at initialization, will use placeholder", {
+                        type: "CONFIG_INVALID",
+                        error: configError instanceof Error ? configError.message : String(configError),
+                    });
+                    // Set a placeholder that will be replaced when valid config is provided
+                    this.sapConfig = { url: "http://placeholder", authType: "jwt", jwtToken: "placeholder" };
+                }
+            }
+            else {
+                this.sapConfig = { url: "http://injected-connection", authType: "jwt", jwtToken: "injected" };
+            }
+        }
+        catch (error) {
+            // If config is not available yet, that's OK - it will be provided later via setSapConfigOverride or DI
+            logger_1.logger.warn("SAP config not available at initialization, will use runtime config", {
+                type: "CONFIG_DEFERRED",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Set a placeholder that will be replaced
+            this.sapConfig = { url: "http://placeholder", authType: "jwt", jwtToken: "placeholder" };
+        }
+        try {
+            this.transportConfig = options?.transportConfig ?? parseTransportConfig();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Always write error to stderr (stderr is safe even in stdio mode)
+            logger_1.logger.error("Failed to parse transport configuration", {
+                type: "TRANSPORT_CONFIG_ERROR",
+                error: message,
+            });
+            process.stderr.write(`[MCP] ✗ ERROR: Failed to parse transport configuration: ${message}\n`);
+            if (this.allowProcessExit) {
+                // On Windows, add a small delay before exit to allow error message to be visible
+                if (process.platform === 'win32') {
+                    setTimeout(() => process.exit(1), 100);
+                }
+                else {
+                    process.exit(1);
+                }
+            }
+            throw error instanceof Error ? error : new Error(message);
+        }
+        // Create McpServer (for all transports)
+        this.mcpServer = new mcp_js_1.McpServer({
+            name: "mcp-abap-adt",
+            version: "0.1.0"
+        });
+        this.setupMcpServerHandlers(); // Setup handlers for McpServer
+        if (this.registerSignalHandlers) {
+            this.setupSignalHandlers();
+        }
+        if (this.transportConfig.type === "streamable-http") {
+            logger_1.logger.info("Transport configured", {
+                type: "TRANSPORT_CONFIG",
+                transport: this.transportConfig.type,
+                host: this.transportConfig.host,
+                port: this.transportConfig.port,
+                enableJsonResponse: this.transportConfig.enableJsonResponse,
+                allowedOrigins: this.transportConfig.allowedOrigins ?? [],
+                allowedHosts: this.transportConfig.allowedHosts ?? [],
+                enableDnsRebindingProtection: this.transportConfig.enableDnsRebindingProtection,
+            });
+        }
+        else if (this.transportConfig.type === "sse") {
+            logger_1.logger.info("Transport configured", {
+                type: "TRANSPORT_CONFIG",
+                transport: this.transportConfig.type,
+                host: this.transportConfig.host,
+                port: this.transportConfig.port,
+                allowedOrigins: this.transportConfig.allowedOrigins ?? [],
+                allowedHosts: this.transportConfig.allowedHosts ?? [],
+                enableDnsRebindingProtection: this.transportConfig.enableDnsRebindingProtection,
+            });
+        }
+        else {
+            logger_1.logger.info("Transport configured", {
+                type: "TRANSPORT_CONFIG",
+                transport: this.transportConfig.type,
+            });
+        }
+    }
+    /**
+     * Creates a new McpServer instance with all handlers registered
+     * Used for SSE sessions where each session needs its own server instance
+     * @private
+     */
+    createMcpServerForSession() {
+        const server = new mcp_js_1.McpServer({
+            name: "mcp-abap-adt",
+            version: "0.1.0"
+        });
+        // Register all tools using the same method as main server
+        this.registerAllToolsOnServer(server);
+        return server;
+    }
+    /**
+     * Converts JSON Schema to Zod schema object (not z.object(), but object with Zod fields)
+     * SDK expects inputSchema to be an object with Zod schemas as values, not z.object()
+     */
+    jsonSchemaToZod(jsonSchema) {
+        // If already a Zod schema object (object with Zod fields), return as-is
+        if (jsonSchema && typeof jsonSchema === 'object' && !jsonSchema.type && !jsonSchema.properties) {
+            // Check if it looks like a Zod schema object (has Zod types as values)
+            const firstValue = Object.values(jsonSchema)[0];
+            if (firstValue && (firstValue.def || firstValue._def || typeof firstValue.parse === 'function')) {
+                return jsonSchema;
+            }
+        }
+        // If it's a JSON Schema object
+        if (jsonSchema && typeof jsonSchema === 'object' && jsonSchema.type === 'object' && jsonSchema.properties) {
+            const zodShape = {};
+            const required = jsonSchema.required || [];
+            for (const [key, prop] of Object.entries(jsonSchema.properties)) {
+                const propSchema = prop;
+                let zodType;
+                if (propSchema.type === 'string') {
+                    if (propSchema.enum && Array.isArray(propSchema.enum) && propSchema.enum.length > 0) {
+                        // Use z.enum() for enum values (requires at least 1 element, but z.enum needs 2+)
+                        if (propSchema.enum.length === 1) {
+                            zodType = z.literal(propSchema.enum[0]);
+                        }
+                        else {
+                            zodType = z.enum(propSchema.enum);
+                        }
+                    }
+                    else {
+                        zodType = z.string();
+                    }
+                }
+                else if (propSchema.type === 'number' || propSchema.type === 'integer') {
+                    zodType = z.number();
+                }
+                else if (propSchema.type === 'boolean') {
+                    zodType = z.boolean();
+                }
+                else if (propSchema.type === 'array') {
+                    const items = propSchema.items;
+                    if (items?.type === 'string') {
+                        zodType = z.array(z.string());
+                    }
+                    else if (items?.type === 'number' || items?.type === 'integer') {
+                        zodType = z.array(z.number());
+                    }
+                    else if (items?.type === 'boolean') {
+                        zodType = z.array(z.boolean());
+                    }
+                    else if (items?.type === 'object' && items.properties) {
+                        // For nested objects in arrays, create object schema
+                        const nestedShape = {};
+                        const nestedRequired = items.required || [];
+                        for (const [nestedKey, nestedProp] of Object.entries(items.properties)) {
+                            const nestedPropSchema = nestedProp;
+                            let nestedZodType;
+                            if (nestedPropSchema.type === 'string') {
+                                if (nestedPropSchema.enum && Array.isArray(nestedPropSchema.enum) && nestedPropSchema.enum.length > 0) {
+                                    if (nestedPropSchema.enum.length === 1) {
+                                        nestedZodType = z.literal(nestedPropSchema.enum[0]);
+                                    }
+                                    else {
+                                        nestedZodType = z.enum(nestedPropSchema.enum);
+                                    }
+                                }
+                                else {
+                                    nestedZodType = z.string();
+                                }
+                            }
+                            else if (nestedPropSchema.type === 'number' || nestedPropSchema.type === 'integer') {
+                                nestedZodType = z.number();
+                            }
+                            else if (nestedPropSchema.type === 'boolean') {
+                                nestedZodType = z.boolean();
+                            }
+                            else {
+                                nestedZodType = z.any();
+                            }
+                            if (nestedPropSchema.default !== undefined) {
+                                nestedZodType = nestedZodType.default(nestedPropSchema.default);
+                            }
+                            if (!nestedRequired.includes(nestedKey)) {
+                                nestedZodType = nestedZodType.optional();
+                            }
+                            if (nestedPropSchema.description) {
+                                nestedZodType = nestedZodType.describe(nestedPropSchema.description);
+                            }
+                            nestedShape[nestedKey] = nestedZodType;
+                        }
+                        zodType = z.array(z.object(nestedShape));
+                    }
+                    else {
+                        zodType = z.array(z.any());
+                    }
+                }
+                else if (propSchema.type === 'object' && propSchema.properties) {
+                    // For nested objects, create object schema
+                    const nestedShape = {};
+                    const nestedRequired = propSchema.required || [];
+                    for (const [nestedKey, nestedProp] of Object.entries(propSchema.properties)) {
+                        const nestedPropSchema = nestedProp;
+                        let nestedZodType;
+                        if (nestedPropSchema.type === 'string') {
+                            if (nestedPropSchema.enum && Array.isArray(nestedPropSchema.enum)) {
+                                nestedZodType = z.enum(nestedPropSchema.enum);
+                            }
+                            else {
+                                nestedZodType = z.string();
+                            }
+                        }
+                        else if (nestedPropSchema.type === 'number' || nestedPropSchema.type === 'integer') {
+                            nestedZodType = z.number();
+                        }
+                        else if (nestedPropSchema.type === 'boolean') {
+                            nestedZodType = z.boolean();
+                        }
+                        else {
+                            nestedZodType = z.any();
+                        }
+                        if (nestedPropSchema.default !== undefined) {
+                            nestedZodType = nestedZodType.default(nestedPropSchema.default);
+                        }
+                        if (!nestedRequired.includes(nestedKey)) {
+                            nestedZodType = nestedZodType.optional();
+                        }
+                        if (nestedPropSchema.description) {
+                            nestedZodType = nestedZodType.describe(nestedPropSchema.description);
+                        }
+                        nestedShape[nestedKey] = nestedZodType;
+                    }
+                    zodType = z.object(nestedShape);
+                }
+                else {
+                    zodType = z.any();
+                }
+                // Add default value if present (before optional)
+                if (propSchema.default !== undefined) {
+                    zodType = zodType.default(propSchema.default);
+                }
+                // Make optional if not in required array (must be after default, before describe)
+                if (!required.includes(key)) {
+                    zodType = zodType.optional();
+                }
+                // Add description if present (after optional)
+                if (propSchema.description) {
+                    zodType = zodType.describe(propSchema.description);
+                }
+                zodShape[key] = zodType;
+            }
+            // Return object with Zod fields, not z.object()
+            return zodShape;
+        }
+        // Fallback: if it's already a Zod schema object, return as-is
+        if (jsonSchema && typeof jsonSchema === 'object' && !jsonSchema.type) {
+            return jsonSchema;
+        }
+        // Fallback: return empty object for unknown schemas
+        return {};
+    }
+    /**
+     * Helper function to register a tool on McpServer
+     * Wraps handler to convert our response format to MCP format
+     */
+    registerToolOnServer(server, toolName, description, inputSchema, handler) {
+        // Convert JSON Schema to Zod if needed, otherwise pass as-is (like in the example)
+        const zodSchema = (inputSchema && typeof inputSchema === 'object' && inputSchema.type === 'object' && inputSchema.properties)
+            ? this.jsonSchemaToZod(inputSchema)
+            : inputSchema;
+        server.registerTool(toolName, {
+            description,
+            inputSchema: zodSchema,
+        }, async (args) => {
+            const result = await handler(args);
+            // If error, throw it
+            if (result.isError) {
+                const errorText = result.content
+                    ?.map((item) => {
+                    if (item?.type === "json" && item.json !== undefined) {
+                        return JSON.stringify(item.json);
+                    }
+                    return item?.text || String(item);
+                })
+                    .join("\n") || "Unknown error";
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, errorText);
+            }
+            // Convert content to MCP format - JSON items become text
+            const content = (result.content || []).map((item) => {
+                if (item?.type === "json" && item.json !== undefined) {
+                    return {
+                        type: "text",
+                        text: JSON.stringify(item.json),
+                    };
+                }
+                return {
+                    type: "text",
+                    text: item?.text || String(item || ""),
+                };
+            });
+            return { content };
+        });
+    }
+    /**
+     * Registers all tools on a McpServer instance
+     * Used for both main server and per-session servers
+     */
+    registerAllToolsOnServer(server) {
+        this.registerToolOnServer(server, handleGetProgram_2.TOOL_DEFINITION.name, handleGetProgram_2.TOOL_DEFINITION.description, handleGetProgram_2.TOOL_DEFINITION.inputSchema, handleGetProgram_1.handleGetProgram);
+        this.registerToolOnServer(server, handleGetClass_2.TOOL_DEFINITION.name, handleGetClass_2.TOOL_DEFINITION.description, handleGetClass_2.TOOL_DEFINITION.inputSchema, handleGetClass_1.handleGetClass);
+        this.registerToolOnServer(server, handleGetFunction_2.TOOL_DEFINITION.name, handleGetFunction_2.TOOL_DEFINITION.description, handleGetFunction_2.TOOL_DEFINITION.inputSchema, handleGetFunction_1.handleGetFunction);
+        this.registerToolOnServer(server, handleGetFunctionGroup_2.TOOL_DEFINITION.name, handleGetFunctionGroup_2.TOOL_DEFINITION.description, handleGetFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleGetFunctionGroup_1.handleGetFunctionGroup);
+        this.registerToolOnServer(server, handleGetTable_2.TOOL_DEFINITION.name, handleGetTable_2.TOOL_DEFINITION.description, handleGetTable_2.TOOL_DEFINITION.inputSchema, handleGetTable_1.handleGetTable);
+        this.registerToolOnServer(server, handleGetStructure_2.TOOL_DEFINITION.name, handleGetStructure_2.TOOL_DEFINITION.description, handleGetStructure_2.TOOL_DEFINITION.inputSchema, handleGetStructure_1.handleGetStructure);
+        this.registerToolOnServer(server, handleGetTableContents_2.TOOL_DEFINITION.name, handleGetTableContents_2.TOOL_DEFINITION.description, handleGetTableContents_2.TOOL_DEFINITION.inputSchema, handleGetTableContents_1.handleGetTableContents);
+        this.registerToolOnServer(server, handleGetPackage_2.TOOL_DEFINITION.name, handleGetPackage_2.TOOL_DEFINITION.description, handleGetPackage_2.TOOL_DEFINITION.inputSchema, handleGetPackage_1.handleGetPackage);
+        this.registerToolOnServer(server, handleCreatePackage_3.TOOL_DEFINITION.name, handleCreatePackage_3.TOOL_DEFINITION.description, handleCreatePackage_3.TOOL_DEFINITION.inputSchema, handleCreatePackage_1.handleCreatePackage);
+        this.registerToolOnServer(server, handleUpdatePackage_2.TOOL_DEFINITION.name, handleUpdatePackage_2.TOOL_DEFINITION.description, handleUpdatePackage_2.TOOL_DEFINITION.inputSchema, handleUpdatePackage_1.handleUpdatePackage);
+        this.registerToolOnServer(server, handleUnlockPackage_2.TOOL_DEFINITION.name, handleUnlockPackage_2.TOOL_DEFINITION.description, handleUnlockPackage_2.TOOL_DEFINITION.inputSchema, handleUnlockPackage_1.handleUnlockPackage);
+        this.registerToolOnServer(server, handleGetInclude_2.TOOL_DEFINITION.name, handleGetInclude_2.TOOL_DEFINITION.description, handleGetInclude_2.TOOL_DEFINITION.inputSchema, handleGetInclude_1.handleGetInclude);
+        this.registerToolOnServer(server, handleGetIncludesList_2.TOOL_DEFINITION.name, handleGetIncludesList_2.TOOL_DEFINITION.description, handleGetIncludesList_2.TOOL_DEFINITION.inputSchema, handleGetIncludesList_1.handleGetIncludesList);
+        this.registerToolOnServer(server, handleGetTypeInfo_2.TOOL_DEFINITION.name, handleGetTypeInfo_2.TOOL_DEFINITION.description, handleGetTypeInfo_2.TOOL_DEFINITION.inputSchema, handleGetTypeInfo_1.handleGetTypeInfo);
+        this.registerToolOnServer(server, handleGetInterface_2.TOOL_DEFINITION.name, handleGetInterface_2.TOOL_DEFINITION.description, handleGetInterface_2.TOOL_DEFINITION.inputSchema, handleGetInterface_1.handleGetInterface);
+        this.registerToolOnServer(server, handleGetTransaction_2.TOOL_DEFINITION.name, handleGetTransaction_2.TOOL_DEFINITION.description, handleGetTransaction_2.TOOL_DEFINITION.inputSchema, handleGetTransaction_1.handleGetTransaction);
+        this.registerToolOnServer(server, handleSearchObject_2.TOOL_DEFINITION.name, handleSearchObject_2.TOOL_DEFINITION.description, handleSearchObject_2.TOOL_DEFINITION.inputSchema, handleSearchObject_1.handleSearchObject);
+        this.registerToolOnServer(server, handleGetEnhancements_2.TOOL_DEFINITION.name, handleGetEnhancements_2.TOOL_DEFINITION.description, handleGetEnhancements_2.TOOL_DEFINITION.inputSchema, handleGetEnhancements_1.handleGetEnhancements);
+        this.registerToolOnServer(server, handleGetEnhancementSpot_2.TOOL_DEFINITION.name, handleGetEnhancementSpot_2.TOOL_DEFINITION.description, handleGetEnhancementSpot_2.TOOL_DEFINITION.inputSchema, handleGetEnhancementSpot_1.handleGetEnhancementSpot);
+        this.registerToolOnServer(server, handleGetEnhancementImpl_2.TOOL_DEFINITION.name, handleGetEnhancementImpl_2.TOOL_DEFINITION.description, handleGetEnhancementImpl_2.TOOL_DEFINITION.inputSchema, handleGetEnhancementImpl_1.handleGetEnhancementImpl);
+        this.registerToolOnServer(server, handleGetBdef_2.TOOL_DEFINITION.name, handleGetBdef_2.TOOL_DEFINITION.description, handleGetBdef_2.TOOL_DEFINITION.inputSchema, handleGetBdef_1.handleGetBdef);
+        this.registerToolOnServer(server, handleGetSqlQuery_2.TOOL_DEFINITION.name, handleGetSqlQuery_2.TOOL_DEFINITION.description, handleGetSqlQuery_2.TOOL_DEFINITION.inputSchema, handleGetSqlQuery_1.handleGetSqlQuery);
+        this.registerToolOnServer(server, handleGetWhereUsed_2.TOOL_DEFINITION.name, handleGetWhereUsed_2.TOOL_DEFINITION.description, handleGetWhereUsed_2.TOOL_DEFINITION.inputSchema, handleGetWhereUsed_1.handleGetWhereUsed);
+        this.registerToolOnServer(server, handleGetObjectInfo_2.TOOL_DEFINITION.name, handleGetObjectInfo_2.TOOL_DEFINITION.description, handleGetObjectInfo_2.TOOL_DEFINITION.inputSchema, async (args) => {
+            if (!args || typeof args !== "object") {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, "Missing or invalid arguments for GetObjectInfo");
+            }
+            return await (0, handleGetObjectInfo_1.handleGetObjectInfo)(args);
+        });
+        this.registerToolOnServer(server, handleGetAbapAST_2.TOOL_DEFINITION.name, handleGetAbapAST_2.TOOL_DEFINITION.description, handleGetAbapAST_2.TOOL_DEFINITION.inputSchema, handleGetAbapAST_1.handleGetAbapAST);
+        this.registerToolOnServer(server, handleGetAbapSemanticAnalysis_2.TOOL_DEFINITION.name, handleGetAbapSemanticAnalysis_2.TOOL_DEFINITION.description, handleGetAbapSemanticAnalysis_2.TOOL_DEFINITION.inputSchema, handleGetAbapSemanticAnalysis_1.handleGetAbapSemanticAnalysis);
+        this.registerToolOnServer(server, handleGetAbapSystemSymbols_2.TOOL_DEFINITION.name, handleGetAbapSystemSymbols_2.TOOL_DEFINITION.description, handleGetAbapSystemSymbols_2.TOOL_DEFINITION.inputSchema, handleGetAbapSystemSymbols_1.handleGetAbapSystemSymbols);
+        this.registerToolOnServer(server, handleGetDomain_2.TOOL_DEFINITION.name, handleGetDomain_2.TOOL_DEFINITION.description, handleGetDomain_2.TOOL_DEFINITION.inputSchema, handleGetDomain_1.handleGetDomain);
+        this.registerToolOnServer(server, handleCreateDomain_3.TOOL_DEFINITION.name, handleCreateDomain_3.TOOL_DEFINITION.description, handleCreateDomain_3.TOOL_DEFINITION.inputSchema, handleCreateDomain_1.handleCreateDomain);
+        this.registerToolOnServer(server, handleUpdateDomain_4.TOOL_DEFINITION.name, handleUpdateDomain_4.TOOL_DEFINITION.description, handleUpdateDomain_4.TOOL_DEFINITION.inputSchema, handleUpdateDomain_2.handleUpdateDomain);
+        this.registerToolOnServer(server, handleUpdateDomain_3.TOOL_DEFINITION.name, handleUpdateDomain_3.TOOL_DEFINITION.description, handleUpdateDomain_3.TOOL_DEFINITION.inputSchema, handleUpdateDomain_1.handleUpdateDomain);
+        this.registerToolOnServer(server, handleCreateDataElement_3.TOOL_DEFINITION.name, handleCreateDataElement_3.TOOL_DEFINITION.description, handleCreateDataElement_3.TOOL_DEFINITION.inputSchema, handleCreateDataElement_1.handleCreateDataElement);
+        this.registerToolOnServer(server, handleUpdateDataElement_4.TOOL_DEFINITION.name, handleUpdateDataElement_4.TOOL_DEFINITION.description, handleUpdateDataElement_4.TOOL_DEFINITION.inputSchema, handleUpdateDataElement_2.handleUpdateDataElement);
+        this.registerToolOnServer(server, handleUpdateDataElement_3.TOOL_DEFINITION.name, handleUpdateDataElement_3.TOOL_DEFINITION.description, handleUpdateDataElement_3.TOOL_DEFINITION.inputSchema, handleUpdateDataElement_1.handleUpdateDataElement);
+        this.registerToolOnServer(server, handleGetDataElement_2.TOOL_DEFINITION.name, handleGetDataElement_2.TOOL_DEFINITION.description, handleGetDataElement_2.TOOL_DEFINITION.inputSchema, handleGetDataElement_1.handleGetDataElement);
+        this.registerToolOnServer(server, handleCreateTransport_3.TOOL_DEFINITION.name, handleCreateTransport_3.TOOL_DEFINITION.description, handleCreateTransport_3.TOOL_DEFINITION.inputSchema, handleCreateTransport_1.handleCreateTransport);
+        this.registerToolOnServer(server, handleGetTransport_2.TOOL_DEFINITION.name, handleGetTransport_2.TOOL_DEFINITION.description, handleGetTransport_2.TOOL_DEFINITION.inputSchema, handleGetTransport_1.handleGetTransport);
+        this.registerToolOnServer(server, handleCreateTable_3.TOOL_DEFINITION.name, handleCreateTable_3.TOOL_DEFINITION.description, handleCreateTable_3.TOOL_DEFINITION.inputSchema, handleCreateTable_1.handleCreateTable);
+        this.registerToolOnServer(server, handleUpdateTable_2.TOOL_DEFINITION.name, handleUpdateTable_2.TOOL_DEFINITION.description, handleUpdateTable_2.TOOL_DEFINITION.inputSchema, handleUpdateTable_1.handleUpdateTable);
+        this.registerToolOnServer(server, handleCreateStructure_3.TOOL_DEFINITION.name, handleCreateStructure_3.TOOL_DEFINITION.description, handleCreateStructure_3.TOOL_DEFINITION.inputSchema, handleCreateStructure_1.handleCreateStructure);
+        this.registerToolOnServer(server, handleUpdateStructure_2.TOOL_DEFINITION.name, handleUpdateStructure_2.TOOL_DEFINITION.description, handleUpdateStructure_2.TOOL_DEFINITION.inputSchema, handleUpdateStructure_1.handleUpdateStructure);
+        this.registerToolOnServer(server, handleCreateView_3.TOOL_DEFINITION.name, handleCreateView_3.TOOL_DEFINITION.description, handleCreateView_3.TOOL_DEFINITION.inputSchema, handleCreateView_1.handleCreateView);
+        this.registerToolOnServer(server, handleGetView_2.TOOL_DEFINITION.name, handleGetView_2.TOOL_DEFINITION.description, handleGetView_2.TOOL_DEFINITION.inputSchema, handleGetView_1.handleGetView);
+        this.registerToolOnServer(server, handleGetServiceDefinition_2.TOOL_DEFINITION.name, handleGetServiceDefinition_2.TOOL_DEFINITION.description, handleGetServiceDefinition_2.TOOL_DEFINITION.inputSchema, handleGetServiceDefinition_1.handleGetServiceDefinition);
+        this.registerToolOnServer(server, handleUpdateView_4.TOOL_DEFINITION.name, handleUpdateView_4.TOOL_DEFINITION.description, handleUpdateView_4.TOOL_DEFINITION.inputSchema, handleUpdateView_2.handleUpdateView);
+        this.registerToolOnServer(server, handleCreateClass_3.TOOL_DEFINITION.name, handleCreateClass_3.TOOL_DEFINITION.description, handleCreateClass_3.TOOL_DEFINITION.inputSchema, handleCreateClass_1.handleCreateClass);
+        this.registerToolOnServer(server, handleUpdateClass_4.TOOL_DEFINITION.name, handleUpdateClass_4.TOOL_DEFINITION.description, handleUpdateClass_4.TOOL_DEFINITION.inputSchema, handleUpdateClass_2.handleUpdateClass);
+        this.registerToolOnServer(server, handleUpdateClass_3.TOOL_DEFINITION.name, handleUpdateClass_3.TOOL_DEFINITION.description, handleUpdateClass_3.TOOL_DEFINITION.inputSchema, handleUpdateClass_1.handleUpdateClass);
+        this.registerToolOnServer(server, handleCreateProgram_3.TOOL_DEFINITION.name, handleCreateProgram_3.TOOL_DEFINITION.description, handleCreateProgram_3.TOOL_DEFINITION.inputSchema, handleCreateProgram_1.handleCreateProgram);
+        this.registerToolOnServer(server, handleUpdateProgram_4.TOOL_DEFINITION.name, handleUpdateProgram_4.TOOL_DEFINITION.description, handleUpdateProgram_4.TOOL_DEFINITION.inputSchema, handleUpdateProgram_2.handleUpdateProgram);
+        this.registerToolOnServer(server, handleUpdateProgram_3.TOOL_DEFINITION.name, handleUpdateProgram_3.TOOL_DEFINITION.description, handleUpdateProgram_3.TOOL_DEFINITION.inputSchema, handleUpdateProgram_1.handleUpdateProgram);
+        this.registerToolOnServer(server, handleCreateInterface_3.TOOL_DEFINITION.name, handleCreateInterface_3.TOOL_DEFINITION.description, handleCreateInterface_3.TOOL_DEFINITION.inputSchema, handleCreateInterface_1.handleCreateInterface);
+        this.registerToolOnServer(server, handleUpdateInterface_4.TOOL_DEFINITION.name, handleUpdateInterface_4.TOOL_DEFINITION.description, handleUpdateInterface_4.TOOL_DEFINITION.inputSchema, handleUpdateInterface_2.handleUpdateInterface);
+        this.registerToolOnServer(server, handleCreateFunctionGroup_3.TOOL_DEFINITION.name, handleCreateFunctionGroup_3.TOOL_DEFINITION.description, handleCreateFunctionGroup_3.TOOL_DEFINITION.inputSchema, handleCreateFunctionGroup_1.handleCreateFunctionGroup);
+        this.registerToolOnServer(server, handleCreateFunctionModule_3.TOOL_DEFINITION.name, handleCreateFunctionModule_3.TOOL_DEFINITION.description, handleCreateFunctionModule_3.TOOL_DEFINITION.inputSchema, handleCreateFunctionModule_1.handleCreateFunctionModule);
+        this.registerToolOnServer(server, handleUpdateFunctionModule_4.TOOL_DEFINITION.name, handleUpdateFunctionModule_4.TOOL_DEFINITION.description, handleUpdateFunctionModule_4.TOOL_DEFINITION.inputSchema, handleUpdateFunctionModule_2.handleUpdateFunctionModule);
+        this.registerToolOnServer(server, handleUpdateView_3.TOOL_DEFINITION.name, handleUpdateView_3.TOOL_DEFINITION.description, handleUpdateView_3.TOOL_DEFINITION.inputSchema, handleUpdateView_1.handleUpdateView);
+        this.registerToolOnServer(server, handleUpdateInterface_3.TOOL_DEFINITION.name, handleUpdateInterface_3.TOOL_DEFINITION.description, handleUpdateInterface_3.TOOL_DEFINITION.inputSchema, handleUpdateInterface_1.handleUpdateInterface);
+        this.registerToolOnServer(server, handleUpdateFunctionModule_3.TOOL_DEFINITION.name, handleUpdateFunctionModule_3.TOOL_DEFINITION.description, handleUpdateFunctionModule_3.TOOL_DEFINITION.inputSchema, handleUpdateFunctionModule_1.handleUpdateFunctionModule);
+        this.registerToolOnServer(server, handleActivateObject_2.TOOL_DEFINITION.name, handleActivateObject_2.TOOL_DEFINITION.description, handleActivateObject_2.TOOL_DEFINITION.inputSchema, handleActivateObject_1.handleActivateObject);
+        this.registerToolOnServer(server, handleDeleteObject_2.TOOL_DEFINITION.name, handleDeleteObject_2.TOOL_DEFINITION.description, handleDeleteObject_2.TOOL_DEFINITION.inputSchema, handleDeleteObject_1.handleDeleteObject);
+        this.registerToolOnServer(server, handleCheckObject_2.TOOL_DEFINITION.name, handleCheckObject_2.TOOL_DEFINITION.description, handleCheckObject_2.TOOL_DEFINITION.inputSchema, handleCheckObject_1.handleCheckObject);
+        this.registerToolOnServer(server, handleGetSession_2.TOOL_DEFINITION.name, handleGetSession_2.TOOL_DEFINITION.description, handleGetSession_2.TOOL_DEFINITION.inputSchema, handleGetSession_1.handleGetSession);
+        this.registerToolOnServer(server, handleValidateObject_2.TOOL_DEFINITION.name, handleValidateObject_2.TOOL_DEFINITION.description, handleValidateObject_2.TOOL_DEFINITION.inputSchema, handleValidateObject_1.handleValidateObject);
+        this.registerToolOnServer(server, handleLockObject_2.TOOL_DEFINITION.name, handleLockObject_2.TOOL_DEFINITION.description, handleLockObject_2.TOOL_DEFINITION.inputSchema, handleLockObject_1.handleLockObject);
+        this.registerToolOnServer(server, handleUnlockObject_2.TOOL_DEFINITION.name, handleUnlockObject_2.TOOL_DEFINITION.description, handleUnlockObject_2.TOOL_DEFINITION.inputSchema, handleUnlockObject_1.handleUnlockObject);
+        this.registerToolOnServer(server, handleValidateClass_2.TOOL_DEFINITION.name, handleValidateClass_2.TOOL_DEFINITION.description, handleValidateClass_2.TOOL_DEFINITION.inputSchema, handleValidateClass_1.handleValidateClass);
+        this.registerToolOnServer(server, handleCheckClass_2.TOOL_DEFINITION.name, handleCheckClass_2.TOOL_DEFINITION.description, handleCheckClass_2.TOOL_DEFINITION.inputSchema, handleCheckClass_1.handleCheckClass);
+        this.registerToolOnServer(server, handleValidateTable_2.TOOL_DEFINITION.name, handleValidateTable_2.TOOL_DEFINITION.description, handleValidateTable_2.TOOL_DEFINITION.inputSchema, handleValidateTable_1.handleValidateTable);
+        this.registerToolOnServer(server, handleCheckTable_2.TOOL_DEFINITION.name, handleCheckTable_2.TOOL_DEFINITION.description, handleCheckTable_2.TOOL_DEFINITION.inputSchema, handleCheckTable_1.handleCheckTable);
+        this.registerToolOnServer(server, handleValidateFunctionModule_2.TOOL_DEFINITION.name, handleValidateFunctionModule_2.TOOL_DEFINITION.description, handleValidateFunctionModule_2.TOOL_DEFINITION.inputSchema, handleValidateFunctionModule_1.handleValidateFunctionModule);
+        this.registerToolOnServer(server, handleCheckFunctionModule_2.TOOL_DEFINITION.name, handleCheckFunctionModule_2.TOOL_DEFINITION.description, handleCheckFunctionModule_2.TOOL_DEFINITION.inputSchema, handleCheckFunctionModule_1.handleCheckFunctionModule);
+        this.registerToolOnServer(server, handleCreateBehaviorDefinition_3.TOOL_DEFINITION.name, handleCreateBehaviorDefinition_3.TOOL_DEFINITION.description, handleCreateBehaviorDefinition_3.TOOL_DEFINITION.inputSchema, handleCreateBehaviorDefinition_1.handleCreateBehaviorDefinition);
+        this.registerToolOnServer(server, handleUpdateBehaviorDefinition_4.TOOL_DEFINITION.name, handleUpdateBehaviorDefinition_4.TOOL_DEFINITION.description, handleUpdateBehaviorDefinition_4.TOOL_DEFINITION.inputSchema, handleUpdateBehaviorDefinition_2.handleUpdateBehaviorDefinition);
+        this.registerToolOnServer(server, handleUpdateBehaviorDefinition_3.TOOL_DEFINITION.name, handleUpdateBehaviorDefinition_3.TOOL_DEFINITION.description, handleUpdateBehaviorDefinition_3.TOOL_DEFINITION.inputSchema, handleUpdateBehaviorDefinition_1.handleUpdateBehaviorDefinition);
+        this.registerToolOnServer(server, handleCreateMetadataExtension_3.TOOL_DEFINITION.name, handleCreateMetadataExtension_3.TOOL_DEFINITION.description, handleCreateMetadataExtension_3.TOOL_DEFINITION.inputSchema, handleCreateMetadataExtension_1.handleCreateMetadataExtension);
+        this.registerToolOnServer(server, handleUpdateMetadataExtension_4.TOOL_DEFINITION.name, handleUpdateMetadataExtension_4.TOOL_DEFINITION.description, handleUpdateMetadataExtension_4.TOOL_DEFINITION.inputSchema, handleUpdateMetadataExtension_2.handleUpdateMetadataExtension);
+        this.registerToolOnServer(server, handleUpdateMetadataExtension_3.TOOL_DEFINITION.name, handleUpdateMetadataExtension_3.TOOL_DEFINITION.description, handleUpdateMetadataExtension_3.TOOL_DEFINITION.inputSchema, handleUpdateMetadataExtension_1.handleUpdateMetadataExtension);
+        this.registerToolOnServer(server, handleGetInactiveObjects_2.TOOL_DEFINITION.name, handleGetInactiveObjects_2.TOOL_DEFINITION.description, handleGetInactiveObjects_2.TOOL_DEFINITION.inputSchema, handleGetInactiveObjects_1.handleGetInactiveObjects);
+        // New low-level handlers registration
+        this.registerToolOnServer(server, handleDeleteClass_2.TOOL_DEFINITION.name, handleDeleteClass_2.TOOL_DEFINITION.description, handleDeleteClass_2.TOOL_DEFINITION.inputSchema, handleDeleteClass_1.handleDeleteClass);
+        this.registerToolOnServer(server, handleLockClass_2.TOOL_DEFINITION.name, handleLockClass_2.TOOL_DEFINITION.description, handleLockClass_2.TOOL_DEFINITION.inputSchema, handleLockClass_1.handleLockClass);
+        this.registerToolOnServer(server, handleUnlockClass_2.TOOL_DEFINITION.name, handleUnlockClass_2.TOOL_DEFINITION.description, handleUnlockClass_2.TOOL_DEFINITION.inputSchema, handleUnlockClass_1.handleUnlockClass);
+        this.registerToolOnServer(server, handleCreateClass_4.TOOL_DEFINITION.name, handleCreateClass_4.TOOL_DEFINITION.description, handleCreateClass_4.TOOL_DEFINITION.inputSchema, handleCreateClass_2.handleCreateClass);
+        this.registerToolOnServer(server, handleLockClassTestClasses_2.TOOL_DEFINITION.name, handleLockClassTestClasses_2.TOOL_DEFINITION.description, handleLockClassTestClasses_2.TOOL_DEFINITION.inputSchema, handleLockClassTestClasses_1.handleLockClassTestClasses);
+        this.registerToolOnServer(server, handleUnlockClassTestClasses_2.TOOL_DEFINITION.name, handleUnlockClassTestClasses_2.TOOL_DEFINITION.description, handleUnlockClassTestClasses_2.TOOL_DEFINITION.inputSchema, handleUnlockClassTestClasses_1.handleUnlockClassTestClasses);
+        this.registerToolOnServer(server, handleUpdateClassTestClasses_2.TOOL_DEFINITION.name, handleUpdateClassTestClasses_2.TOOL_DEFINITION.description, handleUpdateClassTestClasses_2.TOOL_DEFINITION.inputSchema, handleUpdateClassTestClasses_1.handleUpdateClassTestClasses);
+        this.registerToolOnServer(server, handleActivateClassTestClasses_2.TOOL_DEFINITION.name, handleActivateClassTestClasses_2.TOOL_DEFINITION.description, handleActivateClassTestClasses_2.TOOL_DEFINITION.inputSchema, handleActivateClassTestClasses_1.handleActivateClassTestClasses);
+        this.registerToolOnServer(server, handleRunClassUnitTests_2.TOOL_DEFINITION.name, handleRunClassUnitTests_2.TOOL_DEFINITION.description, handleRunClassUnitTests_2.TOOL_DEFINITION.inputSchema, handleRunClassUnitTests_1.handleRunClassUnitTests);
+        this.registerToolOnServer(server, handleGetClassUnitTestStatus_2.TOOL_DEFINITION.name, handleGetClassUnitTestStatus_2.TOOL_DEFINITION.description, handleGetClassUnitTestStatus_2.TOOL_DEFINITION.inputSchema, handleGetClassUnitTestStatus_1.handleGetClassUnitTestStatus);
+        this.registerToolOnServer(server, handleGetClassUnitTestResult_2.TOOL_DEFINITION.name, handleGetClassUnitTestResult_2.TOOL_DEFINITION.description, handleGetClassUnitTestResult_2.TOOL_DEFINITION.inputSchema, handleGetClassUnitTestResult_1.handleGetClassUnitTestResult);
+        this.registerToolOnServer(server, handleCheckProgram_2.TOOL_DEFINITION.name, handleCheckProgram_2.TOOL_DEFINITION.description, handleCheckProgram_2.TOOL_DEFINITION.inputSchema, handleCheckProgram_1.handleCheckProgram);
+        this.registerToolOnServer(server, handleDeleteProgram_2.TOOL_DEFINITION.name, handleDeleteProgram_2.TOOL_DEFINITION.description, handleDeleteProgram_2.TOOL_DEFINITION.inputSchema, handleDeleteProgram_1.handleDeleteProgram);
+        this.registerToolOnServer(server, handleLockProgram_2.TOOL_DEFINITION.name, handleLockProgram_2.TOOL_DEFINITION.description, handleLockProgram_2.TOOL_DEFINITION.inputSchema, handleLockProgram_1.handleLockProgram);
+        this.registerToolOnServer(server, handleUnlockProgram_2.TOOL_DEFINITION.name, handleUnlockProgram_2.TOOL_DEFINITION.description, handleUnlockProgram_2.TOOL_DEFINITION.inputSchema, handleUnlockProgram_1.handleUnlockProgram);
+        this.registerToolOnServer(server, handleValidateProgram_2.TOOL_DEFINITION.name, handleValidateProgram_2.TOOL_DEFINITION.description, handleValidateProgram_2.TOOL_DEFINITION.inputSchema, handleValidateProgram_1.handleValidateProgram);
+        this.registerToolOnServer(server, handleCreateProgram_4.TOOL_DEFINITION.name, handleCreateProgram_4.TOOL_DEFINITION.description, handleCreateProgram_4.TOOL_DEFINITION.inputSchema, handleCreateProgram_2.handleCreateProgram);
+        this.registerToolOnServer(server, handleCheckInterface_2.TOOL_DEFINITION.name, handleCheckInterface_2.TOOL_DEFINITION.description, handleCheckInterface_2.TOOL_DEFINITION.inputSchema, handleCheckInterface_1.handleCheckInterface);
+        this.registerToolOnServer(server, handleDeleteInterface_2.TOOL_DEFINITION.name, handleDeleteInterface_2.TOOL_DEFINITION.description, handleDeleteInterface_2.TOOL_DEFINITION.inputSchema, handleDeleteInterface_1.handleDeleteInterface);
+        this.registerToolOnServer(server, handleLockInterface_2.TOOL_DEFINITION.name, handleLockInterface_2.TOOL_DEFINITION.description, handleLockInterface_2.TOOL_DEFINITION.inputSchema, handleLockInterface_1.handleLockInterface);
+        this.registerToolOnServer(server, handleUnlockInterface_2.TOOL_DEFINITION.name, handleUnlockInterface_2.TOOL_DEFINITION.description, handleUnlockInterface_2.TOOL_DEFINITION.inputSchema, handleUnlockInterface_1.handleUnlockInterface);
+        this.registerToolOnServer(server, handleValidateInterface_2.TOOL_DEFINITION.name, handleValidateInterface_2.TOOL_DEFINITION.description, handleValidateInterface_2.TOOL_DEFINITION.inputSchema, handleValidateInterface_1.handleValidateInterface);
+        this.registerToolOnServer(server, handleCreateInterface_4.TOOL_DEFINITION.name, handleCreateInterface_4.TOOL_DEFINITION.description, handleCreateInterface_4.TOOL_DEFINITION.inputSchema, handleCreateInterface_2.handleCreateInterface);
+        this.registerToolOnServer(server, handleCheckFunctionGroup_2.TOOL_DEFINITION.name, handleCheckFunctionGroup_2.TOOL_DEFINITION.description, handleCheckFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleCheckFunctionGroup_1.handleCheckFunctionGroup);
+        this.registerToolOnServer(server, handleDeleteFunctionGroup_2.TOOL_DEFINITION.name, handleDeleteFunctionGroup_2.TOOL_DEFINITION.description, handleDeleteFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleDeleteFunctionGroup_1.handleDeleteFunctionGroup);
+        this.registerToolOnServer(server, handleDeleteFunctionModule_2.TOOL_DEFINITION.name, handleDeleteFunctionModule_2.TOOL_DEFINITION.description, handleDeleteFunctionModule_2.TOOL_DEFINITION.inputSchema, handleDeleteFunctionModule_1.handleDeleteFunctionModule);
+        this.registerToolOnServer(server, handleLockFunctionGroup_2.TOOL_DEFINITION.name, handleLockFunctionGroup_2.TOOL_DEFINITION.description, handleLockFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleLockFunctionGroup_1.handleLockFunctionGroup);
+        this.registerToolOnServer(server, handleLockFunctionModule_2.TOOL_DEFINITION.name, handleLockFunctionModule_2.TOOL_DEFINITION.description, handleLockFunctionModule_2.TOOL_DEFINITION.inputSchema, handleLockFunctionModule_1.handleLockFunctionModule);
+        this.registerToolOnServer(server, handleUnlockFunctionGroup_2.TOOL_DEFINITION.name, handleUnlockFunctionGroup_2.TOOL_DEFINITION.description, handleUnlockFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleUnlockFunctionGroup_1.handleUnlockFunctionGroup);
+        this.registerToolOnServer(server, handleUnlockFunctionModule_2.TOOL_DEFINITION.name, handleUnlockFunctionModule_2.TOOL_DEFINITION.description, handleUnlockFunctionModule_2.TOOL_DEFINITION.inputSchema, handleUnlockFunctionModule_1.handleUnlockFunctionModule);
+        this.registerToolOnServer(server, handleValidateFunctionGroup_2.TOOL_DEFINITION.name, handleValidateFunctionGroup_2.TOOL_DEFINITION.description, handleValidateFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleValidateFunctionGroup_1.handleValidateFunctionGroup);
+        this.registerToolOnServer(server, handleCreateFunctionGroup_4.TOOL_DEFINITION.name, handleCreateFunctionGroup_4.TOOL_DEFINITION.description, handleCreateFunctionGroup_4.TOOL_DEFINITION.inputSchema, handleCreateFunctionGroup_2.handleCreateFunctionGroup);
+        this.registerToolOnServer(server, handleCreateFunctionModule_4.TOOL_DEFINITION.name, handleCreateFunctionModule_4.TOOL_DEFINITION.description, handleCreateFunctionModule_4.TOOL_DEFINITION.inputSchema, handleCreateFunctionModule_2.handleCreateFunctionModule);
+        this.registerToolOnServer(server, handleCheckDataElement_2.TOOL_DEFINITION.name, handleCheckDataElement_2.TOOL_DEFINITION.description, handleCheckDataElement_2.TOOL_DEFINITION.inputSchema, handleCheckDataElement_1.handleCheckDataElement);
+        this.registerToolOnServer(server, handleDeleteDataElement_2.TOOL_DEFINITION.name, handleDeleteDataElement_2.TOOL_DEFINITION.description, handleDeleteDataElement_2.TOOL_DEFINITION.inputSchema, handleDeleteDataElement_1.handleDeleteDataElement);
+        this.registerToolOnServer(server, handleLockDataElement_2.TOOL_DEFINITION.name, handleLockDataElement_2.TOOL_DEFINITION.description, handleLockDataElement_2.TOOL_DEFINITION.inputSchema, handleLockDataElement_1.handleLockDataElement);
+        this.registerToolOnServer(server, handleUnlockDataElement_2.TOOL_DEFINITION.name, handleUnlockDataElement_2.TOOL_DEFINITION.description, handleUnlockDataElement_2.TOOL_DEFINITION.inputSchema, handleUnlockDataElement_1.handleUnlockDataElement);
+        this.registerToolOnServer(server, handleValidateDataElement_2.TOOL_DEFINITION.name, handleValidateDataElement_2.TOOL_DEFINITION.description, handleValidateDataElement_2.TOOL_DEFINITION.inputSchema, handleValidateDataElement_1.handleValidateDataElement);
+        this.registerToolOnServer(server, handleCreateDataElement_4.TOOL_DEFINITION.name, handleCreateDataElement_4.TOOL_DEFINITION.description, handleCreateDataElement_4.TOOL_DEFINITION.inputSchema, handleCreateDataElement_2.handleCreateDataElement);
+        this.registerToolOnServer(server, handleCheckDomain_2.TOOL_DEFINITION.name, handleCheckDomain_2.TOOL_DEFINITION.description, handleCheckDomain_2.TOOL_DEFINITION.inputSchema, handleCheckDomain_1.handleCheckDomain);
+        this.registerToolOnServer(server, handleDeleteDomain_2.TOOL_DEFINITION.name, handleDeleteDomain_2.TOOL_DEFINITION.description, handleDeleteDomain_2.TOOL_DEFINITION.inputSchema, handleDeleteDomain_1.handleDeleteDomain);
+        this.registerToolOnServer(server, handleLockDomain_2.TOOL_DEFINITION.name, handleLockDomain_2.TOOL_DEFINITION.description, handleLockDomain_2.TOOL_DEFINITION.inputSchema, handleLockDomain_1.handleLockDomain);
+        this.registerToolOnServer(server, handleUnlockDomain_2.TOOL_DEFINITION.name, handleUnlockDomain_2.TOOL_DEFINITION.description, handleUnlockDomain_2.TOOL_DEFINITION.inputSchema, handleUnlockDomain_1.handleUnlockDomain);
+        this.registerToolOnServer(server, handleValidateDomain_2.TOOL_DEFINITION.name, handleValidateDomain_2.TOOL_DEFINITION.description, handleValidateDomain_2.TOOL_DEFINITION.inputSchema, handleValidateDomain_1.handleValidateDomain);
+        this.registerToolOnServer(server, handleCreateDomain_4.TOOL_DEFINITION.name, handleCreateDomain_4.TOOL_DEFINITION.description, handleCreateDomain_4.TOOL_DEFINITION.inputSchema, handleCreateDomain_2.handleCreateDomain);
+        this.registerToolOnServer(server, handleCheckStructure_2.TOOL_DEFINITION.name, handleCheckStructure_2.TOOL_DEFINITION.description, handleCheckStructure_2.TOOL_DEFINITION.inputSchema, handleCheckStructure_1.handleCheckStructure);
+        this.registerToolOnServer(server, handleDeleteStructure_2.TOOL_DEFINITION.name, handleDeleteStructure_2.TOOL_DEFINITION.description, handleDeleteStructure_2.TOOL_DEFINITION.inputSchema, handleDeleteStructure_1.handleDeleteStructure);
+        this.registerToolOnServer(server, handleLockStructure_2.TOOL_DEFINITION.name, handleLockStructure_2.TOOL_DEFINITION.description, handleLockStructure_2.TOOL_DEFINITION.inputSchema, handleLockStructure_1.handleLockStructure);
+        this.registerToolOnServer(server, handleUnlockStructure_2.TOOL_DEFINITION.name, handleUnlockStructure_2.TOOL_DEFINITION.description, handleUnlockStructure_2.TOOL_DEFINITION.inputSchema, handleUnlockStructure_1.handleUnlockStructure);
+        this.registerToolOnServer(server, handleValidateStructure_2.TOOL_DEFINITION.name, handleValidateStructure_2.TOOL_DEFINITION.description, handleValidateStructure_2.TOOL_DEFINITION.inputSchema, handleValidateStructure_1.handleValidateStructure);
+        this.registerToolOnServer(server, handleCreateStructure_4.TOOL_DEFINITION.name, handleCreateStructure_4.TOOL_DEFINITION.description, handleCreateStructure_4.TOOL_DEFINITION.inputSchema, handleCreateStructure_2.handleCreateStructure);
+        this.registerToolOnServer(server, handleDeleteTable_2.TOOL_DEFINITION.name, handleDeleteTable_2.TOOL_DEFINITION.description, handleDeleteTable_2.TOOL_DEFINITION.inputSchema, handleDeleteTable_1.handleDeleteTable);
+        this.registerToolOnServer(server, handleLockTable_2.TOOL_DEFINITION.name, handleLockTable_2.TOOL_DEFINITION.description, handleLockTable_2.TOOL_DEFINITION.inputSchema, handleLockTable_1.handleLockTable);
+        this.registerToolOnServer(server, handleUnlockTable_2.TOOL_DEFINITION.name, handleUnlockTable_2.TOOL_DEFINITION.description, handleUnlockTable_2.TOOL_DEFINITION.inputSchema, handleUnlockTable_1.handleUnlockTable);
+        this.registerToolOnServer(server, handleCreateTable_4.TOOL_DEFINITION.name, handleCreateTable_4.TOOL_DEFINITION.description, handleCreateTable_4.TOOL_DEFINITION.inputSchema, handleCreateTable_2.handleCreateTable);
+        this.registerToolOnServer(server, handleCheckView_2.TOOL_DEFINITION.name, handleCheckView_2.TOOL_DEFINITION.description, handleCheckView_2.TOOL_DEFINITION.inputSchema, handleCheckView_1.handleCheckView);
+        this.registerToolOnServer(server, handleDeleteView_2.TOOL_DEFINITION.name, handleDeleteView_2.TOOL_DEFINITION.description, handleDeleteView_2.TOOL_DEFINITION.inputSchema, handleDeleteView_1.handleDeleteView);
+        this.registerToolOnServer(server, handleLockView_2.TOOL_DEFINITION.name, handleLockView_2.TOOL_DEFINITION.description, handleLockView_2.TOOL_DEFINITION.inputSchema, handleLockView_1.handleLockView);
+        this.registerToolOnServer(server, handleUnlockView_2.TOOL_DEFINITION.name, handleUnlockView_2.TOOL_DEFINITION.description, handleUnlockView_2.TOOL_DEFINITION.inputSchema, handleUnlockView_1.handleUnlockView);
+        this.registerToolOnServer(server, handleValidateView_2.TOOL_DEFINITION.name, handleValidateView_2.TOOL_DEFINITION.description, handleValidateView_2.TOOL_DEFINITION.inputSchema, handleValidateView_1.handleValidateView);
+        this.registerToolOnServer(server, handleCreateView_4.TOOL_DEFINITION.name, handleCreateView_4.TOOL_DEFINITION.description, handleCreateView_4.TOOL_DEFINITION.inputSchema, handleCreateView_2.handleCreateView);
+        this.registerToolOnServer(server, handleCheckPackage_2.TOOL_DEFINITION.name, handleCheckPackage_2.TOOL_DEFINITION.description, handleCheckPackage_2.TOOL_DEFINITION.inputSchema, handleCheckPackage_1.handleCheckPackage);
+        this.registerToolOnServer(server, handleDeletePackage_2.TOOL_DEFINITION.name, handleDeletePackage_2.TOOL_DEFINITION.description, handleDeletePackage_2.TOOL_DEFINITION.inputSchema, handleDeletePackage_1.handleDeletePackage);
+        this.registerToolOnServer(server, handleLockPackage_2.TOOL_DEFINITION.name, handleLockPackage_2.TOOL_DEFINITION.description, handleLockPackage_2.TOOL_DEFINITION.inputSchema, handleLockPackage_1.handleLockPackage);
+        this.registerToolOnServer(server, handleValidatePackage_2.TOOL_DEFINITION.name, handleValidatePackage_2.TOOL_DEFINITION.description, handleValidatePackage_2.TOOL_DEFINITION.inputSchema, handleValidatePackage_1.handleValidatePackage);
+        this.registerToolOnServer(server, handleCreatePackage_4.TOOL_DEFINITION.name, handleCreatePackage_4.TOOL_DEFINITION.description, handleCreatePackage_4.TOOL_DEFINITION.inputSchema, handleCreatePackage_2.handleCreatePackage);
+        this.registerToolOnServer(server, handleCreateTransport_4.TOOL_DEFINITION.name, handleCreateTransport_4.TOOL_DEFINITION.description, handleCreateTransport_4.TOOL_DEFINITION.inputSchema, handleCreateTransport_2.handleCreateTransport);
+        this.registerToolOnServer(server, handleCheckBehaviorDefinition_2.TOOL_DEFINITION.name, handleCheckBehaviorDefinition_2.TOOL_DEFINITION.description, handleCheckBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleCheckBehaviorDefinition_1.handleCheckBehaviorDefinition);
+        this.registerToolOnServer(server, handleDeleteBehaviorDefinition_2.TOOL_DEFINITION.name, handleDeleteBehaviorDefinition_2.TOOL_DEFINITION.description, handleDeleteBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleDeleteBehaviorDefinition_1.handleDeleteBehaviorDefinition);
+        this.registerToolOnServer(server, handleLockBehaviorDefinition_2.TOOL_DEFINITION.name, handleLockBehaviorDefinition_2.TOOL_DEFINITION.description, handleLockBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleLockBehaviorDefinition_1.handleLockBehaviorDefinition);
+        this.registerToolOnServer(server, handleUnlockBehaviorDefinition_2.TOOL_DEFINITION.name, handleUnlockBehaviorDefinition_2.TOOL_DEFINITION.description, handleUnlockBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleUnlockBehaviorDefinition_1.handleUnlockBehaviorDefinition);
+        this.registerToolOnServer(server, handleValidateBehaviorDefinition_2.TOOL_DEFINITION.name, handleValidateBehaviorDefinition_2.TOOL_DEFINITION.description, handleValidateBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleValidateBehaviorDefinition_1.handleValidateBehaviorDefinition);
+        this.registerToolOnServer(server, handleCreateBehaviorDefinition_4.TOOL_DEFINITION.name, handleCreateBehaviorDefinition_4.TOOL_DEFINITION.description, handleCreateBehaviorDefinition_4.TOOL_DEFINITION.inputSchema, handleCreateBehaviorDefinition_2.handleCreateBehaviorDefinition);
+        this.registerToolOnServer(server, handleCheckMetadataExtension_2.TOOL_DEFINITION.name, handleCheckMetadataExtension_2.TOOL_DEFINITION.description, handleCheckMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleCheckMetadataExtension_1.handleCheckMetadataExtension);
+        this.registerToolOnServer(server, handleDeleteMetadataExtension_2.TOOL_DEFINITION.name, handleDeleteMetadataExtension_2.TOOL_DEFINITION.description, handleDeleteMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleDeleteMetadataExtension_1.handleDeleteMetadataExtension);
+        this.registerToolOnServer(server, handleLockMetadataExtension_2.TOOL_DEFINITION.name, handleLockMetadataExtension_2.TOOL_DEFINITION.description, handleLockMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleLockMetadataExtension_1.handleLockMetadataExtension);
+        this.registerToolOnServer(server, handleUnlockMetadataExtension_2.TOOL_DEFINITION.name, handleUnlockMetadataExtension_2.TOOL_DEFINITION.description, handleUnlockMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleUnlockMetadataExtension_1.handleUnlockMetadataExtension);
+        this.registerToolOnServer(server, handleValidateMetadataExtension_2.TOOL_DEFINITION.name, handleValidateMetadataExtension_2.TOOL_DEFINITION.description, handleValidateMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleValidateMetadataExtension_1.handleValidateMetadataExtension);
+        this.registerToolOnServer(server, handleCreateMetadataExtension_4.TOOL_DEFINITION.name, handleCreateMetadataExtension_4.TOOL_DEFINITION.description, handleCreateMetadataExtension_4.TOOL_DEFINITION.inputSchema, handleCreateMetadataExtension_2.handleCreateMetadataExtension);
+        this.registerToolOnServer(server, handleActivateProgram_2.TOOL_DEFINITION.name, handleActivateProgram_2.TOOL_DEFINITION.description, handleActivateProgram_2.TOOL_DEFINITION.inputSchema, handleActivateProgram_1.handleActivateProgram);
+        this.registerToolOnServer(server, handleActivateClass_2.TOOL_DEFINITION.name, handleActivateClass_2.TOOL_DEFINITION.description, handleActivateClass_2.TOOL_DEFINITION.inputSchema, handleActivateClass_1.handleActivateClass);
+        this.registerToolOnServer(server, handleActivateInterface_2.TOOL_DEFINITION.name, handleActivateInterface_2.TOOL_DEFINITION.description, handleActivateInterface_2.TOOL_DEFINITION.inputSchema, handleActivateInterface_1.handleActivateInterface);
+        this.registerToolOnServer(server, handleActivateFunctionModule_2.TOOL_DEFINITION.name, handleActivateFunctionModule_2.TOOL_DEFINITION.description, handleActivateFunctionModule_2.TOOL_DEFINITION.inputSchema, handleActivateFunctionModule_1.handleActivateFunctionModule);
+        this.registerToolOnServer(server, handleActivateFunctionGroup_2.TOOL_DEFINITION.name, handleActivateFunctionGroup_2.TOOL_DEFINITION.description, handleActivateFunctionGroup_2.TOOL_DEFINITION.inputSchema, handleActivateFunctionGroup_1.handleActivateFunctionGroup);
+        this.registerToolOnServer(server, handleActivateDataElement_2.TOOL_DEFINITION.name, handleActivateDataElement_2.TOOL_DEFINITION.description, handleActivateDataElement_2.TOOL_DEFINITION.inputSchema, handleActivateDataElement_1.handleActivateDataElement);
+        this.registerToolOnServer(server, handleActivateDomain_2.TOOL_DEFINITION.name, handleActivateDomain_2.TOOL_DEFINITION.description, handleActivateDomain_2.TOOL_DEFINITION.inputSchema, handleActivateDomain_1.handleActivateDomain);
+        this.registerToolOnServer(server, handleActivateStructure_2.TOOL_DEFINITION.name, handleActivateStructure_2.TOOL_DEFINITION.description, handleActivateStructure_2.TOOL_DEFINITION.inputSchema, handleActivateStructure_1.handleActivateStructure);
+        this.registerToolOnServer(server, handleActivateTable_2.TOOL_DEFINITION.name, handleActivateTable_2.TOOL_DEFINITION.description, handleActivateTable_2.TOOL_DEFINITION.inputSchema, handleActivateTable_1.handleActivateTable);
+        this.registerToolOnServer(server, handleActivateView_2.TOOL_DEFINITION.name, handleActivateView_2.TOOL_DEFINITION.description, handleActivateView_2.TOOL_DEFINITION.inputSchema, handleActivateView_1.handleActivateView);
+        this.registerToolOnServer(server, handleActivateBehaviorDefinition_2.TOOL_DEFINITION.name, handleActivateBehaviorDefinition_2.TOOL_DEFINITION.description, handleActivateBehaviorDefinition_2.TOOL_DEFINITION.inputSchema, handleActivateBehaviorDefinition_1.handleActivateBehaviorDefinition);
+        this.registerToolOnServer(server, handleActivateMetadataExtension_2.TOOL_DEFINITION.name, handleActivateMetadataExtension_2.TOOL_DEFINITION.description, handleActivateMetadataExtension_2.TOOL_DEFINITION.inputSchema, handleActivateMetadataExtension_1.handleActivateMetadataExtension);
+        // Dynamic import tools
+        this.registerToolOnServer(server, "GetAdtTypes", "Get all ADT types available in the system", { type: "object", properties: {}, required: [] }, async (args) => {
+            return await (await import("./handlers/system/readonly/handleGetAllTypes.js")).handleGetAdtTypes(args);
+        });
+        this.registerToolOnServer(server, "GetObjectStructure", "Get object structure with includes hierarchy", { type: "object", properties: { object_name: { type: "string" }, object_type: { type: "string" } }, required: ["object_name", "object_type"] }, async (args) => {
+            return await (await import("./handlers/system/readonly/handleGetObjectStructure.js")).handleGetObjectStructure(args);
+        });
+        this.registerToolOnServer(server, "GetObjectsList", "Get list of objects by package", { type: "object", properties: { package_name: { type: "string" } }, required: ["package_name"] }, async (args) => {
+            return await (await import("./handlers/search/readonly/handleGetObjectsList.js")).handleGetObjectsList(args);
+        });
+        this.registerToolOnServer(server, "GetObjectsByType", "Get objects by type", { type: "object", properties: { object_type: { type: "string" }, package_name: { type: "string" } }, required: ["object_type"] }, async (args) => {
+            return await (await import("./handlers/search/readonly/handleGetObjectsByType.js")).handleGetObjectsByType(args);
+        });
+        this.registerToolOnServer(server, "GetProgFullCode", "Get full program code with includes", { type: "object", properties: { program_name: { type: "string" } }, required: ["program_name"] }, async (args) => {
+            return await (await import("./handlers/program/readonly/handleGetProgFullCode.js")).handleGetProgFullCode(args);
+        });
+        this.registerToolOnServer(server, "GetObjectNodeFromCache", "Get object node from cache", { type: "object", properties: { object_name: { type: "string" }, object_type: { type: "string" } }, required: ["object_name", "object_type"] }, async (args) => {
+            return await (await import("./handlers/system/readonly/handleGetObjectNodeFromCache.js")).handleGetObjectNodeFromCache(args);
+        });
+        this.registerToolOnServer(server, "DescribeByList", "Describe objects by list", { type: "object", properties: { objects: { type: "array", items: { type: "string" } } }, required: ["objects"] }, async (args) => {
+            return await (await import("./handlers/system/readonly/handleDescribeByList.js")).handleDescribeByList(args);
+        });
+    }
+    /**
+     * Sets up handlers for new McpServer using registerTool (recommended API)
+     * @private
+     */
+    setupMcpServerHandlers() {
+        // Register all tools using TOOL_DEFINITION from handlers
+        // McpServer automatically handles listTools requests for registered tools
+        this.registerAllToolsOnServer(this.mcpServer);
+    }
+    setupSignalHandlers() {
+        const signals = ["SIGINT", "SIGTERM"];
+        for (const signal of signals) {
+            process.on(signal, () => {
+                if (this.shuttingDown) {
+                    return;
+                }
+                this.shuttingDown = true;
+                logger_1.logger.info("Received shutdown signal", {
+                    type: "SERVER_SHUTDOWN_SIGNAL",
+                    signal,
+                    transport: this.transportConfig.type,
+                });
+                void this.shutdown().finally(() => {
+                    if (this.allowProcessExit) {
+                        process.exit(0);
+                    }
+                });
+            });
+        }
+    }
+    async shutdown() {
+        try {
+            await this.mcpServer.close();
+        }
+        catch (error) {
+            logger_1.logger.error("Failed to close MCP server", {
+                type: "SERVER_SHUTDOWN_ERROR",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        // Close all SSE sessions
+        for (const [sessionId, session] of this.sseSessions.entries()) {
+            try {
+                await session.transport.close();
+                session.server.server.close();
+                logger_1.logger.debug("SSE session closed during shutdown", {
+                    type: "SSE_SESSION_SHUTDOWN",
+                    sessionId,
+                });
+            }
+            catch (error) {
+                logger_1.logger.error("Failed to close SSE session", {
+                    type: "SSE_SHUTDOWN_ERROR",
+                    error: error instanceof Error ? error.message : String(error),
+                    sessionId,
+                });
+            }
+        }
+        this.sseSessions.clear();
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer?.close((closeError) => {
+                    if (closeError) {
+                        logger_1.logger.error("Failed to close HTTP server", {
+                            type: "HTTP_SERVER_SHUTDOWN_ERROR",
+                            error: closeError instanceof Error ? closeError.message : String(closeError),
+                        });
+                    }
+                    resolve();
+                });
+            });
+            this.httpServer = undefined;
+        }
+    }
+    /**
+     * Starts the MCP server and connects it to the transport.
+     */
+    async run() {
+        if (this.transportConfig.type === "stdio") {
+            // Simple stdio setup like reference implementation
+            const transport = new stdio_js_1.StdioServerTransport();
+            await this.mcpServer.server.connect(transport);
+            // Process stays alive waiting for messages from stdin
+            return;
+        }
+        if (this.transportConfig.type === "streamable-http") {
+            const httpConfig = this.transportConfig;
+            // HTTP Server wrapper for StreamableHTTP transport (like the SDK example)
+            const httpServer = (0, http_1.createServer)(async (req, res) => {
+                // Only handle POST requests (like the example)
+                if (req.method !== "POST") {
+                    res.writeHead(405, { "Content-Type": "text/plain" });
+                    res.end("Method not allowed");
+                    return;
+                }
+                // HTTP: Restrict non-local connections if .env file exists and no SAP headers provided
+                const remoteAddress = req.socket.remoteAddress;
+                if (this.hasEnvFile && !this.hasSapHeaders(req.headers)) {
+                    if (!this.isLocalConnection(remoteAddress)) {
+                        logger_1.logger.warn("HTTP: Non-local connection rejected (has .env but no SAP headers)", {
+                            type: "HTTP_NON_LOCAL_REJECTED",
+                            remoteAddress,
+                            hasEnvFile: this.hasEnvFile,
+                        });
+                        res.writeHead(403, { "Content-Type": "text/plain" });
+                        res.end("Forbidden: Non-local connections require SAP connection headers (x-sap-url, x-sap-auth-type)");
+                        return;
+                    }
+                }
+                // Track client (like the example)
+                const clientID = `${req.socket.remoteAddress}:${req.socket.remotePort}`;
+                logger_1.logger.debug("Client connected", {
+                    type: "STREAMABLE_HTTP_CLIENT_CONNECTED",
+                    clientID,
+                });
+                // Extract session ID from headers (like the example)
+                const clientSessionId = (req.headers["x-session-id"] || req.headers["mcp-session-id"]);
+                let session = this.streamableHttpSessions.get(clientID);
+                // If client sent session ID, try to find existing session
+                if (clientSessionId && !session) {
+                    // Search for existing session by sessionId (client might have new IP:PORT)
+                    for (const [key, sess] of this.streamableHttpSessions.entries()) {
+                        if (sess.sessionId === clientSessionId) {
+                            session = sess;
+                            // Update clientID (port might have changed)
+                            this.streamableHttpSessions.delete(key);
+                            this.streamableHttpSessions.set(clientID, session);
+                            logger_1.logger.debug("Existing session restored", {
+                                type: "STREAMABLE_HTTP_SESSION_RESTORED",
+                                sessionId: session.sessionId,
+                                clientID,
+                            });
+                            break;
+                        }
+                    }
+                }
+                // If no session found, create new one
+                if (!session) {
+                    session = {
+                        sessionId: (0, crypto_1.randomUUID)(),
+                        clientIP: req.socket.remoteAddress || "unknown",
+                        connectedAt: new Date(),
+                        requestCount: 0,
+                    };
+                    this.streamableHttpSessions.set(clientID, session);
+                    logger_1.logger.debug("New session created", {
+                        type: "STREAMABLE_HTTP_SESSION_CREATED",
+                        sessionId: session.sessionId,
+                        clientID,
+                        totalSessions: this.streamableHttpSessions.size,
+                    });
+                }
+                session.requestCount++;
+                logger_1.logger.debug("Request received", {
+                    type: "STREAMABLE_HTTP_REQUEST",
+                    sessionId: session.sessionId,
+                    requestNumber: session.requestCount,
+                    clientID,
+                });
+                // Handle client disconnect (like the example)
+                req.on("close", () => {
+                    const closedSession = this.streamableHttpSessions.get(clientID);
+                    if (closedSession) {
+                        // Clean up connection cache for this session
+                        if (closedSession.sapConfig) {
+                            (0, utils_1.removeConnectionForSession)(closedSession.sessionId, closedSession.sapConfig);
+                        }
+                        this.streamableHttpSessions.delete(clientID);
+                        logger_1.logger.debug("Session closed", {
+                            type: "STREAMABLE_HTTP_SESSION_CLOSED",
+                            sessionId: closedSession.sessionId,
+                            requestCount: closedSession.requestCount,
+                            totalSessions: this.streamableHttpSessions.size,
+                        });
+                    }
+                });
+                try {
+                    // Apply auth headers before processing and store config in session
+                    this.applyAuthHeaders(req.headers, session.sessionId);
+                    // Get SAP config for this session (from headers or existing session)
+                    const sessionSapConfig = session.sapConfig || this.sapConfig;
+                    // Read request body (like the SDK example with Express)
+                    let body = null;
+                    const chunks = [];
+                    for await (const chunk of req) {
+                        chunks.push(chunk);
+                    }
+                    if (chunks.length > 0) {
+                        const bodyString = Buffer.concat(chunks).toString('utf-8');
+                        try {
+                            body = JSON.parse(bodyString);
+                        }
+                        catch (parseError) {
+                            // If body is not JSON, pass as string or null
+                            body = bodyString || null;
+                        }
+                    }
+                    // KEY MOMENT: Create new StreamableHTTP transport for each request (like the SDK example)
+                    // SDK automatically handles:
+                    // - Chunked transfer encoding
+                    // - Session tracking
+                    // - JSON-RPC protocol
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined, // Stateless mode (like the SDK example)
+                        enableJsonResponse: httpConfig.enableJsonResponse,
+                        allowedOrigins: httpConfig.allowedOrigins,
+                        allowedHosts: httpConfig.allowedHosts,
+                        enableDnsRebindingProtection: httpConfig.enableDnsRebindingProtection,
+                    });
+                    // Close transport when response closes (like the SDK example)
+                    res.on("close", () => {
+                        transport.close();
+                    });
+                    // Connect transport to new McpServer (like the SDK example)
+                    await this.mcpServer.connect(transport);
+                    logger_1.logger.debug("Transport connected", {
+                        type: "STREAMABLE_HTTP_TRANSPORT_CONNECTED",
+                        sessionId: session.sessionId,
+                        clientID,
+                    });
+                    // Run handlers in AsyncLocalStorage context with session info
+                    // This allows getManagedConnection() to access sessionId and config
+                    await utils_1.sessionContext.run({
+                        sessionId: session.sessionId,
+                        sapConfig: sessionSapConfig,
+                    }, async () => {
+                        // Handle HTTP request through transport (like the SDK example)
+                        // Pass body as third parameter if available (like the SDK example)
+                        await transport.handleRequest(req, res, body);
+                    });
+                    logger_1.logger.debug("Request completed", {
+                        type: "STREAMABLE_HTTP_REQUEST_COMPLETED",
+                        sessionId: session.sessionId,
+                        clientID,
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.error("Failed to handle HTTP request", {
+                        type: "HTTP_REQUEST_ERROR",
+                        error: error instanceof Error ? error.message : String(error),
+                        sessionId: session.sessionId,
+                        clientID,
+                    });
+                    if (!res.headersSent) {
+                        res.writeHead(500).end("Internal Server Error");
+                    }
+                    else {
+                        res.end();
+                    }
+                }
+            });
+            httpServer.on("clientError", (err, socket) => {
+                logger_1.logger.error("HTTP client error", {
+                    type: "HTTP_CLIENT_ERROR",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+            });
+            await new Promise((resolve, reject) => {
+                const onError = (error) => {
+                    logger_1.logger.error("HTTP server failed to start", {
+                        type: "HTTP_SERVER_ERROR",
+                        error: error.message,
+                    });
+                    httpServer.off("error", onError);
+                    reject(error);
+                };
+                httpServer.once("error", onError);
+                httpServer.listen(httpConfig.port, httpConfig.host, () => {
+                    httpServer.off("error", onError);
+                    logger_1.logger.info("HTTP server listening", {
+                        type: "HTTP_SERVER_LISTENING",
+                        host: httpConfig.host,
+                        port: httpConfig.port,
+                        enableJsonResponse: httpConfig.enableJsonResponse,
+                    });
+                    resolve();
+                });
+            });
+            this.httpServer = httpServer;
+            return;
+        }
+        const sseConfig = this.transportConfig;
+        const streamPathMap = new Map([
+            ["/", "/messages"],
+            ["/mcp/events", "/mcp/messages"],
+            ["/sse", "/messages"],
+        ]);
+        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) => {
+            // SSE: Always restrict to local connections only
+            const remoteAddress = req.socket.remoteAddress;
+            if (!this.isLocalConnection(remoteAddress)) {
+                logger_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");
+                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("/")) {
+                pathname = pathname.slice(0, -1);
+            }
+            this.applyAuthHeaders(req.headers);
+            logger_1.logger.debug("SSE request received", {
+                type: "SSE_HTTP_REQUEST",
+                method: req.method,
+                pathname,
+                originalUrl: req.url,
+                headers: {
+                    accept: req.headers.accept,
+                    "content-type": req.headers["content-type"],
+                },
+            });
+            // GET /sse, /mcp/events, or / - establish SSE connection
+            if (req.method === "GET" && streamPathMap.has(pathname)) {
+                const postEndpoint = streamPathMap.get(pathname) ?? "/messages";
+                logger_1.logger.debug("SSE client connecting", {
+                    type: "SSE_CLIENT_CONNECTING",
+                    pathname,
+                    postEndpoint,
+                });
+                // Create new McpServer instance for this session (like the working example)
+                const server = this.createMcpServerForSession();
+                // Create SSE transport
+                const transport = new sse_js_1.SSEServerTransport(postEndpoint, res, {
+                    allowedHosts: sseConfig.allowedHosts,
+                    allowedOrigins: sseConfig.allowedOrigins,
+                    enableDnsRebindingProtection: sseConfig.enableDnsRebindingProtection,
+                });
+                const sessionId = transport.sessionId;
+                logger_1.logger.info("New SSE session created", {
+                    type: "SSE_SESSION_CREATED",
+                    sessionId,
+                    pathname,
+                });
+                // Store transport and server for this session
+                this.sseSessions.set(sessionId, {
+                    server,
+                    transport,
+                });
+                // Connect transport to server (using server.server like in the example)
+                try {
+                    await server.server.connect(transport);
+                    logger_1.logger.info("SSE transport connected", {
+                        type: "SSE_CONNECTION_READY",
+                        sessionId,
+                        pathname,
+                        postEndpoint,
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.error("Failed to connect SSE transport", {
+                        type: "SSE_CONNECT_ERROR",
+                        error: error instanceof Error ? error.message : String(error),
+                        sessionId,
+                    });
+                    this.sseSessions.delete(sessionId);
+                    if (!res.headersSent) {
+                        res.writeHead(500).end("Internal Server Error");
+                    }
+                    else {
+                        res.end();
+                    }
+                    return;
+                }
+                // Cleanup on connection close
+                res.on("close", () => {
+                    logger_1.logger.info("SSE connection closed", {
+                        type: "SSE_CONNECTION_CLOSED",
+                        sessionId,
+                        pathname,
+                    });
+                    this.sseSessions.delete(sessionId);
+                    server.server.close();
+                });
+                transport.onerror = (error) => {
+                    logger_1.logger.error("SSE transport error", {
+                        type: "SSE_TRANSPORT_ERROR",
+                        error: error instanceof Error ? error.message : String(error),
+                        sessionId,
+                    });
+                };
+                return;
+            }
+            // POST /messages or /mcp/messages - handle client messages
+            if (req.method === "POST" && postPathSet.has(pathname)) {
+                // Extract sessionId from query string or header
+                let sessionId;
+                if (requestUrl) {
+                    sessionId = requestUrl.searchParams.get("sessionId") || undefined;
+                }
+                if (!sessionId) {
+                    sessionId = req.headers["x-session-id"];
+                }
+                logger_1.logger.debug("SSE POST request received", {
+                    type: "SSE_POST_REQUEST",
+                    sessionId,
+                    pathname,
+                });
+                if (!sessionId || !this.sseSessions.has(sessionId)) {
+                    logger_1.logger.error("Invalid or missing SSE session", {
+                        type: "SSE_INVALID_SESSION",
+                        sessionId,
+                    });
+                    res.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Invalid or missing sessionId",
+                        },
+                        id: null,
+                    }));
+                    return;
+                }
+                const session = this.sseSessions.get(sessionId);
+                const { transport } = session;
+                try {
+                    // Read request body
+                    let body = null;
+                    const chunks = [];
+                    for await (const chunk of req) {
+                        chunks.push(chunk);
+                    }
+                    if (chunks.length > 0) {
+                        const bodyString = Buffer.concat(chunks).toString('utf-8');
+                        try {
+                            body = JSON.parse(bodyString);
+                        }
+                        catch (parseError) {
+                            body = bodyString || null;
+                        }
+                    }
+                    // Handle POST message through transport (like the working example)
+                    await transport.handlePostMessage(req, res, body);
+                    logger_1.logger.debug("SSE POST request processed", {
+                        type: "SSE_POST_PROCESSED",
+                        sessionId,
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.error("Failed to handle SSE POST message", {
+                        type: "SSE_POST_ERROR",
+                        error: error instanceof Error ? error.message : String(error),
+                        sessionId,
+                    });
+                    if (!res.headersSent) {
+                        res.writeHead(500).end("Internal Server Error");
+                    }
+                    else {
+                        res.end();
+                    }
+                }
+                return;
+            }
+            // OPTIONS - CORS preflight
+            if (req.method === "OPTIONS" && (streamPathMap.has(pathname) || postPathSet.has(pathname))) {
+                res.writeHead(204, {
+                    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+                    "Access-Control-Allow-Headers": "Content-Type",
+                }).end();
+                return;
+            }
+            res.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "Not Found" }));
+        });
+        httpServer.on("clientError", (err, socket) => {
+            logger_1.logger.error("SSE HTTP client error", {
+                type: "SSE_HTTP_CLIENT_ERROR",
+                error: err instanceof Error ? err.message : String(err),
+            });
+            socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                logger_1.logger.error("SSE HTTP server failed to start", {
+                    type: "SSE_HTTP_SERVER_ERROR",
+                    error: error.message,
+                });
+                httpServer.off("error", onError);
+                reject(error);
+            };
+            httpServer.once("error", onError);
+            httpServer.listen(sseConfig.port, sseConfig.host, () => {
+                httpServer.off("error", onError);
+                logger_1.logger.info("SSE HTTP server listening", {
+                    type: "SSE_HTTP_SERVER_LISTENING",
+                    host: sseConfig.host,
+                    port: sseConfig.port,
+                    streamPaths,
+                    postPaths: Array.from(postPathSet.values()),
+                });
+                resolve();
+            });
+        });
+        this.httpServer = httpServer;
+    }
+}
+exports.mcp_abap_adt_server = mcp_abap_adt_server;
+if (process.env.MCP_SKIP_AUTO_START !== "true") {
+    const server = new mcp_abap_adt_server();
+    server.run().catch((error) => {
+        logger_1.logger.error("Fatal error while running MCP server", {
+            type: "SERVER_FATAL_ERROR",
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Always write to stderr (safe even in stdio mode)
+        process.stderr.write(`[MCP] ✗ Fatal error: ${error instanceof Error ? error.message : String(error)}\n`);
+        // On Windows, add a small delay before exit to allow error message to be visible
+        if (process.platform === 'win32') {
+            setTimeout(() => process.exit(1), 100);
+        }
+        else {
+            process.exit(1);
+        }
+    });
+}