@convertcom/mcp-server 0.0.1-beta.10

package/build/executor.js

@@ -0,0 +1,783 @@
+import axios from 'axios';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { toolDefinitionMap } from './tools.js';
+import { API_BASE_URL } from './api-config.js';
+import { JSON_SCHEMA_DRAFT_2020_12, pathParamsFromTemplate } from './shared.js';
+const MAX_API_ERROR_DETAIL_LEN = 2000;
+const MAX_SCHEMA_ERRORS_TO_SHOW = 8;
+const validatorCache = new Map();
+const ajv = new Ajv2020({
+    allErrors: true,
+    strict: false,
+    allowUnionTypes: true,
+    validateFormats: false,
+});
+function resolvePathTemplate(pathTemplate, args) {
+    const params = pathParamsFromTemplate(pathTemplate);
+    let resolvedPath = pathTemplate;
+    const missing = [];
+    for (const name of params) {
+        const value = args[name];
+        if (typeof value === 'undefined' || value === null) {
+            missing.push(name);
+            continue;
+        }
+        resolvedPath = resolvedPath.replace(`{${name}}`, encodeURIComponent(String(value)));
+    }
+    return { resolvedPath, missing };
+}
+export async function executeToolByName(toolName, toolArgs) {
+    const toolDefinition = toolDefinitionMap.get(toolName);
+    if (!toolDefinition) {
+        return {
+            isError: true,
+            content: [{ type: 'text', text: 'Error: Unknown tool requested: ' + toolName }],
+            structuredContent: { error: `Unknown tool: ${toolName}` },
+        };
+    }
+    return await executeApiTool(toolName, toolDefinition, toolArgs);
+}
+async function executeApiTool(toolName, definition, toolArgs) {
+    let uploadScreenshotReadbackUrl = null;
+    try {
+        const argsToValidate = (typeof toolArgs === 'object' && toolArgs !== null) ? toolArgs : {};
+        const validation = validateToolArgs(toolName, definition.inputSchema, argsToValidate);
+        if (!validation.ok) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: validation.message }],
+                structuredContent: {
+                    error: 'InvalidArguments',
+                    tool: toolName,
+                    issues: validation.errors,
+                },
+            };
+        }
+        const validatedArgs = argsToValidate;
+        let urlPath = definition.pathTemplate;
+        const queryParams = {};
+        const headers = { 'Accept': 'application/json' };
+        let requestBodyData = undefined;
+        // Apply basic authentication (Bearer token)
+        const bearerToken = process.env.BEARER_TOKEN || process.env.API_TOKEN;
+        if (bearerToken) {
+            headers['authorization'] = `Bearer ${bearerToken}`;
+        }
+        definition.executionParameters.forEach((param) => {
+            const value = validatedArgs[param.name];
+            if (typeof value !== 'undefined' && value !== null) {
+                if (param.in === 'path') {
+                    urlPath = urlPath.replace(`{${param.name}}`, encodeURIComponent(String(value)));
+                }
+                else if (param.in === 'query') {
+                    // Always keep arrays as arrays - we'll serialize them with bracket notation later
+                    // Note: OpenAPI spec says explode=false but Convert API requires bracket notation (explode=true behavior)
+                    queryParams[param.name] = value;
+                }
+                else if (param.in === 'header') {
+                    headers[param.name.toLowerCase()] = String(value);
+                }
+            }
+        });
+        const resolved = resolvePathTemplate(urlPath, validatedArgs);
+        urlPath = resolved.resolvedPath;
+        if (resolved.missing.length) {
+            const availableArgKeys = Object.keys(validatedArgs).sort().join(', ') || '(none)';
+            throw new Error(`Failed to resolve path parameters: missing ${resolved.missing.join(', ')} for template ${definition.pathTemplate}. Provided keys: ${availableArgKeys}`);
+        }
+        // Build full URL with query string directly - don't rely on axios params serialization
+        let fullUrl = API_BASE_URL + urlPath;
+        if (Object.keys(queryParams).length > 0) {
+            // Serialize query params with bracket notation for arrays
+            const parts = [];
+            for (const [key, value] of Object.entries(queryParams)) {
+                if (Array.isArray(value)) {
+                    value.forEach((v) => {
+                        parts.push(`${key}[]=${encodeURIComponent(String(v))}`);
+                    });
+                }
+                else {
+                    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+                }
+            }
+            fullUrl = fullUrl + '?' + parts.join('&');
+        }
+        if (definition.requestBodyContentType && typeof validatedArgs['requestBody'] !== 'undefined') {
+            if (isMultipartContentType(definition.requestBodyContentType)) {
+                requestBodyData = buildMultipartFormData(validatedArgs['requestBody']);
+            }
+            else {
+                requestBodyData = validatedArgs['requestBody'];
+                headers['content-type'] = definition.requestBodyContentType;
+            }
+        }
+        const config = {
+            method: (definition.method || 'get').toUpperCase(),
+            url: fullUrl,
+            // Don't pass params - query string is already in URL
+            headers,
+            ...(requestBodyData !== undefined && { data: requestBodyData }),
+        };
+        if (toolName === 'uploadexperiencevariationscreenshot') {
+            uploadScreenshotReadbackUrl = fullUrl;
+        }
+        const response = await axios(config);
+        let responseText = '';
+        const contentType = response.headers['content-type']?.toLowerCase() || '';
+        const isJsonResponse = contentType.includes('application/json') && typeof response.data === 'object' && response.data !== null;
+        if (isJsonResponse) {
+            try {
+                responseText = JSON.stringify(response.data, null, 2);
+            }
+            catch {
+                responseText = '[Stringify Error]';
+            }
+        }
+        else if (typeof response.data === 'string') {
+            responseText = response.data;
+        }
+        else if (response.data !== undefined && response.data !== null) {
+            responseText = String(response.data);
+        }
+        else {
+            responseText = `(Status: ${response.status} - No body content)`;
+        }
+        return {
+            content: [{ type: 'text', text: `API Response (Status: ${response.status}):\n${responseText}` }],
+            structuredContent: isJsonResponse
+                ? { status: response.status, data: response.data }
+                : { status: response.status },
+        };
+    }
+    catch (error) {
+        let errorMessage;
+        if (axios.isAxiosError(error)) {
+            const recovered = await recoverUploadedScreenshot(toolName, error, uploadScreenshotReadbackUrl);
+            if (recovered)
+                return recovered;
+            errorMessage = formatApiError(error);
+        }
+        else if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        else {
+            errorMessage = `Unexpected error: ${String(error)}`;
+        }
+        console.error(`Error during execution: ${errorMessage}`);
+        return {
+            isError: true,
+            content: [{ type: 'text', text: errorMessage }],
+            structuredContent: { error: errorMessage },
+        };
+    }
+}
+export async function recoverUploadedScreenshot(toolName, error, readbackUrl) {
+    if (toolName !== 'uploadexperiencevariationscreenshot')
+        return null;
+    if (error.response?.status !== 500 || !readbackUrl)
+        return null;
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        if (attempt > 0)
+            await delay(250 * attempt);
+        try {
+            const response = await axios.get(readbackUrl, { headers: { 'Accept': 'application/json' } });
+            const data = response.data;
+            if (!isPlainObject(data) || typeof data.data !== 'string' || data.data.length === 0) {
+                continue;
+            }
+            const recoveredData = {
+                ...data,
+                warning: 'UploadReturned500ButReadbackSucceeded',
+                recovered: true,
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: `API Response (Status: 200):\n${JSON.stringify(recoveredData, null, 2)}`,
+                    }],
+                structuredContent: {
+                    status: 200,
+                    data: recoveredData,
+                    warning: 'UploadReturned500ButReadbackSucceeded',
+                    recovered: true,
+                },
+            };
+        }
+        catch {
+            // Keep the original upload failure if readback cannot verify persistence.
+        }
+    }
+    return null;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isMultipartContentType(contentType) {
+    return contentType.toLowerCase().startsWith('multipart/form-data');
+}
+function buildMultipartFormData(requestBody) {
+    const form = new FormData();
+    const fields = multipartFieldsFromBody(requestBody);
+    for (const [field, value] of Object.entries(fields)) {
+        appendMultipartField(form, field, value);
+    }
+    return form;
+}
+function multipartFieldsFromBody(requestBody) {
+    if (typeof requestBody === 'string') {
+        return { image: requestBody };
+    }
+    if (requestBody && typeof requestBody === 'object' && !Array.isArray(requestBody)) {
+        return requestBody;
+    }
+    throw new Error('Multipart requestBody must be an object of form fields or a data URL/base64 string for the image field.');
+}
+function appendMultipartField(form, field, value) {
+    const file = multipartFileFromValue(field, value);
+    if (file) {
+        form.append(field, file.blob, file.filename);
+        return;
+    }
+    if (typeof value === 'undefined' || value === null)
+        return;
+    if (typeof value === 'object') {
+        form.append(field, JSON.stringify(value));
+        return;
+    }
+    form.append(field, String(value));
+}
+function multipartFileFromValue(field, value) {
+    if (typeof value === 'string') {
+        const parsed = binaryPayloadFromString(value, defaultMimeTypeForField(field));
+        if (!parsed)
+            return null;
+        return {
+            blob: new Blob([blobPartFromBuffer(parsed.buffer)], { type: parsed.mimeType }),
+            filename: defaultFilenameForField(field, parsed.mimeType),
+        };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const obj = value;
+    const raw = firstString(obj.data_url, obj.dataUrl, obj.base64, obj.content, obj.data, obj.value);
+    if (!raw)
+        return null;
+    const parsed = binaryPayloadFromString(raw, firstString(obj.content_type, obj.contentType, obj.mime_type, obj.mimeType) ?? defaultMimeTypeForField(field));
+    if (!parsed)
+        return null;
+    return {
+        blob: new Blob([blobPartFromBuffer(parsed.buffer)], { type: parsed.mimeType }),
+        filename: firstString(obj.filename, obj.name) ?? defaultFilenameForField(field, parsed.mimeType),
+    };
+}
+function blobPartFromBuffer(buffer) {
+    const bytes = new Uint8Array(buffer.byteLength);
+    bytes.set(buffer);
+    return bytes;
+}
+function binaryPayloadFromString(value, fallbackMimeType) {
+    const trimmed = value.trim();
+    const dataUrl = trimmed.match(/^data:([^;,]+)?(;base64)?,(.*)$/s);
+    if (dataUrl) {
+        const mimeType = dataUrl[1] || fallbackMimeType;
+        const isBase64 = dataUrl[2] === ';base64';
+        const payload = dataUrl[3] || '';
+        return {
+            buffer: isBase64 ? Buffer.from(payload, 'base64') : Buffer.from(decodeURIComponent(payload)),
+            mimeType,
+        };
+    }
+    if (looksLikeBase64(trimmed)) {
+        return { buffer: Buffer.from(trimmed.replace(/\s+/g, ''), 'base64'), mimeType: fallbackMimeType };
+    }
+    return null;
+}
+function looksLikeBase64(value) {
+    if (value.length < 16 || value.length % 4 !== 0)
+        return false;
+    return /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return null;
+}
+function defaultMimeTypeForField(field) {
+    return field.toLowerCase().includes('image') ? 'image/png' : 'application/octet-stream';
+}
+function defaultFilenameForField(field, mimeType) {
+    const extension = mimeType.includes('jpeg') ? 'jpg'
+        : mimeType.includes('png') ? 'png'
+            : mimeType.includes('gif') ? 'gif'
+                : mimeType.includes('webp') ? 'webp'
+                    : mimeType.includes('csv') ? 'csv'
+                        : 'bin';
+    return `${field}.${extension}`;
+}
+function formatApiError(error) {
+    let message = 'API request failed.';
+    if (error.response) {
+        const method = error.config?.method?.toUpperCase() || 'UNKNOWN_METHOD';
+        const url = error.config?.url || 'UNKNOWN_URL';
+        const statusText = error.response.statusText || 'Status text not available';
+        const requestId = getRequestId(error.response.headers);
+        message = `API Error: ${method} ${url} -> Status ${error.response.status} (${statusText}).`;
+        if (requestId) {
+            message += ` Request ID: ${requestId}.`;
+        }
+        const responseDetails = extractApiErrorDetails(error.response.data);
+        if (responseDetails) {
+            message += ` Details: ${responseDetails}`;
+        }
+        else {
+            message += ' No response body received.';
+        }
+    }
+    else if (error.request) {
+        message = 'API Network Error: No response received from server.';
+        if (error.code)
+            message += ` (Code: ${error.code})`;
+    }
+    else {
+        message = `API Request Setup Error: ${error.message}`;
+    }
+    return message;
+}
+export function validateToolArgs(toolName, rawSchema, args) {
+    const validator = getOrCreateValidator(toolName, rawSchema);
+    if (!validator) {
+        return {
+            ok: false,
+            errors: [],
+            message: `Internal schema error: could not compile input schema for tool "${toolName}".`,
+        };
+    }
+    const valid = validator(args);
+    if (valid)
+        return { ok: true };
+    const errors = (validator.errors || []);
+    const issueSummary = summarizeSchemaErrors(errors);
+    const arrayHint = hasIncludeExpandArrayIssue(errors)
+        ? '\nHint: Array parameters (like "include" and "expand") must be arrays, even for single values. Example: {"query":{"include":["goals"],"expand":["goals"]}}.'
+        : '';
+    return {
+        ok: false,
+        errors,
+        message: `Invalid arguments for tool "${toolName}".\n${issueSummary}${arrayHint}`,
+    };
+}
+function getOrCreateValidator(toolName, rawSchema) {
+    const cached = validatorCache.get(toolName);
+    if (cached)
+        return cached;
+    const fallbackSchema = {
+        $schema: JSON_SCHEMA_DRAFT_2020_12,
+        type: 'object',
+        additionalProperties: true,
+    };
+    const normalized = normalizeSchema(rawSchema, toolName);
+    const schema = (normalized && typeof normalized === 'object') ? normalized : fallbackSchema;
+    if (!schema.$schema)
+        schema.$schema = JSON_SCHEMA_DRAFT_2020_12;
+    try {
+        const validator = ajv.compile(schema);
+        validatorCache.set(toolName, validator);
+        return validator;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to compile JSON schema for '${toolName}': ${message}`);
+        return null;
+    }
+}
+function normalizeSchema(input, toolName) {
+    const seen = new WeakMap();
+    function walk(node, path = '') {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (seen.has(node))
+            return seen.get(node);
+        if (Array.isArray(node)) {
+            const arr = [];
+            seen.set(node, arr);
+            node.forEach((item, index) => arr.push(walk(item, `${path}/${index}`)));
+            return arr;
+        }
+        const out = {};
+        seen.set(node, out);
+        for (const [key, value] of Object.entries(node)) {
+            out[key] = walk(value, `${path}/${escapeJsonPointer(key)}`);
+        }
+        if (Array.isArray(out.oneOf) && isExperienceChangeUnionPath(path)) {
+            out.oneOf = normalizeExperienceChangeUnion(out.oneOf);
+        }
+        if (out.nullable === true) {
+            const type = out.type;
+            if (typeof type === 'string') {
+                out.type = [type, 'null'];
+            }
+            else if (Array.isArray(type)) {
+                const typeSet = new Set(type);
+                typeSet.add('null');
+                out.type = [...typeSet];
+            }
+            else if (Array.isArray(out.oneOf)) {
+                out.oneOf = [...out.oneOf, { type: 'null' }];
+            }
+            else if (Array.isArray(out.anyOf)) {
+                out.anyOf = [...out.anyOf, { type: 'null' }];
+            }
+            delete out.nullable;
+        }
+        return out;
+    }
+    return normalizeToolSpecificSchema(toolName, walk(input));
+}
+function escapeJsonPointer(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function isExperienceChangeUnionPath(path) {
+    return path.includes('/properties/changes/items');
+}
+function normalizeExperienceChangeUnion(branches) {
+    return branches.map((branch, index) => {
+        if (!isAutoPlaceholderSchema(branch))
+            return branch;
+        const inferredType = inferPlaceholderChangeType(branches, index);
+        if (inferredType === 'defaultRedirect')
+            return defaultRedirectChangeSchema();
+        if (inferredType === 'richStructure')
+            return richStructureChangeSchema();
+        return branch;
+    });
+}
+function isAutoPlaceholderSchema(schema) {
+    return isPlainObject(schema)
+        && typeof schema.description === 'string'
+        && schema.description.includes('auto-placeholder');
+}
+function inferPlaceholderChangeType(branches, index) {
+    const previousTypes = collectDiscriminantTypes(branches[index - 1]);
+    const nextTypes = collectDiscriminantTypes(branches[index + 1]);
+    if (index === 2 && nextTypes.has('customCode'))
+        return 'defaultRedirect';
+    if (previousTypes.has('defaultRedirect'))
+        return 'richStructure';
+    if (previousTypes.has('customCode') && nextTypes.has('fullStackFeature'))
+        return 'richStructure';
+    return null;
+}
+function collectDiscriminantTypes(schema) {
+    const types = new Set();
+    const visited = new WeakSet();
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (visited.has(node))
+            return;
+        visited.add(node);
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+            return;
+        }
+        const record = node;
+        const typeProperty = isPlainObject(record.properties) ? record.properties.type : undefined;
+        if (isPlainObject(typeProperty) && Array.isArray(typeProperty.enum)) {
+            for (const value of typeProperty.enum) {
+                if (typeof value === 'string')
+                    types.add(value);
+            }
+        }
+        for (const value of Object.values(record))
+            walk(value);
+    }
+    walk(schema);
+    return types;
+}
+function defaultRedirectChangeSchema() {
+    return {
+        type: 'object',
+        description: 'Normalized schema for a defaultRedirect split URL change. Replaces a broad generated auto-placeholder so oneOf validation can discriminate by type.',
+        properties: {
+            type: { type: 'string', enum: ['defaultRedirect'] },
+            data: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    original_pattern: { type: 'string' },
+                    variation_pattern: { type: 'string' },
+                    case_sensitive: { type: 'boolean' },
+                },
+                required: ['original_pattern', 'variation_pattern'],
+            },
+        },
+        required: ['type', 'data'],
+    };
+}
+function richStructureChangeSchema() {
+    return {
+        type: 'object',
+        description: 'Normalized schema for a richStructure visual editor change. Replaces a broad generated auto-placeholder so oneOf validation can discriminate by type.',
+        properties: {
+            id: { type: 'integer' },
+            type: { type: 'string', enum: ['richStructure'] },
+            data: { type: 'object', additionalProperties: true },
+        },
+        required: ['type', 'data'],
+        additionalProperties: true,
+    };
+}
+function normalizeToolSpecificSchema(toolName, schema) {
+    if (!isPlainObject(schema))
+        return schema;
+    const properties = isPlainObject(schema.properties) ? schema.properties : undefined;
+    if (!properties || !Object.prototype.hasOwnProperty.call(properties, 'requestBody'))
+        return schema;
+    if (toolName === 'createaudience') {
+        properties.requestBody = audienceRequestBodySchema(true);
+    }
+    else if (toolName === 'updateaudience') {
+        properties.requestBody = audienceRequestBodySchema(false);
+    }
+    else if (toolName === 'createlocation') {
+        properties.requestBody = locationRequestBodySchema(true);
+    }
+    else if (toolName === 'updatelocation') {
+        properties.requestBody = locationRequestBodySchema(false);
+    }
+    else if (toolName === 'creategoal') {
+        properties.requestBody = goalRequestBodySchema(true);
+    }
+    else if (toolName === 'updategoal') {
+        properties.requestBody = goalRequestBodySchema(false);
+    }
+    else if (toolName === 'createfeature') {
+        properties.requestBody = featureRequestBodySchema(true);
+    }
+    else if (toolName === 'updatefeature') {
+        properties.requestBody = featureRequestBodySchema(false);
+    }
+    else if (toolName === 'uploadexperiencevariationscreenshot') {
+        properties.requestBody = uploadImageNoNameRequestBodySchema();
+    }
+    return schema;
+}
+function uploadImageNoNameRequestBodySchema() {
+    return {
+        type: 'object',
+        description: 'Normalized multipart image upload payload. Accepts either a raw data URL/base64 string in image or an object with data_url/base64 plus optional filename/content_type metadata.',
+        additionalProperties: true,
+        properties: {
+            image: {
+                anyOf: [
+                    { type: 'string', format: 'binary' },
+                    {
+                        type: 'object',
+                        additionalProperties: true,
+                        properties: {
+                            data_url: { type: 'string' },
+                            dataUrl: { type: 'string' },
+                            base64: { type: 'string' },
+                            content: { type: 'string' },
+                            data: { type: 'string' },
+                            value: { type: 'string' },
+                            filename: { type: 'string' },
+                            name: { type: 'string' },
+                            content_type: { type: 'string' },
+                            contentType: { type: 'string' },
+                            mime_type: { type: 'string' },
+                            mimeType: { type: 'string' },
+                        },
+                    },
+                ],
+            },
+        },
+        required: ['image'],
+    };
+}
+function audienceRequestBodySchema(isCreate) {
+    return {
+        type: 'object',
+        description: 'Normalized Convert audience payload schema. The generated OpenAPI oneOf currently rejects valid non-null rules for segmentation/permanent/transient audiences, so MCP validates the stable envelope and lets the API validate the rule semantics.',
+        additionalProperties: true,
+        properties: {
+            id: { type: 'integer' },
+            name: { type: 'string', maxLength: 100 },
+            description: { type: ['string', 'null'], maxLength: 500 },
+            status: { type: 'string', enum: ['active', 'archived'] },
+            type: { type: 'string', enum: ['segmentation', 'permanent', 'transient'] },
+            rules: ruleObjectSchema('Audience rules use nested OR -> AND -> OR_WHEN blocks. Audience rule_type values include visitor_type, country, city, region, device/browser fields, cookies, JS conditions, URL fields for segmentation audiences, and page-tag fields.'),
+            selected_default: { type: 'boolean' },
+        },
+        required: isCreate ? ['name', 'type', 'rules'] : [],
+    };
+}
+function locationRequestBodySchema(isCreate) {
+    return {
+        type: 'object',
+        description: 'Normalized Convert location payload schema. The generated OpenAPI schema currently treats non-null rules as invalid, so MCP validates the stable envelope and lets the API validate the rule semantics.',
+        additionalProperties: true,
+        properties: {
+            id: { type: 'integer' },
+            name: { type: 'string', maxLength: 100 },
+            description: { type: ['string', 'null'], maxLength: 500 },
+            status: { type: 'string', enum: ['active', 'archived'] },
+            rules: ruleObjectSchema('Location rules use nested OR -> AND -> OR_WHEN blocks, usually with URL/page matching rule types.'),
+            trigger: { type: ['object', 'null'], additionalProperties: true },
+            selected_default: { type: 'boolean' },
+        },
+        required: isCreate ? ['name', 'rules'] : [],
+    };
+}
+function goalRequestBodySchema(isCreate) {
+    return {
+        type: 'object',
+        description: 'Normalized Convert goal payload schema. The generated OpenAPI oneOf is too strict for real goal variants such as clicks_element, code_trigger, and triggering_rule scoping.',
+        additionalProperties: true,
+        properties: {
+            id: { type: 'integer' },
+            name: { type: 'string', maxLength: 100 },
+            key: { type: 'string', maxLength: 32 },
+            description: { type: ['string', 'null'], maxLength: 500 },
+            status: { type: 'string', enum: ['active', 'archived'] },
+            type: {
+                type: 'string',
+                enum: [
+                    'advanced',
+                    'visits_page',
+                    'revenue',
+                    'clicks_link',
+                    'submits_form',
+                    'clicks_element',
+                    'dom_interaction',
+                    'scroll_percentage',
+                    'ga_import',
+                    'code_trigger',
+                ],
+            },
+            settings: { type: ['object', 'null'], additionalProperties: true },
+            triggering_rule: ruleObjectSchema('Goal triggering rules use nested OR -> AND -> OR_WHEN blocks to scope when the goal can fire.'),
+            selected_default: { type: 'boolean' },
+        },
+        required: isCreate ? ['name', 'type'] : [],
+    };
+}
+function featureRequestBodySchema(isCreate) {
+    return {
+        type: 'object',
+        description: 'Normalized Convert feature payload schema. The generated OpenAPI oneOf currently combines a base null default_value with type-specific default_value branches, causing valid boolean/number defaults to fail validation.',
+        additionalProperties: true,
+        properties: {
+            id: { type: 'integer' },
+            name: { type: 'string', maxLength: 100 },
+            key: { type: 'string', maxLength: 32 },
+            description: { type: ['string', 'null'], maxLength: 200 },
+            status: { type: 'string', enum: ['active', 'archived'] },
+            variables: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: true,
+                    properties: {
+                        key: { type: 'string', maxLength: 32 },
+                        type: { type: 'string', enum: ['json', 'string', 'boolean', 'float', 'integer'] },
+                        default_value: {},
+                    },
+                    required: ['key', 'type'],
+                },
+            },
+        },
+        required: isCreate ? ['name', 'variables'] : [],
+    };
+}
+function ruleObjectSchema(description) {
+    return {
+        type: ['object', 'null'],
+        description,
+        additionalProperties: true,
+    };
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function summarizeSchemaErrors(errors) {
+    if (!errors.length)
+        return 'Validation failed with no issue details.';
+    const lines = errors.slice(0, MAX_SCHEMA_ERRORS_TO_SHOW).map((issue) => {
+        return `- ${errorPath(issue)}: ${issue.message || 'Invalid value'}`;
+    });
+    if (errors.length > MAX_SCHEMA_ERRORS_TO_SHOW) {
+        lines.push(`- ... ${errors.length - MAX_SCHEMA_ERRORS_TO_SHOW} more issue(s)`);
+    }
+    return lines.join('\n');
+}
+function errorPath(issue) {
+    const pointerPath = issue.instancePath ? issue.instancePath.slice(1).replace(/\//g, '.') : '(root)';
+    if (issue.keyword === 'required') {
+        const missing = issue.params.missingProperty;
+        if (missing) {
+            return pointerPath === '(root)' ? missing : `${pointerPath}.${missing}`;
+        }
+    }
+    return pointerPath;
+}
+function hasIncludeExpandArrayIssue(errors) {
+    return errors.some((issue) => {
+        const missing = issue.keyword === 'required'
+            ? issue.params.missingProperty
+            : undefined;
+        const requiredPath = missing ? `${issue.instancePath}/${missing}` : issue.instancePath;
+        return /\/(include|expand)(\/|$)/.test(requiredPath || '');
+    });
+}
+function getRequestId(headers) {
+    if (!headers || typeof headers !== 'object')
+        return null;
+    const candidates = ['x-request-id', 'x-correlation-id', 'request-id'];
+    for (const key of candidates) {
+        const value = headers[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'string')
+            return value[0].trim();
+    }
+    return null;
+}
+function truncate(value, maxLen) {
+    if (value.length <= maxLen)
+        return value;
+    return `${value.slice(0, maxLen)}...`;
+}
+function extractApiErrorDetails(responseData) {
+    if (typeof responseData === 'undefined' || responseData === null)
+        return null;
+    if (typeof responseData === 'string')
+        return truncate(responseData, MAX_API_ERROR_DETAIL_LEN);
+    if (typeof responseData === 'object') {
+        const data = responseData;
+        const preferredKeys = ['message', 'error', 'errors', 'details', 'validation_errors'];
+        for (const key of preferredKeys) {
+            const value = data[key];
+            if (typeof value === 'string' && value.trim())
+                return truncate(value.trim(), MAX_API_ERROR_DETAIL_LEN);
+            if (Array.isArray(value) || (value && typeof value === 'object')) {
+                try {
+                    return truncate(JSON.stringify(value), MAX_API_ERROR_DETAIL_LEN);
+                }
+                catch {
+                    return '[Could not serialize error details]';
+                }
+            }
+        }
+        try {
+            return truncate(JSON.stringify(data), MAX_API_ERROR_DETAIL_LEN);
+        }
+        catch {
+            return '[Could not serialize error response]';
+        }
+    }
+    return truncate(String(responseData), MAX_API_ERROR_DETAIL_LEN);
+}
+//# sourceMappingURL=executor.js.map