dalvon-mcp 3.0.0

package/dist/clients/dalvon.js

@@ -0,0 +1,1240 @@
+/**
+ * Telefonieren.ai API Client
+ * Handles all communication with api.dalvon.ai
+ */
+import { logger } from '../utils/logger.js';
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+export class DalvonClient {
+    apiKey;
+    baseUrl;
+    constructor(apiKey, baseUrl = 'https://api.dalvon.ai') {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    }
+    /**
+     * Reconfigure credentials and base URL at runtime.
+     */
+    reconfigure(apiKey, baseUrl) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    /**
+     * Make HTTP request with retry logic
+     */
+    async makeRequest(method, endpoint, options = {}) {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        // Add query params
+        if (options.params) {
+            for (const [key, value] of Object.entries(options.params)) {
+                if (value !== undefined && value !== null) {
+                    if (Array.isArray(value)) {
+                        value.forEach((v) => url.searchParams.append(key, String(v)));
+                    }
+                    else {
+                        url.searchParams.set(key, String(value));
+                    }
+                }
+            }
+        }
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        let lastError = null;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                logger.debug(`${method} ${url.toString()}`, {
+                    attempt,
+                    body: options.body,
+                });
+                const response = await fetch(url.toString(), {
+                    method,
+                    headers,
+                    body: options.body ? JSON.stringify(options.body) : undefined,
+                });
+                const responseText = await response.text();
+                logger.debug(`Response status: ${response.status}`, {
+                    status: response.status,
+                    body: responseText.substring(0, 500),
+                });
+                if (response.status >= 400) {
+                    let details;
+                    try {
+                        details = JSON.parse(responseText);
+                    }
+                    catch {
+                        details = responseText;
+                    }
+                    logger.warn(`API Error: ${response.status}`, {
+                        url: url.toString(),
+                        status: response.status,
+                        details,
+                    });
+                    return {
+                        success: false,
+                        error: `API request failed with status ${response.status}`,
+                        statusCode: response.status,
+                        details,
+                    };
+                }
+                // Parse successful response
+                let data;
+                try {
+                    data = JSON.parse(responseText);
+                }
+                catch {
+                    data = responseText;
+                }
+                return {
+                    success: true,
+                    data,
+                    statusCode: response.status,
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                logger.warn(`Request failed (attempt ${attempt}/${MAX_RETRIES})`, {
+                    error: lastError.message,
+                    url: url.toString(),
+                });
+                // Only retry on network errors, not on 4xx/5xx
+                if (attempt < MAX_RETRIES) {
+                    await this.delay(RETRY_DELAY_MS * attempt); // Exponential backoff
+                }
+            }
+        }
+        logger.error('All retry attempts failed', lastError);
+        return {
+            success: false,
+            error: `Network error after ${MAX_RETRIES} attempts: ${lastError?.message}`,
+        };
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Make HTTP request sending form data (multipart/form-data) instead of JSON.
+     * Used for endpoints that expect Form() parameters (e.g. rules).
+     */
+    async makeFormDataRequest(method, endpoint, data, params) {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    if (Array.isArray(value)) {
+                        value.forEach((v) => url.searchParams.append(key, String(v)));
+                    }
+                    else {
+                        url.searchParams.set(key, String(value));
+                    }
+                }
+            }
+        }
+        let lastError = null;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const formData = new FormData();
+                for (const [key, value] of Object.entries(data)) {
+                    if (value === undefined || value === null)
+                        continue;
+                    if (Array.isArray(value)) {
+                        value.forEach((v) => formData.append(key, String(v)));
+                    }
+                    else if (typeof value === 'boolean') {
+                        formData.append(key, value ? 'true' : 'false');
+                    }
+                    else {
+                        formData.append(key, String(value));
+                    }
+                }
+                logger.debug(`${method} ${url.toString()} (form-data)`, {
+                    attempt,
+                    fields: Object.keys(data),
+                });
+                const response = await fetch(url.toString(), {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey}`,
+                    },
+                    body: formData,
+                });
+                const responseText = await response.text();
+                logger.debug(`Response status: ${response.status}`, {
+                    status: response.status,
+                    body: responseText.substring(0, 500),
+                });
+                if (response.status >= 400) {
+                    let details;
+                    try {
+                        details = JSON.parse(responseText);
+                    }
+                    catch {
+                        details = responseText;
+                    }
+                    logger.warn(`API Error: ${response.status}`, {
+                        url: url.toString(),
+                        status: response.status,
+                        details,
+                    });
+                    return {
+                        success: false,
+                        error: `API request failed with status ${response.status}`,
+                        statusCode: response.status,
+                        details,
+                    };
+                }
+                let responseData;
+                try {
+                    responseData = JSON.parse(responseText);
+                }
+                catch {
+                    responseData = responseText;
+                }
+                return {
+                    success: true,
+                    data: responseData,
+                    statusCode: response.status,
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                logger.warn(`Request failed (attempt ${attempt}/${MAX_RETRIES})`, {
+                    error: lastError.message,
+                    url: url.toString(),
+                });
+                if (attempt < MAX_RETRIES) {
+                    await this.delay(RETRY_DELAY_MS * attempt);
+                }
+            }
+        }
+        logger.error('All retry attempts failed', lastError);
+        return {
+            success: false,
+            error: `Network error after ${MAX_RETRIES} attempts: ${lastError?.message}`,
+        };
+    }
+    /**
+     * CRITICAL: Transform flat agent data into nested structure expected by API
+     * - prompt must be {"user_prompt": "text"}, NOT just a string!
+     * - conversation config goes into "conversation" object
+     * - features config goes into "features" object
+     * - template config goes into "template" object
+     */
+    prepareAgentData(agentData) {
+        const llmFields = [
+            'model', 'prompt', 'first_message', 'temperature', 'max_tokens',
+            'reasoning_effort', 'llm_fixed', 'prompt_hidden', 'customizable_variables',
+        ];
+        const conversationFields = [
+            'language', 'multi_language', 'language_presets', 'voice_id', 'voice_ids',
+            'speed', 'interruption', 'record_voice', 'retention_days',
+            'max_duration_seconds', 'max_duration_message', 'agent_concurrency_limit',
+            'stt_provider', 'stt_model',
+            'background_sound_config', 'noise_cancellation_config', 'voice_mode',
+        ];
+        const visibilityFields = ['visibility', 'hide_details', 'hidden'];
+        const inheritanceFields = ['parent_id', 'enable_childs'];
+        // Fields that are already nested and should pass through directly
+        const directFields = ['name', 'description', 'tags', 'features', 'workflow', 'chat', 'preview'];
+        const llmConfig = {};
+        const conversationConfig = {};
+        const templateConfig = {};
+        const visibilityConfig = {};
+        const inheritanceConfig = {};
+        const remainingData = {};
+        for (const [key, value] of Object.entries(agentData)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (directFields.includes(key)) {
+                remainingData[key] = value;
+            }
+            else if (llmFields.includes(key)) {
+                if (key === 'prompt') {
+                    if (typeof value === 'string') {
+                        llmConfig.prompt = { user_prompt: value };
+                    }
+                    else {
+                        llmConfig.prompt = value;
+                    }
+                }
+                else {
+                    llmConfig[key] = value;
+                }
+            }
+            else if (conversationFields.includes(key)) {
+                if (key === 'voice_id' && typeof value === 'string') {
+                    conversationConfig.voice_ids = [value];
+                }
+                else if (key === 'background_sound_config') {
+                    conversationConfig.background_sound = value;
+                }
+                else if (key === 'noise_cancellation_config') {
+                    conversationConfig.noise_cancellation = value;
+                }
+                else {
+                    conversationConfig[key] = value;
+                }
+            }
+            else if (visibilityFields.includes(key)) {
+                visibilityConfig[key] = value;
+            }
+            else if (inheritanceFields.includes(key)) {
+                inheritanceConfig[key] = value;
+            }
+            else if (key === 'template_id' || key === 'is_template') {
+                templateConfig[key] = value;
+            }
+            else if (key === 'template_variables') {
+                templateConfig.template_variables = { _values: value };
+            }
+            else {
+                remainingData[key] = value;
+            }
+        }
+        if (Object.keys(llmConfig).length > 0) {
+            remainingData.llm = llmConfig;
+        }
+        if (Object.keys(conversationConfig).length > 0) {
+            remainingData.conversation = conversationConfig;
+        }
+        if (Object.keys(templateConfig).length > 0) {
+            remainingData.template = templateConfig;
+        }
+        if (Object.keys(visibilityConfig).length > 0) {
+            remainingData.visibility = visibilityConfig;
+        }
+        if (Object.keys(inheritanceConfig).length > 0) {
+            remainingData.inheritance = inheritanceConfig;
+        }
+        logger.debug('Transformed agent data', { transformed: remainingData });
+        return remainingData;
+    }
+    // ==================== AGENT METHODS ====================
+    async createAgent(agentData, targetUserId) {
+        const preparedData = this.prepareAgentData(agentData);
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/agents/', { body: preparedData, params });
+    }
+    async updateAgent(agentId, agentData, targetUserId) {
+        const preparedData = this.prepareAgentData(agentData);
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/agents/${agentId}`, { body: preparedData, params });
+    }
+    async getAgent(agentId) {
+        return this.makeRequest('GET', `/agents/${agentId}`);
+    }
+    async listAgents(params = {}) {
+        return this.makeRequest('GET', '/agents/', { params });
+    }
+    async deleteAgent(agentId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('DELETE', `/agents/${agentId}`, { params });
+    }
+    async duplicateAgent(agentId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/agents/${agentId}/duplicate`, { params });
+    }
+    async getAgentStats(params = {}) {
+        return this.makeRequest('GET', '/agents/stats', { params });
+    }
+    async listChildAgents(agentId, includeDescendants = false) {
+        return this.makeRequest('GET', `/agents/${agentId}/children`, {
+            params: { include_descendants: includeDescendants },
+        });
+    }
+    // ==================== CALL METHODS ====================
+    async listCalls(params = {}) {
+        return this.makeRequest('GET', '/calls/', { params });
+    }
+    async initiateCall(callData) {
+        return this.makeRequest('POST', '/calls/', { body: callData });
+    }
+    async getCallDetails(callId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/calls/${callId}`, { params });
+    }
+    async deleteCall(callId, memoryOnly = false) {
+        return this.makeRequest('DELETE', `/calls/${callId}`, {
+            params: { memory_only: memoryOnly },
+        });
+    }
+    async submitCallFeedback(callId, rating, note) {
+        const data = { rating };
+        if (note)
+            data.note = note;
+        return this.makeRequest('POST', `/calls/${callId}/feedback`, { body: data });
+    }
+    async getCallFeedback(callId) {
+        return this.makeRequest('GET', `/calls/${callId}/feedback`);
+    }
+    async cleanupExpiredCalls(params = {}) {
+        return this.makeRequest('GET', '/calls/cleanup', { params });
+    }
+    // ==================== TEMPLATE METHODS ====================
+    async listTemplates(params = {}) {
+        return this.makeRequest('GET', '/agents/templates', { params });
+    }
+    async getTemplate(templateId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/agents/templates/${templateId}`, { params });
+    }
+    async createTemplate(templateData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/agents/templates', { body: templateData, params });
+    }
+    async updateTemplate(templateId, templateData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/agents/templates/${templateId}`, { body: templateData, params });
+    }
+    async deleteTemplate(templateId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('DELETE', `/agents/templates/${templateId}`, { params });
+    }
+    // ==================== AGENT VERSIONING METHODS (API-Sync 2026-01) ====================
+    /**
+     * Get agent with optional specific version
+     * @param agentId - Agent UUID
+     * @param version - Optional version UUID (defaults to draft version)
+     */
+    async getAgentVersion(agentId, version, targetUserId) {
+        const params = {};
+        if (version)
+            params.version = version;
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/agents/${agentId}`, { params });
+    }
+    /**
+     * Publish the current draft version of an agent
+     * Creates an immutable snapshot that can be used in production
+     */
+    async publishAgentVersion(agentId, versionName, targetUserId) {
+        const body = {};
+        if (versionName)
+            body.version_name = versionName;
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', `/agents/${agentId}/publish`, { body, params });
+    }
+    /**
+     * List all versions of an agent (draft, published, archived)
+     */
+    async listAgentVersions(agentId, includeDraft = true, includeArchived = false) {
+        return this.makeRequest('GET', `/agents/${agentId}/versions`, {
+            params: { include_draft: includeDraft, include_archived: includeArchived },
+        });
+    }
+    /**
+     * Configure A/B testing traffic distribution between agent versions
+     * @param config - Map of version_id to weight (0.0-1.0), or null for latest_published mode
+     */
+    async configureAgentTraffic(agentId, config) {
+        return this.makeRequest('PUT', `/agents/${agentId}/traffic`, { body: { config } });
+    }
+    /**
+     * Get current traffic distribution statistics for an agent
+     */
+    async getAgentTrafficStats(agentId) {
+        return this.makeRequest('GET', `/agents/${agentId}/traffic`);
+    }
+    /**
+     * Archive a published version (removes from A/B testing pool)
+     */
+    async archiveAgentVersion(agentId, versionId) {
+        return this.makeRequest('PATCH', `/agents/${agentId}`, {
+            params: { version: versionId },
+            body: { status: 'archived' },
+        });
+    }
+    // ==================== EXTENDED AGENT METHODS (Phase 1) ====================
+    async refreshAgents(params = {}) {
+        return this.makeRequest('POST', '/agents/refresh', { params });
+    }
+    async transferAgent(transferData) {
+        return this.makeRequest('POST', '/agents/transfer', { body: transferData });
+    }
+    async getAgentStatistics(agentId, params = {}) {
+        return this.makeRequest('GET', `/agents/${agentId}/statistics`, { params });
+    }
+    // ==================== EXTENDED CALL METHODS (Phase 1) ====================
+    async markCallsAsRead(callIds, unread = false) {
+        return this.makeRequest('PATCH', '/calls/mark-read', { body: { call_ids: callIds, unread } });
+    }
+    async listCallCategories() {
+        return this.makeRequest('GET', '/calls/categories');
+    }
+    async updateCallCategories(categories) {
+        return this.makeRequest('PATCH', '/calls/categories', { body: { categories } });
+    }
+    async updateCallMetadata(callId, metadata) {
+        return this.makeRequest('PATCH', `/calls/${callId}`, { body: metadata });
+    }
+    // ==================== CONTACT METHODS (Phase 1) ====================
+    async listContacts(params = {}) {
+        // Convert offset to skip for backend compatibility
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/contacts/', { params });
+    }
+    async getContact(contactId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/contacts/${contactId}`, { params });
+    }
+    async createContact(contactData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/contacts/', { body: [contactData], params });
+    }
+    async updateContact(contactId, contactData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/contacts/${contactId}`, { body: contactData, params });
+    }
+    async deleteContact(contactId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('DELETE', `/contacts/${contactId}`, { params });
+    }
+    async bulkDeleteContacts(contactIds) {
+        return this.makeRequest('DELETE', '/contacts/', { body: { contact_ids: contactIds } });
+    }
+    async manageContactCategories(contactId, action, categories) {
+        return this.makeRequest('POST', `/contacts/${contactId}/categories`, {
+            body: { action, categories },
+        });
+    }
+    /**
+     * Import contacts from CSV/Excel file
+     * Note: This requires multipart/form-data which needs special handling
+     */
+    async importContacts(file, fileName, params = {}) {
+        const url = `${this.baseUrl}/contacts/import`;
+        try {
+            const formData = new FormData();
+            // Detect mime type
+            const mimeType = fileName.endsWith('.csv')
+                ? 'text/csv'
+                : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+            const blob = new Blob([file], { type: mimeType });
+            formData.append('file', blob, fileName);
+            // Add params as form fields
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    formData.append(key, String(value));
+                }
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: formData,
+            });
+            const responseText = await response.text();
+            if (response.status >= 400) {
+                let details;
+                try {
+                    details = JSON.parse(responseText);
+                }
+                catch {
+                    details = responseText;
+                }
+                return {
+                    success: false,
+                    error: `Import failed with status ${response.status}`,
+                    statusCode: response.status,
+                    details,
+                };
+            }
+            let data;
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                data = responseText;
+            }
+            return {
+                success: true,
+                data,
+                statusCode: response.status,
+            };
+        }
+        catch (error) {
+            logger.error('Contact import failed', error);
+            return {
+                success: false,
+                error: `Import error: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    // REMOVED: Campaign methods - campaigns not implemented in backend
+    // ==================== RULES METHODS (Phase 1) ====================
+    async listRules(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/rules/', { params });
+    }
+    async getRule(ruleId) {
+        return this.makeRequest('GET', `/rules/${ruleId}`);
+    }
+    async createRule(ruleData) {
+        return this.makeFormDataRequest('POST', '/rules/', ruleData);
+    }
+    async updateRule(ruleId, ruleData) {
+        return this.makeFormDataRequest('PATCH', `/rules/${ruleId}`, ruleData);
+    }
+    async deleteRule(ruleId) {
+        return this.makeRequest('DELETE', `/rules/${ruleId}`);
+    }
+    async getRateLimitSettings(params = {}) {
+        return this.makeRequest('GET', '/rules/rate-limit', { params });
+    }
+    async updateRateLimitSettings(rateLimitData) {
+        return this.makeRequest('PUT', '/rules/rate-limit', { body: rateLimitData });
+    }
+    async deleteRateLimitSettings(settingsId) {
+        return this.makeRequest('DELETE', `/rules/rate-limit/${settingsId}`);
+    }
+    // ==================== NUMBERS METHODS (Reworked API-Sync 2026-01 - Replaces Hotlines) ====================
+    async listPhoneNumbers(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/numbers/', { params });
+    }
+    async getPhoneNumber(numberId) {
+        return this.makeRequest('GET', `/numbers/${numberId}`);
+    }
+    async provisionPhoneNumber(numberData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/numbers/', { body: numberData, params });
+    }
+    async updatePhoneNumber(numberId, numberData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/numbers/${numberId}`, { body: numberData, params });
+    }
+    async releasePhoneNumber(numberId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('DELETE', `/numbers/${numberId}`, { params });
+    }
+    async searchAvailableNumbers(params = {}) {
+        return this.makeRequest('GET', '/numbers/available', { params });
+    }
+    // --- NEW: Agent Assignment (replaces Hotlines) ---
+    /**
+     * Assign an agent to a phone number for inbound call routing
+     * This replaces the old hotlines functionality
+     */
+    async assignNumberToAgent(numberId, agentId) {
+        return this.makeRequest('PATCH', `/numbers/${numberId}`, { body: { agent_id: agentId } });
+    }
+    /**
+     * Remove agent assignment from a phone number
+     */
+    async unassignNumber(numberId) {
+        return this.makeRequest('PATCH', `/numbers/${numberId}`, { body: { agent_id: null } });
+    }
+    /**
+     * Get the effective area code based on organization/whitelabel settings
+     */
+    async getEffectiveAreaCode() {
+        return this.makeRequest('GET', '/numbers/effective-area-code');
+    }
+    /**
+     * Transfer numbers to another user
+     */
+    async transferNumbers(numberIds, targetUserId) {
+        return this.makeRequest('POST', '/numbers/transfer', {
+            body: { number_ids: numberIds, target_user_id: targetUserId },
+        });
+    }
+    /**
+     * Refresh Twilio webhooks for all numbers (Admin only)
+     */
+    async refreshNumberWebhooks(forceRefresh = false) {
+        return this.makeRequest('POST', '/numbers/refresh', { params: { force_refresh: forceRefresh } });
+    }
+    // ==================== VOICES METHODS (Phase 2) ====================
+    async listVoices(params = {}) {
+        return this.makeRequest('GET', '/voices/', { params });
+    }
+    async getVoice(voiceId) {
+        return this.makeRequest('GET', `/voices/${voiceId}`);
+    }
+    async refreshVoices() {
+        return this.makeRequest('POST', '/voices/refresh');
+    }
+    // ==================== VOICE PREVIEW METHODS (Phase 2) ====================
+    async generateVoicePreview(previewData) {
+        return this.makeRequest('POST', '/voice-preview/', { body: previewData });
+    }
+    async getVoicePreview(previewId) {
+        return this.makeRequest('GET', `/voice-preview/${previewId}`);
+    }
+    // ==================== HOTLINES METHODS (DEPRECATED - Use Numbers with agent_id) ====================
+    // API-Sync 2026-01: Hotlines have been replaced by direct agent assignment on Numbers
+    // Use assignNumberToAgent() and unassignNumber() instead
+    // ==================== FORWARDING METHODS (Phase 2) ====================
+    async refreshForwardingRules() {
+        return this.makeRequest('POST', '/forwarding/refresh');
+    }
+    // ==================== MEDIA METHODS (Phase 2) ====================
+    async listMedia(params = {}) {
+        return this.makeRequest('GET', '/media/', { params });
+    }
+    async getMedia(mediaId) {
+        return this.makeRequest('GET', `/media/${mediaId}`);
+    }
+    async deleteMedia(gcsUrl, bucketType) {
+        const params = new URLSearchParams({ gcs_url: gcsUrl, bucket_type: bucketType });
+        return this.makeRequest('DELETE', `/media?${params.toString()}`);
+    }
+    /**
+     * Upload media file (audio or image)
+     * Note: This requires multipart/form-data which needs special handling
+     */
+    async uploadMedia(file, fileName, mediaType, params = {}) {
+        const url = `${this.baseUrl}/media/upload`;
+        try {
+            const formData = new FormData();
+            // Detect mime type based on file extension
+            const ext = fileName.toLowerCase().split('.').pop();
+            let mimeType = 'application/octet-stream';
+            if (mediaType === 'audio') {
+                if (ext === 'mp3')
+                    mimeType = 'audio/mpeg';
+                else if (ext === 'wav')
+                    mimeType = 'audio/wav';
+                else if (ext === 'ogg')
+                    mimeType = 'audio/ogg';
+                else if (ext === 'm4a')
+                    mimeType = 'audio/mp4';
+            }
+            else if (mediaType === 'image') {
+                if (ext === 'png')
+                    mimeType = 'image/png';
+                else if (ext === 'jpg' || ext === 'jpeg')
+                    mimeType = 'image/jpeg';
+                else if (ext === 'gif')
+                    mimeType = 'image/gif';
+                else if (ext === 'webp')
+                    mimeType = 'image/webp';
+            }
+            const blob = new Blob([file], { type: mimeType });
+            formData.append('file', blob, fileName);
+            formData.append('media_type', mediaType);
+            // Add additional params
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    formData.append(key, String(value));
+                }
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: formData,
+            });
+            const responseText = await response.text();
+            if (response.status >= 400) {
+                let details;
+                try {
+                    details = JSON.parse(responseText);
+                }
+                catch {
+                    details = responseText;
+                }
+                return {
+                    success: false,
+                    error: `Upload failed with status ${response.status}`,
+                    statusCode: response.status,
+                    details,
+                };
+            }
+            let data;
+            try {
+                data = JSON.parse(responseText);
+            }
+            catch {
+                data = responseText;
+            }
+            return {
+                success: true,
+                data,
+                statusCode: response.status,
+            };
+        }
+        catch (error) {
+            logger.error('Media upload failed', error);
+            return {
+                success: false,
+                error: `Upload error: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async generateTTS(ttsData) {
+        return this.makeRequest('POST', '/media/generate-tts', { body: ttsData });
+    }
+    // ==================== PRONUNCIATIONS METHODS (Phase 2) ====================
+    async listPronunciations(params = {}) {
+        return this.makeRequest('GET', '/pronunciations/', { params });
+    }
+    async getPronunciation(pronunciationId) {
+        return this.makeRequest('GET', `/pronunciations/${pronunciationId}`);
+    }
+    async createPronunciation(pronunciationData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/pronunciations/', { body: pronunciationData, params });
+    }
+    async updatePronunciation(pronunciationId, pronunciationData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/pronunciations/${pronunciationId}`, { body: pronunciationData, params });
+    }
+    async deletePronunciation(pronunciationId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('DELETE', `/pronunciations/${pronunciationId}`, { params });
+    }
+    // ==================== INTEGRATIONS METHODS ====================
+    // --- Connections System ---
+    async createConnection(connectionData) {
+        return this.makeRequest('POST', '/integrations/connections', { body: connectionData });
+    }
+    async listConnections(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/integrations/connections', { params });
+    }
+    async getConnection(connectionId) {
+        return this.makeRequest('GET', `/integrations/connections/${connectionId}`);
+    }
+    async updateConnection(connectionId, connectionData) {
+        return this.makeRequest('PATCH', `/integrations/connections/${connectionId}`, { body: connectionData });
+    }
+    async deleteConnection(connectionId) {
+        return this.makeRequest('DELETE', `/integrations/connections/${connectionId}`);
+    }
+    async testConnection(connectionId) {
+        return this.makeRequest('POST', `/integrations/connections/${connectionId}/test`);
+    }
+    async listPlatforms() {
+        return this.makeRequest('GET', '/integrations/platforms');
+    }
+    // --- Connection Actions ---
+    async createConnectionAction(connectionId, actionData) {
+        return this.makeRequest('POST', `/integrations/connections/${connectionId}/actions`, { body: actionData });
+    }
+    async updateConnectionAction(connectionId, actionId, actionData) {
+        return this.makeRequest('PATCH', `/integrations/connections/${connectionId}/actions/${actionId}`, { body: actionData });
+    }
+    async deleteConnectionAction(connectionId, actionId) {
+        return this.makeRequest('DELETE', `/integrations/connections/${connectionId}/actions/${actionId}`);
+    }
+    // --- Legacy OAuth (deprecated, use Connections) ---
+    async getOAuthAuthorizationUrl(provider, params = {}) {
+        return this.makeRequest('GET', `/integrations/oauth/${provider}/authorize`, { params });
+    }
+    // ==================== POSTPROCESSING METHODS (Phase 3) ====================
+    async listPostprocessingResults(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/postprocessing/', { params });
+    }
+    async getPostprocessingResult(resultId, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('GET', `/postprocessing/${resultId}`, { params });
+    }
+    async triggerPostprocessing(callId, postprocessingData = {}) {
+        return this.makeRequest('POST', '/postprocessing/', { body: { call_id: callId, ...postprocessingData } });
+    }
+    async updatePostprocessingResult(resultId, resultData) {
+        return this.makeRequest('PATCH', `/postprocessing/${resultId}`, { body: resultData });
+    }
+    async deletePostprocessingResult(resultId) {
+        return this.makeRequest('DELETE', `/postprocessing/${resultId}`);
+    }
+    async updateCallFromPostprocessing(callId, postprocessingData) {
+        return this.makeRequest('POST', '/postprocessing/update-call', { body: { call_id: callId, ...postprocessingData } });
+    }
+    async transferPostprocessingData(transferData) {
+        return this.makeRequest('POST', '/postprocessing/transfer', { body: transferData });
+    }
+    // REMOVED: DNC methods - DNC is now part of rules in backend
+    // ==================== CHANNELS METHODS (Phase 6) ====================
+    async listChannels(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/channels/', { params });
+    }
+    async getChannel(channelId) {
+        return this.makeRequest('GET', `/channels/${channelId}`);
+    }
+    async configureChannel(channelData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/channels/', { body: channelData, params });
+    }
+    // ==================== MAILBOX METHODS (Phase 6) ====================
+    async listMailboxMessages(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/mailbox/', { params });
+    }
+    async getMailboxMessage(messageId) {
+        return this.makeRequest('GET', `/mailbox/${messageId}`);
+    }
+    // ==================== USERS METHODS (Phase 4) ====================
+    async listUsers(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/users/', { params });
+    }
+    async createUsers(usersData) {
+        return this.makeRequest('POST', '/users/', { body: usersData });
+    }
+    async getCurrentUser() {
+        return this.makeRequest('GET', '/users/me');
+    }
+    async updateCurrentUser(userData) {
+        return this.makeRequest('PATCH', '/users/me', { body: userData });
+    }
+    async changePassword(passwordData) {
+        return this.makeRequest('POST', '/users/me/password', { body: passwordData });
+    }
+    async getUser(userId) {
+        return this.makeRequest('GET', `/users/${userId}`);
+    }
+    async updateUser(userId, userData) {
+        return this.makeRequest('PATCH', `/users/${userId}`, { body: userData });
+    }
+    async deleteUser(userId) {
+        return this.makeRequest('DELETE', `/users/${userId}`);
+    }
+    async getUserPermissions(userId) {
+        return this.makeRequest('GET', `/users/${userId}/permissions`);
+    }
+    async resetUserPassword(userId) {
+        return this.makeRequest('POST', `/users/${userId}/reset-password`);
+    }
+    async listRoles(params = {}) {
+        return this.makeRequest('GET', '/users/roles', { params });
+    }
+    async createRole(roleData) {
+        return this.makeRequest('POST', '/users/roles', { body: roleData });
+    }
+    async updateRole(roleId, roleData) {
+        return this.makeRequest('PATCH', `/users/roles/${roleId}`, { body: roleData });
+    }
+    async deleteRole(roleId) {
+        return this.makeRequest('DELETE', `/users/roles/${roleId}`);
+    }
+    async manageApiKeys(userId, action, keyData) {
+        if (action === 'list') {
+            return this.makeRequest('GET', `/users/${userId}/keys`);
+        }
+        else if (action === 'create') {
+            return this.makeRequest('POST', `/users/${userId}/keys`, { body: keyData });
+        }
+        else {
+            return this.makeRequest('DELETE', `/users/${userId}/keys/${keyData?.key_id}`);
+        }
+    }
+    // ==================== ORGANIZATIONS METHODS (Phase 4) ====================
+    async listOrganizations(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/organizations/', { params });
+    }
+    async getOrganization(organizationId) {
+        return this.makeRequest('GET', `/organizations/${organizationId}`);
+    }
+    async createOrganization(organizationData) {
+        const { name, description, ...rest } = organizationData;
+        const body = {
+            basic_info: { name, description },
+            ...rest,
+        };
+        return this.makeRequest('POST', '/organizations/', { body });
+    }
+    async updateOrganization(organizationId, organizationData) {
+        return this.makeRequest('PATCH', `/organizations/${organizationId}`, { body: organizationData });
+    }
+    async deleteOrganization(organizationId) {
+        return this.makeRequest('DELETE', `/organizations/${organizationId}`);
+    }
+    async getOrganizationSettings(organizationId) {
+        return this.makeRequest('GET', `/organizations/${organizationId}/settings`);
+    }
+    // ==================== WHITELABELS METHODS (Phase 4) ====================
+    async listWhitelabels(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/whitelabels/', { params });
+    }
+    async getWhitelabel(whitelabelId) {
+        return this.makeRequest('GET', `/whitelabels/${whitelabelId}`);
+    }
+    async createWhitelabel(whitelabelData) {
+        return this.makeRequest('POST', '/whitelabels/', { body: whitelabelData });
+    }
+    async updateWhitelabel(whitelabelId, whitelabelData) {
+        return this.makeRequest('PATCH', `/whitelabels/${whitelabelId}`, { body: whitelabelData });
+    }
+    async deleteWhitelabel(whitelabelId) {
+        return this.makeRequest('DELETE', `/whitelabels/${whitelabelId}`);
+    }
+    // ==================== BILLING METHODS (Phase 4) ====================
+    async getBillingOverview() {
+        return this.makeRequest('GET', '/billing/');
+    }
+    async listInvoices(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/billing/invoices', { params });
+    }
+    async getInvoice(invoiceId) {
+        return this.makeRequest('GET', `/billing/invoices/${invoiceId}`);
+    }
+    async listTransactions(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/billing/transactions', { params });
+    }
+    async getPricingPackages() {
+        return this.makeRequest('GET', '/billing/packages');
+    }
+    async getUsage(params = {}) {
+        return this.makeRequest('GET', '/billing/usage', { params });
+    }
+    async getBillingSettings(organizationId) {
+        const path = organizationId ? `/organizations/${organizationId}/billing` : '/billing/settings';
+        return this.makeRequest('GET', path);
+    }
+    async updateBillingSettings(organizationId, data) {
+        const path = organizationId ? `/organizations/${organizationId}/billing` : '/billing/settings';
+        return this.makeRequest('PUT', path, { body: data });
+    }
+    // ==================== CHAT METHODS ====================
+    async createChat(chatData) {
+        return this.makeRequest('POST', '/chats', { body: chatData });
+    }
+    async listChats(params = {}) {
+        return this.makeRequest('GET', '/chats', { params });
+    }
+    async getChat(chatId) {
+        return this.makeRequest('GET', `/chats/${chatId}`);
+    }
+    async deleteChat(chatId) {
+        return this.makeRequest('DELETE', `/chats/${chatId}`);
+    }
+    // ==================== WIDGET CONFIG METHODS ====================
+    async getWidgetConfig(organizationId) {
+        return this.makeRequest('GET', `/organizations/${organizationId}/chat-widget-config`);
+    }
+    async updateWidgetConfig(organizationId, config) {
+        return this.makeRequest('PATCH', `/organizations/${organizationId}/chat-widget-config`, { body: config });
+    }
+    async getAgentWidgetConfig(agentId) {
+        return this.makeRequest('GET', `/chat-widget/${agentId}/config`);
+    }
+    // ==================== TEST METHODS ====================
+    async createTestCase(agentId, testData) {
+        return this.makeRequest('POST', `/agents/${agentId}/tests`, { body: testData });
+    }
+    async listTestCases(agentId) {
+        return this.makeRequest('GET', `/agents/${agentId}/tests`);
+    }
+    async getTestCase(agentId, testCaseId) {
+        return this.makeRequest('GET', `/agents/${agentId}/tests/${testCaseId}`);
+    }
+    async updateTestCase(agentId, testCaseId, testData) {
+        return this.makeRequest('PATCH', `/agents/${agentId}/tests/${testCaseId}`, { body: testData });
+    }
+    async deleteTestCase(agentId, testCaseId) {
+        return this.makeRequest('DELETE', `/agents/${agentId}/tests/${testCaseId}`);
+    }
+    async listTestRuns(agentId, params = {}) {
+        return this.makeRequest('GET', `/agents/${agentId}/tests/runs`, { params });
+    }
+    async getTestRun(agentId, runId) {
+        return this.makeRequest('GET', `/agents/${agentId}/tests/runs/${runId}`);
+    }
+    async runTest(agentId, testCaseId) {
+        return this.makeRequest('POST', `/agents/${agentId}/tests/${testCaseId}/run`);
+    }
+    async runAllTests(agentId) {
+        return this.makeRequest('POST', `/agents/${agentId}/tests/run`);
+    }
+    // ==================== STATISTICS METHODS ====================
+    async getStatistic(endpoint, params = {}) {
+        return this.makeRequest('GET', `/statistics/${endpoint}`, { params });
+    }
+    // ==================== CALENDAR METHODS ====================
+    async getCalendarAuthUrl(params) {
+        return this.makeRequest('GET', '/calendar/auth/connect', { params });
+    }
+    async disconnectCalendar(connectionId) {
+        return this.makeRequest('POST', `/calendar/auth/disconnect/${connectionId}`);
+    }
+    async listCalendarConnections(params = {}) {
+        return this.makeRequest('GET', '/calendar/connections', { params });
+    }
+    async getCalendarConnection(connectionId) {
+        return this.makeRequest('GET', `/calendar/connections/${connectionId}`);
+    }
+    async updateCalendarConnection(connectionId, data) {
+        return this.makeRequest('PATCH', `/calendar/connections/${connectionId}`, { body: data });
+    }
+    async listCalendarConnectionCalendars(connectionId) {
+        return this.makeRequest('GET', `/calendar/connections/${connectionId}/calendars`);
+    }
+    async listAvailableCalendarConnections() {
+        return this.makeRequest('GET', '/calendar/connections/available');
+    }
+    async listBookingTypes() {
+        return this.makeRequest('GET', '/calendar/booking-types');
+    }
+    async createBookingType(data) {
+        return this.makeRequest('POST', '/calendar/booking-types', { body: data });
+    }
+    async getBookingType(bookingTypeId) {
+        return this.makeRequest('GET', `/calendar/booking-types/${bookingTypeId}`);
+    }
+    async updateBookingType(bookingTypeId, data) {
+        return this.makeRequest('PATCH', `/calendar/booking-types/${bookingTypeId}`, { body: data });
+    }
+    async deleteBookingType(bookingTypeId) {
+        return this.makeRequest('DELETE', `/calendar/booking-types/${bookingTypeId}`);
+    }
+    async addBookingTypeMember(bookingTypeId, data) {
+        return this.makeRequest('POST', `/calendar/booking-types/${bookingTypeId}/members`, { body: data });
+    }
+    async removeBookingTypeMember(bookingTypeId, memberId) {
+        return this.makeRequest('DELETE', `/calendar/booking-types/${bookingTypeId}/members/${memberId}`);
+    }
+    async listAppointments(params = {}) {
+        return this.makeRequest('GET', '/calendar/appointments', { params });
+    }
+    async cancelAppointment(appointmentId) {
+        return this.makeRequest('POST', `/calendar/appointments/${appointmentId}/cancel`);
+    }
+    // ==================== CAMPAIGN METHODS ====================
+    async listCampaigns(params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', '/campaigns/', { params });
+    }
+    async getCampaign(campaignId) {
+        return this.makeRequest('GET', `/campaigns/${campaignId}`);
+    }
+    async createCampaign(campaignData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('POST', '/campaigns/', { body: campaignData, params });
+    }
+    async updateCampaign(campaignId, campaignData, targetUserId) {
+        const params = {};
+        if (targetUserId)
+            params.target_user_id = targetUserId;
+        return this.makeRequest('PATCH', `/campaigns/${campaignId}`, { body: campaignData, params });
+    }
+    async deleteCampaign(campaignId) {
+        return this.makeRequest('DELETE', `/campaigns/${campaignId}`);
+    }
+    async startCampaign(campaignId) {
+        return this.makeRequest('POST', `/campaigns/${campaignId}/start`);
+    }
+    async pauseCampaign(campaignId) {
+        return this.makeRequest('POST', `/campaigns/${campaignId}/pause`);
+    }
+    async resumeCampaign(campaignId) {
+        return this.makeRequest('POST', `/campaigns/${campaignId}/resume`);
+    }
+    async cancelCampaign(campaignId) {
+        return this.makeRequest('POST', `/campaigns/${campaignId}/cancel`);
+    }
+    async getCampaignStats(campaignId) {
+        return this.makeRequest('GET', `/campaigns/${campaignId}/stats`);
+    }
+    async addCampaignContacts(campaignId, contactIds) {
+        return this.makeRequest('POST', `/campaigns/${campaignId}/contacts`, { body: { contact_ids: contactIds } });
+    }
+    async getCampaignContacts(campaignId, params = {}) {
+        if (params.offset !== undefined) {
+            params.skip = params.offset;
+            delete params.offset;
+        }
+        return this.makeRequest('GET', `/campaigns/${campaignId}/contacts`, { params });
+    }
+    async removeCampaignContact(campaignId, contactId) {
+        return this.makeRequest('DELETE', `/campaigns/${campaignId}/contacts/${contactId}`);
+    }
+}
+//# sourceMappingURL=dalvon.js.map