@sinch/mcp/dist/tools/voice/conference.js

Sinch MCP server

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.conferenceCalloutHandler = exports.registerConferenceCallout = void 0;
const crypto_1 = __importDefault(require("crypto"));
const zod_1 = require("zod");
const voice_service_helper_1 = require("./utils/voice-service-helper");
const voice_tools_helper_1 = require("./utils/voice-tools-helper");
const utils_1 = require("../../utils");
const types_1 = require("../../types");
const TOOL_KEY = 'conferenceCallout';
const TOOL_NAME = (0, voice_tools_helper_1.getToolName)(TOOL_KEY);
const registerConferenceCallout = (server, tags) => {
    if (!(0, utils_1.matchesAnyTag)(tags, voice_tools_helper_1.voiceToolsConfig[TOOL_KEY].tags))
        return;
    server.tool(TOOL_NAME, 'Call a phone number and connects it to a conference room when answered', {
        phoneNumbers: zod_1.z.array(zod_1.z.string()).describe('The phone numbers to call and connect to the conference room'),
        conferenceId: zod_1.z.string().optional().describe('The conference room ID. If not provided, a new one will be generated.'),
    }, exports.conferenceCalloutHandler);
};
exports.registerConferenceCallout = registerConferenceCallout;
const conferenceCalloutHandler = async ({ phoneNumbers, conferenceId }) => {
    const maybeService = (0, voice_service_helper_1.getVoiceService)(TOOL_NAME);
    if ((0, utils_1.isPromptResponse)(maybeService)) {
        return maybeService.promptResponse;
    }
    const voiceService = maybeService;
    const cli = process.env.CALLING_LINE_IDENTIFICATION;
    if (!conferenceId) {
        conferenceId = crypto_1.default.randomUUID();
    }
    const errors = [];
    const successfulCalls = [];
    for (const phoneNumber of phoneNumbers) {
        const request = {
            conferenceCalloutRequestBody: {
                method: 'conferenceCallout',
                conferenceCallout: {
                    destination: {
                        type: 'number',
                        endpoint: phoneNumber
                    },
                    conferenceId
                }
            }
        };
        if (cli) {
            request.conferenceCalloutRequestBody.conferenceCallout.cli = cli;
        }
        try {
            const response = await voiceService.callouts.conference(request);
            if (response.callId) {
                successfulCalls.push({
                    phoneNumber: request.conferenceCalloutRequestBody.conferenceCallout.destination.endpoint,
                    callId: response.callId
                });
            }
        }
        catch (error) {
            errors.push({
                phoneNumber: request.conferenceCalloutRequestBody.conferenceCallout.destination.endpoint,
                error: error.message
            });
        }
    }
    return new types_1.PromptResponse(JSON.stringify({
        success: true,
        conference_id: conferenceId,
        successful_calls: successfulCalls.map(call => ({
            phone_number: call.phoneNumber,
            call_id: call.callId
        })),
        failed_calls: errors.map(err => ({
            phone_number: err.phoneNumber,
            error: err.error
        }))
    })).promptResponse;
};
exports.conferenceCalloutHandler = conferenceCalloutHandler;
//# sourceMappingURL=conference.js.map