@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/ddlx/handleCreateMetadataExtension.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * CreateMetadataExtension Handler - ABAP Metadata Extension Creation via ADT API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateMetadataExtension = handleCreateMetadataExtension;
+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: "CreateMetadataExtension",
+    description: "Create a new ABAP Metadata Extension (DDLX) in SAP system.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Metadata Extension name"
+            },
+            description: {
+                type: "string",
+                description: "Description"
+            },
+            package_name: {
+                type: "string",
+                description: "Package name"
+            },
+            transport_request: {
+                type: "string",
+                description: "Transport request number"
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate after creation. Default: true"
+            }
+        },
+        required: ["name", "package_name"]
+    }
+};
+async function handleCreateMetadataExtension(params) {
+    const args = params;
+    if (!args.name || !args.package_name) {
+        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 DDLX creation: ${name}`);
+    try {
+        const client = new adt_clients_1.CrudClient(connection);
+        const shouldActivate = args.activate !== false;
+        // Create
+        await client.createMetadataExtension(name, args.description || name, args.package_name, args.transport_request || '');
+        // Lock
+        await client.lockMetadataExtension(name);
+        const lockHandle = client.getLockHandle();
+        // Check
+        await client.checkMetadataExtension(name);
+        // Unlock
+        await client.unlockMetadataExtension(name, lockHandle);
+        // Activate if requested
+        if (shouldActivate) {
+            await client.activateMetadataExtension(name);
+        }
+        const result = {
+            success: true,
+            name: name,
+            package_name: args.package_name,
+            type: 'DDLX',
+            message: shouldActivate
+                ? `Metadata Extension ${name} created and activated successfully`
+                : `Metadata Extension ${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 DDLX ${name}:`, error);
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/ddlx/handleUpdateMetadataExtension.d.ts

@@ -0,0 +1,37 @@
+/**
+ * UpdateMetadataExtension Handler - ABAP Metadata Extension Update via ADT API
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "UpdateMetadataExtension";
+    readonly description: "Update source code of an ABAP Metadata Extension.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Metadata Extension 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.";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after update. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "source_code"];
+    };
+};
+export declare function handleUpdateMetadataExtension(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleUpdateMetadataExtension.d.ts.map

package/dist/handlers/ddlx/handleUpdateMetadataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleUpdateMetadataExtension.d.ts","sourceRoot":"","sources":["../../../src/handlers/ddlx/handleUpdateMetadataExtension.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AASX,wBAAsB,6BAA6B,CAAC,MAAM,EAAE,GAAG;;;;;;GAsD9D"}

package/dist/handlers/ddlx/handleUpdateMetadataExtension.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * UpdateMetadataExtension Handler - ABAP Metadata Extension Update via ADT API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleUpdateMetadataExtension = handleUpdateMetadataExtension;
+const utils_1 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "UpdateMetadataExtension",
+    description: "Update source code of an ABAP Metadata Extension.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Metadata Extension 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."
+            },
+            activate: {
+                type: "boolean",
+                description: "Activate after update. Default: true"
+            }
+        },
+        required: ["name", "source_code"]
+    }
+};
+async function handleUpdateMetadataExtension(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.lockMetadataExtension(name);
+            lockHandle = client.getLockHandle();
+        }
+        // Update
+        await client.updateMetadataExtension(name, args.source_code, lockHandle);
+        // Unlock if we locked it internally
+        if (!args.lock_handle) {
+            await client.unlockMetadataExtension(name, lockHandle);
+        }
+        // Activate if requested
+        if (shouldActivate) {
+            await client.activateMetadataExtension(name);
+        }
+        const result = {
+            success: true,
+            name: name,
+            message: shouldActivate
+                ? `Metadata Extension ${name} updated and activated successfully`
+                : `Metadata Extension ${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 DDLX ${name}:`, error);
+        return (0, utils_1.return_error)(error);
+    }
+}

package/dist/handlers/domain/handleCreateDomain.d.ts

@@ -0,0 +1,104 @@
+/**
+ * CreateDomain Handler - ABAP Domain Creation via ADT API
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: create -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateDomain";
+    readonly description: "Create a new ABAP domain in SAP system with all required steps: lock, create, check, unlock, activate, and verify.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly domain_name: {
+                readonly type: "string";
+                readonly description: "Domain name (e.g., ZZ_TEST_0001). Must follow SAP naming conventions.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "(optional) Domain description. If not provided, domain_name will be used.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "(optional) Package name (e.g., ZOK_LOCAL, $TMP for local objects)";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "(optional) Transport request number (e.g., E19K905635). Required for transportable packages.";
+            };
+            readonly datatype: {
+                readonly type: "string";
+                readonly description: "(optional) Data type: CHAR, NUMC, DATS, TIMS, DEC, INT1, INT2, INT4, INT8, CURR, QUAN, etc.";
+                readonly default: "CHAR";
+            };
+            readonly length: {
+                readonly type: "number";
+                readonly description: "(optional) Field length (max depends on datatype)";
+                readonly default: 100;
+            };
+            readonly decimals: {
+                readonly type: "number";
+                readonly description: "(optional) Decimal places (for DEC, CURR, QUAN types)";
+                readonly default: 0;
+            };
+            readonly conversion_exit: {
+                readonly type: "string";
+                readonly description: "(optional) Conversion exit routine name (without CONVERSION_EXIT_ prefix)";
+            };
+            readonly lowercase: {
+                readonly type: "boolean";
+                readonly description: "(optional) Allow lowercase input";
+                readonly default: false;
+            };
+            readonly sign_exists: {
+                readonly type: "boolean";
+                readonly description: "(optional) Field has sign (+/-)";
+                readonly default: false;
+            };
+            readonly value_table: {
+                readonly type: "string";
+                readonly description: "(optional) Value table name for foreign key relationship";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "(optional) Activate domain after creation (default: true)";
+                readonly default: true;
+            };
+            readonly fixed_values: {
+                readonly type: "array";
+                readonly description: "(optional) Array of fixed values for domain value range";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly low: {
+                            readonly type: "string";
+                            readonly description: "Fixed value (e.g., '001', 'A')";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                            readonly description: "Description text for the fixed value";
+                        };
+                    };
+                    readonly required: readonly ["low", "text"];
+                };
+            };
+        };
+        readonly required: readonly ["domain_name"];
+    };
+};
+/**
+ * Main handler for CreateDomain MCP tool
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateDomain(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateDomain.d.ts.map

package/dist/handlers/domain/handleCreateDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateDomain.d.ts","sourceRoot":"","sources":["../../../src/handlers/domain/handleCreateDomain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFlB,CAAC;AAmBX;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GA6GjD"}

package/dist/handlers/domain/handleCreateDomain.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * CreateDomain Handler - ABAP Domain Creation via ADT API
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: create -> check -> unlock -> (activate)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateDomain = handleCreateDomain;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const transportValidation_1 = require("../../utils/transportValidation");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateDomain",
+    description: "Create a new ABAP domain in SAP system with all required steps: lock, create, check, unlock, activate, and verify.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            domain_name: {
+                type: "string",
+                description: "Domain name (e.g., ZZ_TEST_0001). Must follow SAP naming conventions."
+            },
+            description: {
+                type: "string",
+                description: "(optional) Domain description. If not provided, domain_name will be used."
+            },
+            package_name: {
+                type: "string",
+                description: "(optional) Package name (e.g., ZOK_LOCAL, $TMP for local objects)"
+            },
+            transport_request: {
+                type: "string",
+                description: "(optional) Transport request number (e.g., E19K905635). Required for transportable packages."
+            },
+            datatype: {
+                type: "string",
+                description: "(optional) Data type: CHAR, NUMC, DATS, TIMS, DEC, INT1, INT2, INT4, INT8, CURR, QUAN, etc.",
+                default: "CHAR"
+            },
+            length: {
+                type: "number",
+                description: "(optional) Field length (max depends on datatype)",
+                default: 100
+            },
+            decimals: {
+                type: "number",
+                description: "(optional) Decimal places (for DEC, CURR, QUAN types)",
+                default: 0
+            },
+            conversion_exit: {
+                type: "string",
+                description: "(optional) Conversion exit routine name (without CONVERSION_EXIT_ prefix)"
+            },
+            lowercase: {
+                type: "boolean",
+                description: "(optional) Allow lowercase input",
+                default: false
+            },
+            sign_exists: {
+                type: "boolean",
+                description: "(optional) Field has sign (+/-)",
+                default: false
+            },
+            value_table: {
+                type: "string",
+                description: "(optional) Value table name for foreign key relationship"
+            },
+            activate: {
+                type: "boolean",
+                description: "(optional) Activate domain after creation (default: true)",
+                default: true
+            },
+            fixed_values: {
+                type: "array",
+                description: "(optional) Array of fixed values for domain value range",
+                items: {
+                    type: "object",
+                    properties: {
+                        low: {
+                            type: "string",
+                            description: "Fixed value (e.g., '001', 'A')"
+                        },
+                        text: {
+                            type: "string",
+                            description: "Description text for the fixed value"
+                        }
+                    },
+                    required: ["low", "text"]
+                }
+            }
+        },
+        required: ["domain_name"]
+    }
+};
+/**
+ * Main handler for CreateDomain MCP tool
+ *
+ * Uses DomainBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateDomain(args) {
+    try {
+        // Validate required parameters
+        if (!args?.domain_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Domain name is required');
+        }
+        if (!args?.package_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Package name is required');
+        }
+        // Validate transport_request: required for non-$TMP, non-ZLOCAL packages
+        (0, transportValidation_1.validateTransportRequest)(args.package_name, args.transport_request, args.super_package);
+        const typedArgs = args;
+        const connection = (0, utils_2.getManagedConnection)();
+        const domainName = typedArgs.domain_name.toUpperCase();
+        utils_2.logger.info(`Starting domain creation: ${domainName}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            const shouldActivate = typedArgs.activate !== false; // Default to true if not specified
+            // Validate
+            await client.validateDomain(domainName);
+            // Create
+            await client.createDomain(domainName, typedArgs.description || domainName, typedArgs.package_name, typedArgs.transport_request);
+            // Lock
+            await client.lockDomain(domainName);
+            const lockHandle = client.getLockHandle();
+            // Update with properties
+            const properties = {
+                datatype: typedArgs.datatype || 'CHAR',
+                length: typedArgs.length || 100,
+                decimals: typedArgs.decimals || 0,
+                conversion_exit: typedArgs.conversion_exit,
+                lowercase: typedArgs.lowercase || false,
+                sign_exists: typedArgs.sign_exists || false,
+                value_table: typedArgs.value_table,
+                fixed_values: typedArgs.fixed_values
+            };
+            await client.updateDomain(domainName, properties, lockHandle);
+            // Check
+            await client.checkDomain(domainName);
+            // Unlock
+            await client.unlockDomain(domainName, lockHandle);
+            // Activate if requested
+            if (shouldActivate) {
+                await client.activateDomain(domainName);
+            }
+            // Get domain details from create result (createDomain already does verification)
+            const createResult = client.getCreateResult();
+            let domainDetails = null;
+            if (createResult?.data && typeof createResult.data === 'object' && 'domain_details' in createResult.data) {
+                domainDetails = createResult.data.domain_details;
+            }
+            return (0, utils_2.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    domain_name: domainName,
+                    package: typedArgs.package_name,
+                    transport_request: typedArgs.transport_request,
+                    status: shouldActivate ? 'active' : 'inactive',
+                    message: `Domain ${domainName} created${shouldActivate ? ' and activated' : ''} successfully`,
+                    domain_details: domainDetails
+                })
+            });
+        }
+        catch (error) {
+            utils_2.logger.error(`Error creating domain ${domainName}:`, error);
+            // Check if domain already exists
+            if (error.message?.includes('already exists') || error.response?.data?.includes('ExceptionResourceAlreadyExists')) {
+                throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, `Domain ${domainName} already exists. Please delete it first or use a different name.`);
+            }
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to create domain ${domainName}: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/domain/handleGetDomain.d.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetDomain";
+    readonly description: "Retrieve ABAP domain structure and properties from SAP system.";
+    readonly inputSchema: {
+        readonly domain_name: z.ZodString;
+    };
+};
+/**
+ * Main handler for GetDomain MCP tool
+ */
+export declare function handleGetDomain(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleGetDomain.d.ts.map

package/dist/handlers/domain/handleGetDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetDomain.d.ts","sourceRoot":"","sources":["../../../src/handlers/domain/handleGetDomain.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAMX;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,GAAG;;;;;;GA6F9C"}

package/dist/handlers/domain/handleGetDomain.js

@@ -0,0 +1,138 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetDomain = handleGetDomain;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetDomain",
+    description: "Retrieve ABAP domain structure and properties from SAP system.",
+    inputSchema: {
+        domain_name: z.string().describe("Domain name (e.g., MATNR, CHAR20, ZZ_TEST_DOMAIN)")
+    }
+};
+/**
+ * Main handler for GetDomain MCP tool
+ */
+async function handleGetDomain(args) {
+    try {
+        // Validate required parameters
+        if (!args?.domain_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Domain name is required');
+        }
+        const typedArgs = args;
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readDomain(typedArgs.domain_name);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read domain');
+        }
+        // Parse XML response
+        const parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+        });
+        const result = parser.parse(response.data);
+        const domain = result['doma:domain'];
+        if (!domain) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to parse domain XML response');
+        }
+        // Extract domain information
+        const domainInfo = {
+            name: domain['adtcore:name'],
+            type: domain['adtcore:type'],
+            description: domain['adtcore:description'] || '',
+            language: domain['adtcore:language'],
+            masterLanguage: domain['adtcore:masterLanguage'],
+            masterSystem: domain['adtcore:masterSystem'],
+            responsible: domain['adtcore:responsible'],
+            createdBy: domain['adtcore:createdBy'],
+            createdAt: domain['adtcore:createdAt'],
+            changedBy: domain['adtcore:changedBy'],
+            changedAt: domain['adtcore:changedAt'],
+            version: domain['adtcore:version'],
+            abapLanguageVersion: domain['adtcore:abapLanguageVersion'],
+            package: {
+                name: domain['adtcore:packageRef']?.['adtcore:name'],
+                type: domain['adtcore:packageRef']?.['adtcore:type'],
+                description: domain['adtcore:packageRef']?.['adtcore:description'],
+                uri: domain['adtcore:packageRef']?.['adtcore:uri']
+            },
+            content: domain['doma:content'] ? {
+                typeInformation: {
+                    datatype: domain['doma:content']['doma:typeInformation']?.['doma:datatype'],
+                    length: domain['doma:content']['doma:typeInformation']?.['doma:length'],
+                    decimals: domain['doma:content']['doma:typeInformation']?.['doma:decimals']
+                },
+                outputInformation: {
+                    length: domain['doma:content']['doma:outputInformation']?.['doma:length'],
+                    style: domain['doma:content']['doma:outputInformation']?.['doma:style'],
+                    conversionExit: domain['doma:content']['doma:outputInformation']?.['doma:conversionExit'] || '',
+                    signExists: domain['doma:content']['doma:outputInformation']?.['doma:signExists'],
+                    lowercase: domain['doma:content']['doma:outputInformation']?.['doma:lowercase'],
+                    ampmFormat: domain['doma:content']['doma:outputInformation']?.['doma:ampmFormat']
+                },
+                valueInformation: {
+                    valueTableRef: domain['doma:content']['doma:valueInformation']?.['doma:valueTableRef'] || '',
+                    appendExists: domain['doma:content']['doma:valueInformation']?.['doma:appendExists'],
+                    fixValues: domain['doma:content']['doma:valueInformation']?.['doma:fixValues']
+                }
+            } : null
+        };
+        return (0, utils_2.return_response)({
+            data: JSON.stringify({
+                success: true,
+                domain: domainInfo,
+                raw_xml: response.data
+            }, null, 2),
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            config: response.config
+        });
+    }
+    catch (error) {
+        console.error('[GetDomain] Error:', error);
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}