@mcp-abap-adt/core 2.5.0 → 2.5.2

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 ## [Unreleased]
 
+## [2.5.2] - 2026-02-23
+### Fixed
+- **`--mcp` precedence over local `.env`**:
+  - Fixed CLI fallback logic so `.env` from current working directory is no longer auto-loaded when `--mcp=<destination>` is provided.
+  - Startup auth source display now correctly prioritizes `service-key: <destination>` over `.env`.
+- **JWT auth error diagnostics**:
+  - Improved HTTP/SSE request-time error reporting for missing JWT tokens by surfacing token provider failure reason in `BaseMcpServer`.
+- **Auth broker runtime behavior**:
+  - Fixed v2 auth-broker config to respect `--unsafe` instead of always forcing safe in-memory stores.
+
+### Added
+- **Browser OAuth callback port override**:
+  - Added `--browser-auth-port=<port>` and `MCP_BROWSER_AUTH_PORT` to override auth callback server port (useful when default ports are occupied).
+- **Inspector runtime dependency safety**:
+  - Added explicit `express-rate-limit` dev dependency to avoid missing transitive package issues during `dev:http` inspector startup.
+
+### Documentation
+- Updated auth and CLI docs for `--mcp` behavior and browser auth callback port override:
+  - `README.md`
+  - `docs/user-guide/AUTHENTICATION.md`
+  - CLI help text via `ServerConfigManager`.
+
+## [2.5.1] - 2026-02-21
+### Changed
+- **Compact handler descriptions**:
+  - Reworked compact handler descriptions to be explicit and deterministic for tool routing.
+  - Added per-`object_type` required parameter mapping directly in handler descriptions (`TYPE(param*)` format).
+  - Clarified read vs validate intent to avoid `HandlerGet` / `HandlerValidate` confusion.
+- **Compact schemas metadata**:
+  - Added missing parameter descriptions in compact schemas to remove `No description` in generated tool docs.
+
+### Documentation
+- Regenerated tools documentation:
+  - `docs/user-guide/AVAILABLE_TOOLS.md`
+  - `docs/user-guide/AVAILABLE_TOOLS_HIGH.md`
+  - `docs/user-guide/AVAILABLE_TOOLS_COMPACT.md`
+
+## [2.5.0] - 2026-02-21
+### Added
+- **Compact facade CRUD routing**:
+  - Added compact facade CRUD operations routed by `object_type`.
+  - Added compact router/matrix coverage for supported object/action combinations.
+- **Compact lifecycle and test handlers**:
+  - Added compact handlers for validation, unlock, and unit test workflows.
+
+### Changed
+- **Compact routing architecture**:
+  - Removed legacy `HandlerAction` path and standardized on dedicated compact handlers.
+
 ## [2.4.2] - 2026-02-20
 ### Added
 - **Service Binding high-level tools**:

package/README.md

@@ -299,8 +299,11 @@ Inline comments are not parsed, so keep comments on separate lines.
 **Authentication:**
 - `--auth-broker` - Force use of auth-broker (service keys), ignore .env file
 - `--auth-broker-path=<path>` - Custom path for auth-broker service keys and sessions
+- `--browser-auth-port=<port>` - Override OAuth browser callback port (default: 5000 for HTTP, 4000 for SSE, 4001 for stdio)
 - `--unsafe` - Enable file-based session storage (persists tokens to disk). By default, sessions are stored in-memory (secure, lost on restart)
 
+When `--mcp=<destination>` is specified, automatic fallback loading of `./.env` is skipped.
+
 **Examples:**
 ```bash
 # Use auth-broker with file-based session storage (persists tokens)

package/dist/handlers/bdef/handleCreateBehaviorDefinition.d.ts

@@ -0,0 +1,50 @@
+/**
+ * CreateBehaviorDefinition Handler - ABAP Behavior Definition Creation via ADT API
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateBehaviorDefinition";
+    readonly description: "Create a new ABAP Behavior Definition (BDEF) in SAP system.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Behavior Definition name (usually same as Root Entity name)";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Description";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number";
+            };
+            readonly root_entity: {
+                readonly type: "string";
+                readonly description: "Root Entity name (CDS View name)";
+            };
+            readonly implementation_type: {
+                readonly type: "string";
+                readonly description: "Implementation type: 'Managed', 'Unmanaged', 'Abstract', 'Projection'";
+                readonly enum: readonly ["Managed", "Unmanaged", "Abstract", "Projection"];
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after creation. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "package_name", "root_entity", "implementation_type"];
+    };
+};
+export declare function handleCreateBehaviorDefinition(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateBehaviorDefinition.d.ts.map

package/dist/handlers/bdef/handleCreateBehaviorDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateBehaviorDefinition.d.ts","sourceRoot":"","sources":["../../../src/handlers/bdef/handleCreateBehaviorDefinition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClB,CAAC;AAYX,wBAAsB,8BAA8B,CAAC,MAAM,EAAE,GAAG;;;;;;GAqE/D"}

package/dist/handlers/bdef/handleCreateBehaviorDefinition.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * CreateBehaviorDefinition Handler - ABAP Behavior Definition Creation via ADT API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateBehaviorDefinition = handleCreateBehaviorDefinition;
+const utils_1 = require("../../lib/utils");
+const transportValidation_js_1 = require("../../utils/transportValidation.js");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateBehaviorDefinition",
+    description: "Create a new ABAP Behavior Definition (BDEF) in SAP system.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Behavior Definition name (usually same as Root Entity name)"
+            },
+            description: {
+                type: "string",
+                description: "Description"
+            },
+            package_name: {
+                type: "string",
+                description: "Package name"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number"
+            },
+            root_entity: {
+                type: "string",
+                description: "Root Entity name (CDS View name)"
+            },
+            implementation_type: {
+                type: "string",
+                description: "Implementation type: 'Managed', 'Unmanaged', 'Abstract', 'Projection'",
+                enum: ["Managed", "Unmanaged", "Abstract", "Projection"]
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate after creation. Default: true"
+            }
+        },
+        required: ["name", "package_name", "root_entity", "implementation_type"]
+    }
+};
+async function handleCreateBehaviorDefinition(params) {
+    const args = params;
+    if (!args.name || !args.package_name || !args.root_entity || !args.implementation_type) {
+        return (0, utils_1.return_error)(new Error("Missing required parameters"));
+    }
+    try {
+        (0, transportValidation_js_1.validateTransportRequest)(args.package_name, args.transport_request);
+    }
+    catch (error) {
+        return (0, utils_1.return_error)(error);
+    }
+    const name = args.name.toUpperCase();
+    const connection = (0, utils_1.getManagedConnection)();
+    utils_1.logger.info(`Starting BDEF creation: ${name}`);
+    try {
+        const client = new adt_clients_1.CrudClient(connection);
+        const shouldActivate = args.activate !== false;
+        // Create
+        await client.createBehaviorDefinition(name, args.description || name, args.package_name, args.transport_request || '', args.root_entity, args.implementation_type);
+        // Lock
+        await client.lockBehaviorDefinition(name);
+        const lockHandle = client.getLockHandle();
+        // Check (optional, but good practice)
+        await client.checkBehaviorDefinition(name);
+        // Unlock
+        await client.unlockBehaviorDefinition(name, lockHandle);
+        // Activate if requested
+        if (shouldActivate) {
+            await client.activateBehaviorDefinition(name);
+        }
+        const result = {
+            success: true,
+            name: name,
+            package_name: args.package_name,
+            type: 'BDEF',
+            message: shouldActivate
+                ? `Behavior Definition ${name} created and activated successfully`
+                : `Behavior Definition ${name} created successfully`
+        };
+        return (0, utils_1.return_response)({
+            data: JSON.stringify(result, null, 2),
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            config: {}
+        });
+    }
+    catch (error) {
+        utils_1.logger.error(`Error creating BDEF ${name}:`, error);
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/bdef/handleGetBdef.d.ts

@@ -0,0 +1,54 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetBdef";
+    readonly description: "Retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly bdef_name: {
+                readonly type: "string";
+                readonly description: "Name of the BDEF (Behavior Definition)";
+            };
+        };
+        readonly required: readonly ["bdef_name"];
+    };
+};
+/**
+ * Interface for BDEF (Behavior Definition) response
+ */
+export interface BdefResponse {
+    bdef_name: string;
+    source_code?: string;
+    functions?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+/**
+ * Handler to retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.
+ * Uses the SAP ADT API endpoint for behavior definitions.
+ *
+ * @param args - Tool arguments containing:
+ *   - bdef_name: Name of the BDEF (Behavior Definition) (e.g., 'Z_I_MYENTITY')
+ * @returns Response object containing:
+ *   - bdef_name: The name of the BDEF
+ *   - source_code: The source code of the BDEF (if found)
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes
+ *   - In case of error, an error object with details about the failure
+ */
+export declare function handleGetBdef(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            bdef_name: any;
+            source_code: string;
+        };
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetBdef.d.ts.map

package/dist/handlers/bdef/handleGetBdef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetBdef.d.ts","sourceRoot":"","sources":["../../../src/handlers/bdef/handleGetBdef.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAelB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;GA2D5C"}

package/dist/handlers/bdef/handleGetBdef.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetBdef = handleGetBdef;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+exports.TOOL_DEFINITION = {
+    "name": "GetBdef",
+    "description": "Retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "bdef_name": {
+                "type": "string",
+                "description": "Name of the BDEF (Behavior Definition)"
+            }
+        },
+        "required": [
+            "bdef_name"
+        ]
+    }
+};
+/**
+ * Handler to retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.
+ * Uses the SAP ADT API endpoint for behavior definitions.
+ *
+ * @param args - Tool arguments containing:
+ *   - bdef_name: Name of the BDEF (Behavior Definition) (e.g., 'Z_I_MYENTITY')
+ * @returns Response object containing:
+ *   - bdef_name: The name of the BDEF
+ *   - source_code: The source code of the BDEF (if found)
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes
+ *   - In case of error, an error object with details about the failure
+ */
+async function handleGetBdef(args) {
+    try {
+        utils_2.logger.info('handleGetBdef called with args:', args);
+        if (!args?.bdef_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'BDEF name is required');
+        }
+        const bdefName = args.bdef_name;
+        const bdefUri = args.bdef_uri; // Optional: full ADT URI
+        utils_2.logger.info(`Getting BDEF source for: ${bdefName}${bdefUri ? ` (uri: ${bdefUri})` : ''}`);
+        const baseUrl = await (0, utils_2.getBaseUrl)();
+        // Always use the simple, direct endpoint as in the Python code
+        const endpoint = `${baseUrl}/sap/bc/adt/bo/behaviordefinitions/${(0, utils_2.encodeSapObjectName)(bdefName)}/source/main`;
+        utils_2.logger.info(`Requesting BDEF source from: ${endpoint}`);
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(endpoint, 'GET', 'default', {
+            'Accept': 'text/plain'
+        });
+        if (response.status === 200 && typeof response.data === "string") {
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: {
+                            bdef_name: bdefName,
+                            source_code: response.data
+                        }
+                    }
+                ]
+            };
+            if (args.filePath) {
+                const fs = require('fs');
+                fs.writeFileSync(args.filePath, JSON.stringify(result, null, 2), 'utf-8');
+            }
+            return result;
+        }
+        else if (response.status === 404) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Behavior definition '${bdefName}' not found`);
+        }
+        else {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to retrieve BDEF ${bdefName}. Status: ${response.status}`);
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/bdef/handleUpdateBehaviorDefinition.d.ts

@@ -0,0 +1,37 @@
+/**
+ * UpdateBehaviorDefinition Handler - ABAP Behavior Definition Update via ADT API
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateBehaviorDefinition";
+    readonly description: "Update source code of an ABAP Behavior Definition.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Behavior Definition name";
+            };
+            readonly source_code: {
+                readonly type: "string";
+                readonly description: "New source code";
+            };
+            readonly lock_handle: {
+                readonly type: "string";
+                readonly description: "Lock handle from LockObject. If not provided, will attempt to lock internally (not recommended for stateful flows).";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after update. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "source_code"];
+    };
+};
+export declare function handleUpdateBehaviorDefinition(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUpdateBehaviorDefinition.d.ts.map

package/dist/handlers/bdef/handleUpdateBehaviorDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateBehaviorDefinition.d.ts","sourceRoot":"","sources":["../../../src/handlers/bdef/handleUpdateBehaviorDefinition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AASX,wBAAsB,8BAA8B,CAAC,MAAM,EAAE,GAAG;;;;;;GA0D/D"}

package/dist/handlers/bdef/handleUpdateBehaviorDefinition.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * UpdateBehaviorDefinition Handler - ABAP Behavior Definition Update via ADT API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleUpdateBehaviorDefinition = handleUpdateBehaviorDefinition;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "UpdateBehaviorDefinition",
+    description: "Update source code of an ABAP Behavior Definition.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Behavior Definition name"
+            },
+            source_code: {
+                type: "string",
+                description: "New source code"
+            },
+            lock_handle: {
+                type: "string",
+                description: "Lock handle from LockObject. If not provided, will attempt to lock internally (not recommended for stateful flows)."
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate after update. Default: true"
+            }
+        },
+        required: ["name", "source_code"]
+    }
+};
+async function handleUpdateBehaviorDefinition(params) {
+    const args = params;
+    if (!args.name || !args.source_code) {
+        return (0, utils_1.return_error)(new Error("Missing required parameters"));
+    }
+    const name = args.name.toUpperCase();
+    const connection = (0, utils_1.getManagedConnection)();
+    try {
+        const client = new adt_clients_1.CrudClient(connection);
+        const shouldActivate = args.activate !== false;
+        let lockHandle = args.lock_handle;
+        // Lock if not provided
+        if (!lockHandle) {
+            await client.lockBehaviorDefinition(name);
+            lockHandle = client.getLockHandle();
+        }
+        // Update
+        await client.updateBehaviorDefinition(name, args.source_code, lockHandle);
+        // Unlock if we locked it internally
+        if (!args.lock_handle) {
+            await client.unlockBehaviorDefinition(name, lockHandle);
+        }
+        // Activate if requested
+        if (shouldActivate) {
+            // Note: If we locked internally, we unlocked, so activation might fail if it requires lock?
+            // Usually activation is separate. But if we provided lock_handle, we keep it locked?
+            // Standard practice: Update requires lock. Activation might not, or might require its own lock check.
+            // CrudClient.activateBehaviorDefinition doesn't take lock handle.
+            await client.activateBehaviorDefinition(name);
+        }
+        const result = {
+            success: true,
+            name: name,
+            message: shouldActivate
+                ? `Behavior Definition ${name} updated and activated successfully`
+                : `Behavior Definition ${name} updated successfully`
+        };
+        return (0, utils_1.return_response)({
+            data: JSON.stringify(result, null, 2),
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            config: {}
+        });
+    }
+    catch (error) {
+        utils_1.logger.error(`Error updating BDEF ${name}:`, error);
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/behavior_definition/readonly/handleGetBdef.d.ts

@@ -0,0 +1,54 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetBdef";
+    readonly description: "[read-only] Retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly bdef_name: {
+                readonly type: "string";
+                readonly description: "Name of the BDEF (Behavior Definition)";
+            };
+        };
+        readonly required: readonly ["bdef_name"];
+    };
+};
+/**
+ * Interface for BDEF (Behavior Definition) response
+ */
+export interface BdefResponse {
+    bdef_name: string;
+    source_code?: string;
+    functions?: Array<{
+        name: string;
+        description?: string;
+    }>;
+}
+/**
+ * Handler to retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.
+ * Uses the SAP ADT API endpoint for behavior definitions.
+ *
+ * @param args - Tool arguments containing:
+ *   - bdef_name: Name of the BDEF (Behavior Definition) (e.g., 'Z_I_MYENTITY')
+ * @returns Response object containing:
+ *   - bdef_name: The name of the BDEF
+ *   - source_code: The source code of the BDEF (if found)
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes
+ *   - In case of error, an error object with details about the failure
+ */
+export declare function handleGetBdef(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            bdef_name: any;
+            source_code: string;
+        };
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetBdef.d.ts.map

package/dist/handlers/behavior_definition/readonly/handleGetBdef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetBdef.d.ts","sourceRoot":"","sources":["../../../../src/handlers/behavior_definition/readonly/handleGetBdef.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAelB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;GA2D5C"}

package/dist/handlers/behavior_definition/readonly/handleGetBdef.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetBdef = handleGetBdef;
+const utils_1 = require("../../../lib/utils");
+const utils_2 = require("../../../lib/utils");
+exports.TOOL_DEFINITION = {
+    "name": "GetBdef",
+    "description": "[read-only] Retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "bdef_name": {
+                "type": "string",
+                "description": "Name of the BDEF (Behavior Definition)"
+            }
+        },
+        "required": [
+            "bdef_name"
+        ]
+    }
+};
+/**
+ * Handler to retrieve the source code of a BDEF (Behavior Definition) for a CDS entity.
+ * Uses the SAP ADT API endpoint for behavior definitions.
+ *
+ * @param args - Tool arguments containing:
+ *   - bdef_name: Name of the BDEF (Behavior Definition) (e.g., 'Z_I_MYENTITY')
+ * @returns Response object containing:
+ *   - bdef_name: The name of the BDEF
+ *   - source_code: The source code of the BDEF (if found)
+ *   - raw_xml: The raw XML response from the ADT API for debugging purposes
+ *   - In case of error, an error object with details about the failure
+ */
+async function handleGetBdef(args) {
+    try {
+        utils_2.logger.info('handleGetBdef called with args:', args);
+        if (!args?.bdef_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'BDEF name is required');
+        }
+        const bdefName = args.bdef_name;
+        const bdefUri = args.bdef_uri; // Optional: full ADT URI
+        utils_2.logger.info(`Getting BDEF source for: ${bdefName}${bdefUri ? ` (uri: ${bdefUri})` : ''}`);
+        const baseUrl = await (0, utils_2.getBaseUrl)();
+        // Always use the simple, direct endpoint as in the Python code
+        const endpoint = `${baseUrl}/sap/bc/adt/bo/behaviordefinitions/${(0, utils_2.encodeSapObjectName)(bdefName)}/source/main`;
+        utils_2.logger.info(`Requesting BDEF source from: ${endpoint}`);
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(endpoint, 'GET', 'default', {
+            'Accept': 'text/plain'
+        });
+        if (response.status === 200 && typeof response.data === "string") {
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: {
+                            bdef_name: bdefName,
+                            source_code: response.data
+                        }
+                    }
+                ]
+            };
+            if (args.filePath) {
+                const fs = require('fs');
+                fs.writeFileSync(args.filePath, JSON.stringify(result, null, 2), 'utf-8');
+            }
+            return result;
+        }
+        else if (response.status === 404) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Behavior definition '${bdefName}' not found`);
+        }
+        else {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to retrieve BDEF ${bdefName}. Status: ${response.status}`);
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}