@mcp-abap-adt/core 2.5.2 → 2.7.0

package/dist/handlers/ddlx/handleCreateMetadataExtension.js

@@ -1,92 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,81 +0,0 @@
-"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

@@ -1,104 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,187 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,138 +0,0 @@
-"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);
-    }
-}