@abhinavyadav/bolna-mcp 1.0.0

package/dist/tools/knowledgebases.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerKnowledgebaseTools", {
+    enumerable: true,
+    get: function() {
+        return registerKnowledgebaseTools;
+    }
+});
+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 registerKnowledgebaseTools(server) {
+    server.tool("bolna_create_knowledgebase", "Create a knowledgebase by uploading a PDF (as base64) or ingesting a web URL", {
+        source_type: _zod.z.enum([
+            "file",
+            "url"
+        ]).describe('"file" to upload a PDF, "url" to ingest a web page'),
+        // For file uploads
+        file_base64: _zod.z.string().optional().describe("Base64-encoded PDF content (required when source_type is 'file')"),
+        filename: _zod.z.string().optional().default("document.pdf").describe("Filename for the uploaded PDF (e.g. 'hospital_faqs.pdf')"),
+        // For URL ingestion
+        url: _zod.z.string().url().optional().describe("Web URL to ingest (required when source_type is 'url')")
+    }, async (args)=>{
+        try {
+            if (args.source_type === "file") {
+                if (!args.file_base64) {
+                    throw new Error("file_base64 is required when source_type is 'file'");
+                }
+                const form = new _formdata.default();
+                const fileBuffer = Buffer.from(args.file_base64, "base64");
+                form.append("file", fileBuffer, {
+                    filename: args.filename ?? "document.pdf",
+                    contentType: "application/pdf"
+                });
+                const response = await _client.bolnaClient.post("/knowledgebase", form, {
+                    headers: {
+                        ...form.getHeaders()
+                    }
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response.data, null, 2)
+                        }
+                    ]
+                };
+            } else {
+                // URL ingestion
+                if (!args.url) {
+                    throw new Error("url is required when source_type is 'url'");
+                }
+                const form = new _formdata.default();
+                form.append("url", args.url);
+                const response = await _client.bolnaClient.post("/knowledgebase", form, {
+                    headers: {
+                        ...form.getHeaders()
+                    }
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(response.data, null, 2)
+                        }
+                    ]
+                };
+            }
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_create_knowledgebase");
+        }
+    });
+    server.tool("bolna_list_knowledgebases", "List all knowledgebases in your Bolna account with their status and metadata", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/knowledgebase");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_knowledgebases");
+        }
+    });
+    server.tool("bolna_get_knowledgebase", "Retrieve details of a specific knowledgebase including its ID, filename, status, and creation time", {
+        knowledgebase_id: _zod.z.string().describe("The ID of the knowledgebase to retrieve")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/knowledgebase/${args.knowledgebase_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_knowledgebase");
+        }
+    });
+    server.tool("bolna_delete_knowledgebase", "Permanently delete a knowledgebase by its ID", {
+        knowledgebase_id: _zod.z.string().describe("The ID of the knowledgebase to delete")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/knowledgebase/${args.knowledgebase_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Knowledgebase ${args.knowledgebase_id} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_knowledgebase");
+        }
+    });
+}

package/dist/tools/phone_numbers.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerPhoneNumberTools", {
+    enumerable: true,
+    get: function() {
+        return registerPhoneNumberTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerPhoneNumberTools(server) {
+    server.tool("bolna_search_phone_numbers", "Search for available phone numbers to purchase, filtered by country, area code, or pattern", {
+        country_code: _zod.z.string().describe('ISO 3166-1 alpha-2 country code, e.g. "US" for United States, "IN" for India'),
+        area_code: _zod.z.string().optional().describe("Area/region code to filter available numbers (optional)"),
+        pattern: _zod.z.string().optional().describe("Digit pattern to match in the phone number, e.g. '555' (optional)"),
+        limit: _zod.z.number().int().positive().optional().default(5).describe("Maximum number of results to return (default 5)")
+    }, async (args)=>{
+        try {
+            const params = {
+                country_code: args.country_code,
+                limit: args.limit ?? 5
+            };
+            if (args.area_code !== undefined) params.area_code = args.area_code;
+            if (args.pattern !== undefined) params.pattern = args.pattern;
+            const response = await _client.bolnaClient.get("/phone_numbers/search", {
+                params
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_search_phone_numbers");
+        }
+    });
+    server.tool("bolna_buy_phone_number", "Purchase a specific phone number for use with Bolna agents", {
+        phone_number: _zod.z.string().describe("The phone number to purchase in E.164 format"),
+        telephony_provider: _zod.z.string().describe('Telephony provider to use, e.g. "twilio", "plivo", "vonage"')
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post("/phone_numbers/buy", {
+                phone_number: args.phone_number,
+                telephony_provider: args.telephony_provider
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_buy_phone_number");
+        }
+    });
+    server.tool("bolna_list_phone_numbers", "List all phone numbers purchased and associated with your Bolna account", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/phone_numbers");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_phone_numbers");
+        }
+    });
+    server.tool("bolna_delete_phone_number", "Delete a purchased phone number to stop billing and permanently remove it from your account", {
+        phone_number: _zod.z.string().describe("The phone number to delete (as stored in Bolna, E.164 format)")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/phone_numbers/${encodeURIComponent(args.phone_number)}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Phone number ${args.phone_number} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_phone_number");
+        }
+    });
+}

package/dist/tools/providers.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerProviderTools", {
+    enumerable: true,
+    get: function() {
+        return registerProviderTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerProviderTools(server) {
+    server.tool("bolna_add_provider", "Securely add a new provider (e.g. LLM, TTS, STT, telephony) API key to your Bolna account", {
+        provider_name: _zod.z.string().describe('Provider key name as recognised by Bolna, e.g. "OPENAI_API_KEY", "ELEVENLABS_API_KEY", "DEEPGRAM_API_KEY"'),
+        provider_value: _zod.z.string().describe("The secret API key or credential value for the provider")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post("/providers", {
+                provider_name: args.provider_name,
+                provider_value: args.provider_value
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_add_provider");
+        }
+    });
+    server.tool("bolna_list_providers", "List all providers (API integrations) configured in your Bolna account", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/providers");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_providers");
+        }
+    });
+    server.tool("bolna_remove_provider", "Remove a previously added provider API key from your Bolna account", {
+        provider_key_name: _zod.z.string().describe('The provider key name to remove, e.g. "OPENAI_API_KEY"')
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/providers/${args.provider_key_name}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Provider ${args.provider_key_name} removed successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_remove_provider");
+        }
+    });
+}

package/dist/tools/sip_trunks.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerSipTrunkTools", {
+    enumerable: true,
+    get: function() {
+        return registerSipTrunkTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerSipTrunkTools(server) {
+    server.tool("bolna_create_sip_trunk", "Create a new SIP trunk (BYOT) on Bolna for inbound/outbound calling via your own telephony provider", {
+        name: _zod.z.string().describe("Human-readable label for the trunk (must be unique per account)"),
+        provider: _zod.z.string().describe('SIP provider, e.g. "twilio", "plivo", "zadarma", "telnyx", "vonage", "custom"'),
+        auth_type: _zod.z.enum([
+            "userpass",
+            "ip-based"
+        ]).describe("Authentication method for the trunk"),
+        gateways: _zod.z.array(_zod.z.object({
+            gateway_address: _zod.z.string().describe("Hostname or IP of the SIP gateway"),
+            port: _zod.z.number().int().optional().default(5060),
+            priority: _zod.z.number().int().optional().default(1)
+        })).min(1).describe("At least one gateway is required"),
+        description: _zod.z.string().optional().describe("Optional description for internal reference"),
+        auth_username: _zod.z.string().optional().describe("SIP username (required when auth_type is 'userpass')"),
+        auth_password: _zod.z.string().optional().describe("SIP password (required when auth_type is 'userpass')"),
+        ip_identifiers: _zod.z.array(_zod.z.object({
+            ip_address: _zod.z.string()
+        })).optional().describe("IP ranges for ip-based auth, e.g. [{ip_address: '15.207.90.192/31'}]"),
+        inbound_enabled: _zod.z.boolean().optional().default(false).describe("Enable inbound calls on this trunk"),
+        outbound_leading_plus_enabled: _zod.z.boolean().optional().default(true).describe("Prepend + to outbound dialed numbers"),
+        allow: _zod.z.string().optional().default("ulaw,alaw").describe("Allowed codecs"),
+        disallow: _zod.z.string().optional().default("all").describe("Disallowed codecs"),
+        transport: _zod.z.enum([
+            "transport-udp",
+            "transport-tcp",
+            "transport-tls"
+        ]).optional().default("transport-udp")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.post("/sip-trunks/trunks", args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_create_sip_trunk");
+        }
+    });
+    server.tool("bolna_list_sip_trunks", "List all SIP trunks configured in your Bolna account", {
+        active_only: _zod.z.boolean().optional().describe("Filter to only active trunks")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get("/sip-trunks/trunks", {
+                params: args.active_only !== undefined ? {
+                    active: args.active_only
+                } : {}
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_sip_trunks");
+        }
+    });
+    server.tool("bolna_get_sip_trunk", "Get full details of a single SIP trunk including gateways, IP identifiers, and phone numbers", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID to retrieve")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/sip-trunks/trunks/${args.trunk_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_sip_trunk");
+        }
+    });
+    server.tool("bolna_update_sip_trunk", "Partially update an existing SIP trunk (only included fields are changed)", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID to update"),
+        name: _zod.z.string().optional(),
+        description: _zod.z.string().optional(),
+        inbound_enabled: _zod.z.boolean().optional(),
+        outbound_leading_plus_enabled: _zod.z.boolean().optional(),
+        auth_username: _zod.z.string().optional(),
+        auth_password: _zod.z.string().optional()
+    }, async (args)=>{
+        try {
+            const { trunk_id, ...patch } = args;
+            const response = await _client.bolnaClient.patch(`/sip-trunks/trunks/${trunk_id}`, patch);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_update_sip_trunk");
+        }
+    });
+    server.tool("bolna_delete_sip_trunk", "Permanently delete a SIP trunk and all its associated gateways and phone numbers", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID to delete")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/sip-trunks/trunks/${args.trunk_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `SIP trunk ${args.trunk_id} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_sip_trunk");
+        }
+    });
+    server.tool("bolna_add_sip_trunk_number", "Add a DID phone number to a SIP trunk for inbound/outbound calling", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID to add the number to"),
+        phone_number: _zod.z.string().describe("The DID phone number to register on the trunk, e.g. '919876543210'"),
+        name: _zod.z.string().optional().describe("Optional label for the phone number"),
+        e164_check_enabled: _zod.z.boolean().optional().default(false).describe("Enforce E.164 format validation")
+    }, async (args)=>{
+        try {
+            const { trunk_id, ...body } = args;
+            const response = await _client.bolnaClient.post(`/sip-trunks/trunks/${trunk_id}/numbers`, body);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_add_sip_trunk_number");
+        }
+    });
+    server.tool("bolna_list_sip_trunk_numbers", "List all phone numbers associated with a SIP trunk", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID whose numbers to list")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/sip-trunks/trunks/${args.trunk_id}/numbers`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_sip_trunk_numbers");
+        }
+    });
+    server.tool("bolna_remove_sip_trunk_number", "Remove a phone number from a SIP trunk (also removes any agent mapping)", {
+        trunk_id: _zod.z.string().describe("The SIP trunk ID"),
+        phone_number_id: _zod.z.string().describe("The phone number record ID to remove")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/sip-trunks/trunks/${args.trunk_id}/numbers/${args.phone_number_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Phone number ${args.phone_number_id} removed from trunk ${args.trunk_id}.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_remove_sip_trunk_number");
+        }
+    });
+}

package/dist/tools/sub_accounts.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerSubAccountTools", {
+    enumerable: true,
+    get: function() {
+        return registerSubAccountTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerSubAccountTools(server) {
+    server.tool("bolna_create_sub_account", "Create a new sub-account for enterprise multi-tenant management (enterprise feature)", {
+        name: _zod.z.string().describe("Unique name for the sub-account, e.g. 'alpha-007'"),
+        allow_concurrent_calls: _zod.z.number().int().positive().describe("Maximum number of concurrent calls allowed for this sub-account"),
+        multi_tenant: _zod.z.boolean().optional().default(false).describe("Store sub-account data in a separate database"),
+        db_host: _zod.z.string().optional().describe("Database host (for multi-tenant)"),
+        db_name: _zod.z.string().optional().describe("Database name (for multi-tenant)"),
+        db_port: _zod.z.string().optional().describe("Database port (for multi-tenant)"),
+        db_user: _zod.z.string().optional().describe("Database user (for multi-tenant)"),
+        db_password: _zod.z.string().optional().describe("Database password (for multi-tenant)")
+    }, async (args)=>{
+        try {
+            const body = {
+                name: args.name,
+                allow_concurrent_calls: args.allow_concurrent_calls,
+                multi_tenant: args.multi_tenant ?? false
+            };
+            if (args.db_host) body.db_host = args.db_host;
+            if (args.db_name) body.db_name = args.db_name;
+            if (args.db_port) body.db_port = args.db_port;
+            if (args.db_user) body.db_user = args.db_user;
+            if (args.db_password) body.db_password = args.db_password;
+            const response = await _client.bolnaClient.post("/sub-accounts/create", body);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_create_sub_account");
+        }
+    });
+    server.tool("bolna_list_sub_accounts", "List all sub-accounts linked to your main Bolna organization account", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/sub-accounts/all");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_list_sub_accounts");
+        }
+    });
+    server.tool("bolna_get_sub_account_usage", "Track usage, consumption, and billing details for a specific sub-account", {
+        sub_account_id: _zod.z.string().describe("UUID of the sub-account to retrieve usage for")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.get(`/sub-accounts/${args.sub_account_id}/usage`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_sub_account_usage");
+        }
+    });
+    server.tool("bolna_get_all_sub_accounts_usage", "Retrieve usage, consumption, and billing details for ALL sub-accounts under your organization", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/sub-accounts/usage");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_all_sub_accounts_usage");
+        }
+    });
+    server.tool("bolna_patch_sub_account", "Partially update a sub-account's name or concurrent call limit", {
+        sub_account_id: _zod.z.string().describe("UUID of the sub-account to update"),
+        name: _zod.z.string().optional().describe("New name for the sub-account"),
+        allow_concurrent_calls: _zod.z.number().int().positive().optional().describe("New concurrent call limit")
+    }, async (args)=>{
+        try {
+            const { sub_account_id, ...patch } = args;
+            const response = await _client.bolnaClient.patch(`/sub-accounts/${sub_account_id}`, patch);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_patch_sub_account");
+        }
+    });
+    server.tool("bolna_delete_sub_account", "Permanently delete a sub-account and all its associated agents, batches, and executions", {
+        sub_account_id: _zod.z.string().describe("UUID of the sub-account to delete")
+    }, async (args)=>{
+        try {
+            const response = await _client.bolnaClient.delete(`/sub-accounts/${args.sub_account_id}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2) || `Sub-account ${args.sub_account_id} deleted successfully.`
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_delete_sub_account");
+        }
+    });
+}

package/dist/tools/user.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerUserTools", {
+    enumerable: true,
+    get: function() {
+        return registerUserTools;
+    }
+});
+const _zod = require("zod");
+const _client = require("../client.js");
+function registerUserTools(server) {
+    server.tool("bolna_get_user_info", "Get your Bolna account details including name, email, wallet balance, and concurrency limits", {}, async ()=>{
+        try {
+            const response = await _client.bolnaClient.get("/user/me");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_get_user_info");
+        }
+    });
+    server.tool("bolna_add_custom_llm", "Integrate a custom Large Language Model with your Bolna account for use in agents", {
+        model_name: _zod.z.string().describe("A unique name/identifier for your custom LLM model"),
+        api_base: _zod.z.string().url().describe("Base URL of your custom LLM's OpenAI-compatible API endpoint"),
+        api_key: _zod.z.string().optional().describe("API key for the custom LLM endpoint (if required)"),
+        model: _zod.z.string().optional().describe("The specific model ID to use at the endpoint")
+    }, async (args)=>{
+        try {
+            const body = {
+                model_name: args.model_name,
+                api_base: args.api_base
+            };
+            if (args.api_key) body.api_key = args.api_key;
+            if (args.model) body.model = args.model;
+            const response = await _client.bolnaClient.post("/user/add_model", body);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response.data, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            (0, _client.handleAxiosError)(error, "bolna_add_custom_llm");
+        }
+    });
+}