@abhinavyadav/bolna-mcp 1.0.0

package/dist/tools/batches.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerBatchTools", {
+    enumerable: true,
+    get: function() {
+        return registerBatchTools;
+    }
+});
+const _zod = require("zod");
+const _formdata = /*#__PURE__*/ _interop_require_default(require("form-data"));
+const _client = require("../client.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function registerBatchTools(server) {
+    server.tool("bolna_create_batch", "Create a batch call campaign by uploading a CSV of phone numbers for a Bolna agent", {
+        agent_id: _zod.z.string().describe("UUID of the Bolna agent to use for batch calls"),
+        csv_content: _zod.z.string().describe('Raw CSV string with a "phone_number" column (plus optional variable columns). Example: "phone_number,name\\n+919876543210,Rahul"'),
+        csv_filename: _zod.z.string().optional().default("contacts.csv").describe("Filename to use for the uploaded CSV"),
+        from_phone_numbers: _zod.z.array(_zod.z.string()).optional().describe("List of caller IDs in E.164 format to rotate through"),
+        webhook_url: _zod.z.string().url().optional().describe("Webhook URL for batch status updates"),
+        retry_config: _zod.z.object({
+            enabled: _zod.z.boolean().optional(),
+            max_retries: _zod.z.number().int().min(1).max(3).optional(),
+            retry_on_statuses: _zod.z.array(_zod.z.enum([
+                "no-answer",
+                "busy",
+                "failed",
+                "error"
+            ])).optional(),
+            retry_intervals_minutes: _zod.z.array(_zod.z.number()).optional()
+        }).optional().describe("Retry configuration for failed calls in the batch")
+    }, async (args)=>{
+        try {
+            const form = new _formdata.default();
+            form.append("agent_id", args.agent_id);
+            // Convert csv_content string to a Buffer and attach as multipart file
+            const csvBuffer = Buffer.from(args.csv_content, "utf-8");
+            form.append("file", csvBuffer, {
+                filename: args.csv_filename ?? "contacts.csv",
+                contentType: "text/csv"
+            });
+            if (args.from_phone_numbers && args.from_phone_numbers.length > 0) {
+                args.from_phone_numbers.forEach((num)=>form.append("from_phone_numbers", num));
+            }
+            if (args.webhook_url) {
+                form.append("webhook_url", args.webhook_url);
+            }
+            if (args.retry_config) {
+                form.append("retry_config", JSON.stringify(args.retry_config));
+            }
+            const response = await _client.bolnaClient.post("/batches", form, {
+                headers: {
+                    ...form.getHeaders()
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_create_batch");
+        }
+    });
+    server.tool("bolna_schedule_batch", "Schedule a previously created batch to run at a specific date and time", {
+        batch_id: _zod.z.string().describe("The batch ID to schedule"),
+        run_at: _zod.z.string().describe('ISO 8601 datetime when the batch should start, e.g. "2025-08-21T10:00:00"')
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post(`/batches/${args.batch_id}/schedule`, {
+                run_at: args.run_at
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_schedule_batch");
+        }
+    });
+    server.tool("bolna_stop_batch", "Stop a running batch campaign and cancel all pending calls in it", {
+        batch_id: _zod.z.string().describe("The batch ID to stop")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post(`/batches/${args.batch_id}/stop`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Batch ${args.batch_id} stopped successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_stop_batch");
+        }
+    });
+    server.tool("bolna_get_batch", "Get detailed status and call counts for a specific batch campaign", {
+        batch_id: _zod.z.string().describe("The batch ID to retrieve")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/batches/${args.batch_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_batch");
+        }
+    });
+    server.tool("bolna_list_batches", "List all batch campaigns for a given Bolna agent", {
+        agent_id: _zod.z.string().describe("The agent ID whose batches to list"),
+        page_number: _zod.z.number().int().positive().optional().default(1).describe("Page number (1-indexed)"),
+        page_size: _zod.z.number().int().positive().optional().default(10).describe("Number of batches per page")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/agent/${args.agent_id}/batches`, {
+                params: {
+                    page_number: args.page_number ?? 1,
+                    page_size: args.page_size ?? 10
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_batches");
+        }
+    });
+    server.tool("bolna_get_batch_executions", "List all individual call executions within a batch campaign", {
+        batch_id: _zod.z.string().describe("The batch ID to retrieve executions for"),
+        page_number: _zod.z.number().int().positive().optional().default(1).describe("Page number (1-indexed)"),
+        page_size: _zod.z.number().int().positive().optional().default(10).describe("Number of executions per page")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/batches/${args.batch_id}/executions`, {
+                params: {
+                    page_number: args.page_number ?? 1,
+                    page_size: args.page_size ?? 10
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_batch_executions");
+        }
+    });
+    server.tool("bolna_delete_batch", "Permanently delete a batch campaign by its ID", {
+        batch_id: _zod.z.string().describe("The batch ID to delete")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/batches/${args.batch_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Batch ${args.batch_id} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_batch");
+        }
+    });
+}

package/dist/tools/calls.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerCallTools", {
+    enumerable: true,
+    get: function() {
+        return registerCallTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerCallTools(server) {
+    server.tool("bolna_make_call", "Initiate an outbound voice call using a Bolna agent to a specified phone number", {
+        agent_id: _zod.z.string().uuid().describe("UUID of the Bolna agent to use for the call"),
+        recipient_phone_number: _zod.z.string().describe('Recipient phone number in E.164 format, e.g. "+919876543210"'),
+        from_phone_number: _zod.z.string().optional().describe("Caller ID in E.164 format (optional)"),
+        scheduled_at: _zod.z.string().optional().describe('ISO 8601 datetime to schedule the call, e.g. "2025-08-21T10:35:00"'),
+        user_data: _zod.z.record(_zod.z.unknown()).optional().describe("Key-value pairs for dynamic prompt variable substitution in the agent"),
+        bypass_call_guardrails: _zod.z.boolean().optional().default(false).describe("Skip call guardrails if true"),
+        retry_enabled: _zod.z.boolean().optional().describe("Enable automatic call retries"),
+        retry_max_retries: _zod.z.number().int().min(1).max(3).optional().describe("Number of retry attempts (1–3)"),
+        retry_on_statuses: _zod.z.array(_zod.z.enum([
+            "no-answer",
+            "busy",
+            "failed",
+            "error"
+        ])).optional().describe("Call statuses that should trigger a retry"),
+        retry_intervals_minutes: _zod.z.array(_zod.z.number()).optional().describe("Minutes to wait before each retry attempt, e.g. [30, 60, 120]")
+    }, async (args)=>{
+        try {
+            const body = {
+                agent_id: args.agent_id,
+                recipient_phone_number: args.recipient_phone_number
+            };
+            if (args.from_phone_number !== undefined) body.from_phone_number = args.from_phone_number;
+            if (args.scheduled_at !== undefined) body.scheduled_at = args.scheduled_at;
+            if (args.user_data !== undefined) body.user_data = args.user_data;
+            if (args.bypass_call_guardrails !== undefined) body.bypass_call_guardrails = args.bypass_call_guardrails;
+            // Build retry_config only if any retry field is provided
+            if (args.retry_enabled !== undefined || args.retry_max_retries !== undefined || args.retry_on_statuses !== undefined || args.retry_intervals_minutes !== undefined) {
+                body.retry_config = {
+                    ...args.retry_enabled !== undefined && {
+                        enabled: args.retry_enabled
+                    },
+                    ...args.retry_max_retries !== undefined && {
+                        max_retries: args.retry_max_retries
+                    },
+                    ...args.retry_on_statuses !== undefined && {
+                        retry_on_statuses: args.retry_on_statuses
+                    },
+                    ...args.retry_intervals_minutes !== undefined && {
+                        retry_intervals_minutes: args.retry_intervals_minutes
+                    }
+                };
+            }
+            const response = await _client.bolnaClient.post("/call", body);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_make_call");
+        }
+    });
+    server.tool("bolna_stop_call", "Immediately terminate an active call by its execution ID", {
+        execution_id: _zod.z.string().describe("The execution ID of the active call to stop")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post(`/call/stop/${args.execution_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Call ${args.execution_id} stopped successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_stop_call");
+        }
+    });
+}

package/dist/tools/dispositions.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerDispositionTools", {
+    enumerable: true,
+    get: function() {
+        return registerDispositionTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+// Shared schema for a single ObjectiveOption (used in create/update/bulk)
+const objectiveOptionSchema = _zod.z.lazy(()=>_zod.z.object({
+        value: _zod.z.string().describe("Value returned when this option is selected"),
+        condition: _zod.z.string().describe("Natural-language condition describing when this option applies"),
+        sub_options: _zod.z.array(objectiveOptionSchema).optional().describe("Nested sub-options for hierarchical classifications")
+    }));
+function registerDispositionTools(server) {
+    server.tool("bolna_create_disposition", "Create a new call extraction disposition and link it to a Bolna agent", {
+        agent_id: _zod.z.string().uuid().describe("UUID of the agent this disposition will be linked to"),
+        name: _zod.z.string().describe("Display name for the disposition"),
+        question: _zod.z.string().describe("The prompt sent to the LLM to evaluate the transcript"),
+        category: _zod.z.string().optional().default("General").describe('Category grouping for the disposition (default: "General")'),
+        system_prompt: _zod.z.string().optional().describe("Optional system context for the evaluating LLM"),
+        model: _zod.z.string().optional().default("gpt-4.1-mini").describe("LLM model to use for evaluation"),
+        is_subjective: _zod.z.boolean().optional().default(false).describe("Enable free-text response"),
+        is_objective: _zod.z.boolean().optional().default(false).describe("Enable pre-defined value selection"),
+        subjective_type: _zod.z.enum([
+            "text",
+            "timestamp",
+            "numeric",
+            "boolean",
+            "email",
+            "regex"
+        ]).optional().default("text").describe("Format constraint for the free-text response"),
+        subjective_type_config: _zod.z.object({
+            pattern: _zod.z.string().describe("Regex pattern the answer must match"),
+            description: _zod.z.string().optional()
+        }).optional().describe("Required when subjective_type is 'regex'"),
+        objective_options: _zod.z.array(objectiveOptionSchema).optional().describe("Required when is_objective is true")
+    }, async (args)=>{
+        try {
+            const body = {
+                agent_id: args.agent_id,
+                name: args.name,
+                question: args.question,
+                category: args.category ?? "General",
+                model: args.model ?? "gpt-4.1-mini",
+                is_subjective: args.is_subjective ?? false,
+                is_objective: args.is_objective ?? false,
+                subjective_type: args.subjective_type ?? "text"
+            };
+            if (args.system_prompt !== undefined) body.system_prompt = args.system_prompt;
+            if (args.subjective_type_config !== undefined) body.subjective_type_config = args.subjective_type_config;
+            if (args.objective_options !== undefined) body.objective_options = args.objective_options;
+            const response = await _client.bolnaClient.post("/dispositions/", body);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_create_disposition");
+        }
+    });
+    server.tool("bolna_bulk_create_dispositions", "Atomically create and link multiple dispositions to an agent in a single request", {
+        agent_id: _zod.z.string().uuid().describe("UUID of the agent to link all dispositions to"),
+        dispositions: _zod.z.array(_zod.z.object({
+            name: _zod.z.string(),
+            question: _zod.z.string(),
+            category: _zod.z.string().optional(),
+            system_prompt: _zod.z.string().optional(),
+            model: _zod.z.string().optional(),
+            is_subjective: _zod.z.boolean().optional(),
+            is_objective: _zod.z.boolean().optional(),
+            subjective_type: _zod.z.enum([
+                "text",
+                "timestamp",
+                "numeric",
+                "boolean",
+                "email",
+                "regex"
+            ]).optional(),
+            objective_options: _zod.z.array(objectiveOptionSchema).optional()
+        })).describe("Array of disposition objects to create")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post("/dispositions/bulk", {
+                agent_id: args.agent_id,
+                dispositions: args.dispositions
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_bulk_create_dispositions");
+        }
+    });
+    server.tool("bolna_get_disposition", "Retrieve a single disposition by its ID", {
+        disposition_id: _zod.z.string().describe("UUID of the disposition to retrieve"),
+        agent_id: _zod.z.string().optional().describe("Optional agent UUID to scope the lookup")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/dispositions/${args.disposition_id}`, args.agent_id ? {
+                params: {
+                    agent_id: args.agent_id
+                }
+            } : {});
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_disposition");
+        }
+    });
+    server.tool("bolna_list_dispositions", "List all dispositions for your account, optionally filtered by agent", {
+        agent_id: _zod.z.string().optional().describe("Optional agent UUID to filter dispositions by")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get("/dispositions/", {
+                params: args.agent_id ? {
+                    agent_id: args.agent_id
+                } : {}
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_dispositions");
+        }
+    });
+    server.tool("bolna_update_disposition", "Update a disposition. When scoped to an agent, shared dispositions are copied before editing", {
+        disposition_id: _zod.z.string().describe("UUID of the disposition to update"),
+        agent_id: _zod.z.string().optional().describe("Agent UUID to scope the update (triggers copy-on-write for shared dispositions)"),
+        name: _zod.z.string().optional(),
+        question: _zod.z.string().optional(),
+        category: _zod.z.string().optional(),
+        system_prompt: _zod.z.string().optional(),
+        model: _zod.z.string().optional(),
+        is_subjective: _zod.z.boolean().optional(),
+        is_objective: _zod.z.boolean().optional(),
+        subjective_type: _zod.z.enum([
+            "text",
+            "timestamp",
+            "numeric",
+            "boolean",
+            "email",
+            "regex"
+        ]).optional(),
+        objective_options: _zod.z.array(objectiveOptionSchema).optional()
+    }, async (args)=>{
+        try {
+            const { disposition_id, agent_id, ...rest } = args;
+            const params = agent_id ? {
+                agent_id
+            } : {};
+            const response = await _client.bolnaClient.put(`/dispositions/${disposition_id}`, rest, {
+                params
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_update_disposition");
+        }
+    });
+    server.tool("bolna_delete_disposition", "Permanently delete a disposition by its ID", {
+        disposition_id: _zod.z.string().describe("UUID of the disposition to delete")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/dispositions/${args.disposition_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Disposition ${args.disposition_id} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_disposition");
+        }
+    });
+    server.tool("bolna_test_dispositions", "Test all dispositions linked to an agent against a call transcript to preview extraction results", {
+        agent_id: _zod.z.string().uuid().describe("UUID of the agent whose dispositions to test"),
+        transcript: _zod.z.array(_zod.z.object({
+            role: _zod.z.enum([
+                "user",
+                "assistant"
+            ]),
+            content: _zod.z.string()
+        })).describe("Conversation transcript as an array of role/content objects to evaluate")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post(`/v2/agent/${args.agent_id}/dispositions/test`, {
+                transcript: args.transcript
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_test_dispositions");
+        }
+    });
+}

package/dist/tools/executions.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerExecutionTools", {
+    enumerable: true,
+    get: function() {
+        return registerExecutionTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerExecutionTools(server) {
+    server.tool("bolna_get_execution", "Retrieve full details of a call execution including transcript and recording URL", {
+        execution_id: _zod.z.string().describe("The execution ID of the call to retrieve")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/execution/${args.execution_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_execution");
+        }
+    });
+    server.tool("bolna_list_agent_executions", "List all call executions for a specific Bolna agent with pagination", {
+        agent_id: _zod.z.string().describe("The agent ID whose call history to retrieve"),
+        page_number: _zod.z.number().int().positive().optional().default(1).describe("Page number (1-indexed)"),
+        page_size: _zod.z.number().int().positive().optional().default(10).describe("Number of executions per page")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/agent/${args.agent_id}/executions`, {
+                params: {
+                    page_number: args.page_number ?? 1,
+                    page_size: args.page_size ?? 10
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_agent_executions");
+        }
+    });
+    server.tool("bolna_get_execution_raw_logs", "Fetch raw debug logs for a call execution including LLM prompts, requests, responses, and reasoning", {
+        execution_id: _zod.z.string().describe("The execution ID whose raw logs to retrieve")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/execution/${args.execution_id}/raw-logs`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_execution_raw_logs");
+        }
+    });
+}

package/dist/tools/inbound.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerInboundTools", {
+    enumerable: true,
+    get: function() {
+        return registerInboundTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerInboundTools(server) {
+    server.tool("bolna_set_inbound_agent", "Associate a Bolna agent with a phone number so it automatically handles inbound calls", {
+        agent_id: _zod.z.string().describe("The agent ID to assign for handling inbound calls"),
+        phone_number: _zod.z.string().describe("The phone number (E.164 or as stored in Bolna) to configure for inbound")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post("/inbound/set-agent", {
+                agent_id: args.agent_id,
+                phone_number: args.phone_number
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_set_inbound_agent");
+        }
+    });
+    server.tool("bolna_unlink_inbound_agent", "Remove a Bolna agent from a phone number to disable automated inbound call answering", {
+        phone_number: _zod.z.string().describe("The phone number to unlink from its current inbound agent")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete("/inbound/unlink", {
+                data: {
+                    phone_number: args.phone_number
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Inbound agent unlinked from ${args.phone_number} successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_unlink_inbound_agent");
+        }
+    });
+}