@kognitivedev/backend-cloud 0.2.29

package/dist/cloud-voice.js

@@ -0,0 +1,683 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLOUD_VOICE_FLOW_INSTRUCTION_COMPILER_VERSION = exports.CLOUD_VOICE_SIP_TRANSFER_TOOL = exports.CLOUD_VOICE_PHONE_HANGUP_TOOL = exports.CLOUD_VOICE_CHANNELS = exports.resolveCloudVoiceProviderSystemPrompt = exports.compileCloudVoiceInstructions = exports.buildPhoneOpeningPrompt = exports.buildPhoneControlRule = exports.toPreparedTranscription = exports.toOpenAITurnDetection = exports.resolveCloudVoiceSpeechLanguageCode = exports.normalizeCloudVoiceTurnDetection = exports.normalizeCloudVoicePipelineConfig = exports.normalizeCloudVoiceHumanizationConfig = exports.normalizeCloudVoiceConversationProfile = exports.getCloudVoiceProviderCapabilities = exports.compileCartesiaTtsOptions = exports.DEFAULT_CLOUD_VOICE_HUMANIZATION = exports.CLOUD_VOICE_PROVIDER_CAPABILITIES = exports.CLOUD_VOICE_PROMPT_COMPILER_VERSION = exports.CLOUD_VOICE_CONFIG_VERSION = void 0;
+exports.resolveCloudVoiceChannel = resolveCloudVoiceChannel;
+exports.shouldInjectPhoneControlTools = shouldInjectPhoneControlTools;
+exports.shouldInjectSipControlTools = shouldInjectSipControlTools;
+exports.shouldPersistPhonePrepareSnapshot = shouldPersistPhonePrepareSnapshot;
+exports.resolveToolInputSchema = resolveToolInputSchema;
+exports.compileVoiceGraphToInstructions = compileVoiceGraphToInstructions;
+exports.compileCloudVoiceGraphConfig = compileCloudVoiceGraphConfig;
+exports.normalizeClientToolManifests = normalizeClientToolManifests;
+exports.prepareCloudVoiceSessionConfig = prepareCloudVoiceSessionConfig;
+exports.createPhonePrepareSnapshot = createPhonePrepareSnapshot;
+const utils_1 = require("./utils");
+const cloud_voice_runtime_service_1 = require("./cloud-voice-runtime-service");
+const cloud_voice_prompt_service_1 = require("./cloud-voice-prompt-service");
+const cloud_voice_parameters_1 = require("./cloud-voice-parameters");
+var cloud_voice_runtime_service_2 = require("./cloud-voice-runtime-service");
+Object.defineProperty(exports, "CLOUD_VOICE_CONFIG_VERSION", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.CLOUD_VOICE_CONFIG_VERSION; } });
+Object.defineProperty(exports, "CLOUD_VOICE_PROMPT_COMPILER_VERSION", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.CLOUD_VOICE_PROMPT_COMPILER_VERSION; } });
+Object.defineProperty(exports, "CLOUD_VOICE_PROVIDER_CAPABILITIES", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.CLOUD_VOICE_PROVIDER_CAPABILITIES; } });
+Object.defineProperty(exports, "DEFAULT_CLOUD_VOICE_HUMANIZATION", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.DEFAULT_CLOUD_VOICE_HUMANIZATION; } });
+Object.defineProperty(exports, "compileCartesiaTtsOptions", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.compileCartesiaTtsOptions; } });
+Object.defineProperty(exports, "getCloudVoiceProviderCapabilities", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.getCloudVoiceProviderCapabilities; } });
+Object.defineProperty(exports, "normalizeCloudVoiceConversationProfile", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.normalizeCloudVoiceConversationProfile; } });
+Object.defineProperty(exports, "normalizeCloudVoiceHumanizationConfig", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.normalizeCloudVoiceHumanizationConfig; } });
+Object.defineProperty(exports, "normalizeCloudVoicePipelineConfig", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.normalizeCloudVoicePipelineConfig; } });
+Object.defineProperty(exports, "normalizeCloudVoiceTurnDetection", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.normalizeCloudVoiceTurnDetection; } });
+Object.defineProperty(exports, "resolveCloudVoiceSpeechLanguageCode", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.resolveCloudVoiceSpeechLanguageCode; } });
+Object.defineProperty(exports, "toOpenAITurnDetection", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.toOpenAITurnDetection; } });
+Object.defineProperty(exports, "toPreparedTranscription", { enumerable: true, get: function () { return cloud_voice_runtime_service_2.toPreparedTranscription; } });
+var cloud_voice_prompt_service_2 = require("./cloud-voice-prompt-service");
+Object.defineProperty(exports, "buildPhoneControlRule", { enumerable: true, get: function () { return cloud_voice_prompt_service_2.buildPhoneControlRule; } });
+Object.defineProperty(exports, "buildPhoneOpeningPrompt", { enumerable: true, get: function () { return cloud_voice_prompt_service_2.buildPhoneOpeningPrompt; } });
+Object.defineProperty(exports, "compileCloudVoiceInstructions", { enumerable: true, get: function () { return cloud_voice_prompt_service_2.compileCloudVoiceInstructions; } });
+Object.defineProperty(exports, "resolveCloudVoiceProviderSystemPrompt", { enumerable: true, get: function () { return cloud_voice_prompt_service_2.resolveCloudVoiceProviderSystemPrompt; } });
+exports.CLOUD_VOICE_CHANNELS = new Set(["web", "iframe", "script", "phone", "sip", "outbound"]);
+exports.CLOUD_VOICE_PHONE_HANGUP_TOOL = {
+    type: "function",
+    name: "hang_up_call",
+    description: "End the active phone call only after the caller clearly asks to end the call, says goodbye, or answers that they do not need anything else after you ask. Before using this tool, make sure the conversation has a natural closing: ask if there is anything else unless the caller already clearly ended, then say a brief goodbye such as \"bye\", \"see you later\", or \"take care\". Never use this when the caller asks what tools, abilities, or actions you have access to.",
+    parameters: {
+        type: "object",
+        properties: {
+            reason: {
+                type: "string",
+                description: "Short reason for ending the call.",
+            },
+        },
+        required: ["reason"],
+        additionalProperties: false,
+    },
+};
+exports.CLOUD_VOICE_SIP_TRANSFER_TOOL = {
+    type: "function",
+    name: "sip_transfer_call",
+    description: "Transfer the active SIP or phone call to a configured destination only when the current voice flow or agent policy allows transfer. Use this for live SIP/queue/extension/phone-number handoff, not for summarizing information.",
+    parameters: {
+        type: "object",
+        properties: {
+            providerCallId: {
+                type: "string",
+                description: "Provider call id for the active call leg. Omit when the runtime supplies it out of band.",
+            },
+            destinationId: {
+                type: "string",
+                description: "Configured transfer destination id.",
+            },
+            mode: {
+                type: "string",
+                enum: ["blind", "attended", "warm"],
+                description: "Transfer mode requested by the flow policy.",
+            },
+            reason: {
+                type: "string",
+                description: "Brief reason for the transfer.",
+            },
+        },
+        required: ["destinationId", "reason"],
+        additionalProperties: false,
+    },
+};
+function resolveCloudVoiceChannel(value) {
+    if (value === undefined || value === null || value === "")
+        return "web";
+    if (typeof value === "string" && exports.CLOUD_VOICE_CHANNELS.has(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported cloud voice channel "${String(value)}"`);
+}
+function shouldInjectPhoneControlTools(channel) {
+    return channel === "phone" || channel === "sip" || channel === "outbound";
+}
+function getTransferDestinations(config) {
+    const destinations = (0, utils_1.getRecord)(config.metadata).transferDestinations;
+    return Array.isArray(destinations)
+        ? destinations.filter((destination) => {
+            const record = (0, utils_1.getRecord)(destination);
+            return typeof record.id === "string" && record.id.trim() !== "" && typeof record.destination === "object";
+        })
+        : [];
+}
+function entryModeForChannel(channel) {
+    return channel === "outbound" ? "outgoing" : channel === "phone" ? "incoming" : "both";
+}
+function normalizeEntryMode(value) {
+    if (value === "incoming" || value === "inbound")
+        return "incoming";
+    if (value === "outgoing" || value === "outbound")
+        return "outgoing";
+    return "both";
+}
+function shouldInjectSipControlTools(config, channel) {
+    if (channel !== "sip" && channel !== "phone" && channel !== "outbound")
+        return false;
+    return getTransferDestinations(config).some((destination) => destination.destination.type !== "browser_queue");
+}
+function shouldPersistPhonePrepareSnapshot(channel) {
+    return shouldInjectPhoneControlTools(channel);
+}
+function resolveToolInputSchema(tool) {
+    var _a;
+    const schema = (_a = tool.inputSchema) !== null && _a !== void 0 ? _a : (0, utils_1.getRecord)(tool.config).inputSchema;
+    return schema && typeof schema === "object" && !Array.isArray(schema)
+        ? schema
+        : { type: "object", additionalProperties: true };
+}
+const MAX_FLOW_NODES = 64;
+const MAX_FLOW_EDGES = 128;
+const MAX_FLOW_TEXT_LENGTH = 900;
+exports.CLOUD_VOICE_FLOW_INSTRUCTION_COMPILER_VERSION = "voice-flow-paths-v1";
+function getFlowArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function cleanFlowText(value, maxLength = MAX_FLOW_TEXT_LENGTH) {
+    const text = (0, utils_1.getString)(value, "").replace(/\s+/g, " ").trim();
+    return text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;
+}
+function normalizeFlowOutput(value) {
+    const record = (0, utils_1.getRecord)(value);
+    const id = cleanFlowText(record.id, 96);
+    const label = cleanFlowText(record.label, 140);
+    if (!id || !label)
+        return null;
+    return {
+        id,
+        label,
+        description: cleanFlowText(record.description, 360) || undefined,
+        desc: cleanFlowText(record.desc, 360) || undefined,
+        condition: cleanFlowText(record.condition, 360) || undefined,
+        icon: cleanFlowText(record.icon, 96) || undefined,
+        metadata: (0, utils_1.getRecord)(record.metadata),
+    };
+}
+function normalizeFlowNode(value) {
+    const record = (0, utils_1.getRecord)(value);
+    const id = cleanFlowText(record.id, 96);
+    const type = cleanFlowText(record.type, 64) || "case";
+    if (!id)
+        return null;
+    const toolIds = getFlowArray(record.toolIds)
+        .map((toolId) => cleanFlowText(toolId, 96))
+        .filter(Boolean);
+    const phoneNumberIds = getFlowArray(record.phoneNumberIds)
+        .map((phoneNumberId) => cleanFlowText(phoneNumberId, 96))
+        .filter(Boolean);
+    const maxDuration = typeof record.maxDuration === "number" && Number.isFinite(record.maxDuration)
+        ? Math.round(record.maxDuration)
+        : cleanFlowText(record.maxDuration, 32) || undefined;
+    const transferMode = record.transferMode === "attended" || record.transferMode === "warm" || record.transferMode === "blind"
+        ? record.transferMode
+        : undefined;
+    const metadata = (0, utils_1.getRecord)(record.metadata);
+    const subAgentMetadata = type === "sub_agent"
+        ? Object.assign(Object.assign(Object.assign({}, (0, utils_1.getRecord)(metadata.subAgent)), ((0, utils_1.getString)(record.subAgentToolId, "") ? { toolId: (0, utils_1.getString)(record.subAgentToolId, "") } : {})), ((0, utils_1.getString)(record.subAgentSlug, "") ? { agentSlug: (0, utils_1.getString)(record.subAgentSlug, "") } : {})) : null;
+    return {
+        id,
+        type,
+        entryMode: normalizeEntryMode(record.entryMode),
+        title: cleanFlowText(record.title, 160) || undefined,
+        prompt: cleanFlowText(record.prompt) || undefined,
+        firstMessage: cleanFlowText(record.firstMessage, 360) || undefined,
+        language: cleanFlowText(record.language, 32) || undefined,
+        maxDuration,
+        outputs: getFlowArray(record.outputs).map(normalizeFlowOutput).filter((output) => Boolean(output)),
+        toolId: cleanFlowText(record.toolId, 96) || undefined,
+        toolIds,
+        phoneNumberIds,
+        transferTarget: cleanFlowText(record.transferTarget, 160) || undefined,
+        transferDestinationId: cleanFlowText(record.transferDestinationId, 96) || undefined,
+        transferMode,
+        metadata: subAgentMetadata ? Object.assign(Object.assign({}, metadata), { subAgent: subAgentMetadata }) : metadata,
+    };
+}
+function normalizeFlowEdge(value) {
+    const record = (0, utils_1.getRecord)(value);
+    const from = cleanFlowText(record.from, 96);
+    const to = cleanFlowText(record.to, 96);
+    if (!from || !to)
+        return null;
+    const fromPort = record.fromPort === null ? null : cleanFlowText(record.fromPort, 96) || null;
+    return {
+        id: cleanFlowText(record.id, 96) || undefined,
+        from,
+        fromPort,
+        to,
+    };
+}
+function normalizeFlowGraph(value) {
+    const record = (0, utils_1.getRecord)(value);
+    const nodes = getFlowArray(record.nodes)
+        .slice(0, MAX_FLOW_NODES)
+        .map(normalizeFlowNode)
+        .filter((node) => Boolean(node));
+    const knownNodeIds = new Set(nodes.map((node) => node.id));
+    const edges = getFlowArray(record.edges)
+        .slice(0, MAX_FLOW_EDGES)
+        .map(normalizeFlowEdge)
+        .filter((edge) => Boolean(edge && knownNodeIds.has(edge.from) && knownNodeIds.has(edge.to)));
+    if (nodes.length === 0)
+        return null;
+    const startNodeId = cleanFlowText(record.startNodeId, 96);
+    return {
+        version: record.version === 1 ? 1 : undefined,
+        startNodeId: startNodeId && knownNodeIds.has(startNodeId) ? startNodeId : undefined,
+        nodes,
+        edges,
+        metadata: (0, utils_1.getRecord)(record.metadata),
+    };
+}
+function resolveFlowStartNode(graph, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const entryMode = (_a = options.entryMode) !== null && _a !== void 0 ? _a : "both";
+    const initialNodes = graph.nodes.filter((node) => node.type === "initial");
+    const matchingStart = entryMode !== "both"
+        ? initialNodes.find((node) => normalizeEntryMode(node.entryMode) === entryMode)
+        : null;
+    const bothStart = initialNodes.find((node) => normalizeEntryMode(node.entryMode) === "both");
+    const legacyStart = (_d = (_c = (_b = graph.nodes.find((node) => node.id === graph.startNodeId)) !== null && _b !== void 0 ? _b : initialNodes[0]) !== null && _c !== void 0 ? _c : graph.nodes[0]) !== null && _d !== void 0 ? _d : null;
+    return (_e = matchingStart !== null && matchingStart !== void 0 ? matchingStart : bothStart) !== null && _e !== void 0 ? _e : legacyStart;
+}
+function outputDescription(output) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = output.condition) !== null && _a !== void 0 ? _a : output.description) !== null && _b !== void 0 ? _b : output.desc) !== null && _c !== void 0 ? _c : "";
+}
+function edgeTargetTitle(edge, nodesById) {
+    var _a;
+    const target = nodesById.get(edge.to);
+    return target ? `${(_a = target.title) !== null && _a !== void 0 ? _a : target.id} (${target.type})` : edge.to;
+}
+function collectNodeToolIds(node) {
+    var _a;
+    const metadata = (0, utils_1.getRecord)(node.metadata);
+    const subAgent = (0, utils_1.getRecord)(metadata.subAgent);
+    return [
+        node.toolId,
+        ...((_a = node.toolIds) !== null && _a !== void 0 ? _a : []),
+        (0, utils_1.getString)(node.subAgentToolId, ""),
+        (0, utils_1.getString)(subAgent.toolId, ""),
+        (0, utils_1.getString)(subAgent.subAgentToolId, ""),
+        (0, utils_1.getString)(metadata.toolId, ""),
+        (0, utils_1.getString)(metadata.toolName, ""),
+    ].map((value) => cleanFlowText(value, 96)).filter(Boolean);
+}
+function toolToManifest(tool) {
+    var _a;
+    return {
+        type: "function",
+        name: tool.id,
+        description: (_a = tool.description) !== null && _a !== void 0 ? _a : tool.name,
+        parameters: resolveToolInputSchema(tool),
+    };
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function hashText(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function graphSignature(graph) {
+    return hashText(stableJson(graph));
+}
+function toolLabel(toolId, toolsById) {
+    var _a;
+    const tool = toolsById.get(toolId);
+    return tool ? `${(_a = tool.name) !== null && _a !== void 0 ? _a : tool.id} (\`${tool.id}\`)` : `\`${toolId}\``;
+}
+function toolRequiredInputs(tool) {
+    if (!tool)
+        return "";
+    const schema = (0, utils_1.getRecord)(resolveToolInputSchema(tool));
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
+    return required.length > 0 ? required.join(", ") : "";
+}
+function outgoingEdges(nodeId, edgesBySource) {
+    var _a;
+    return (_a = edgesBySource.get(nodeId)) !== null && _a !== void 0 ? _a : [];
+}
+function outputForEdge(node, edge) {
+    var _a, _b;
+    return (_b = (_a = node === null || node === void 0 ? void 0 : node.outputs) === null || _a === void 0 ? void 0 : _a.find((output) => output.id === edge.fromPort)) !== null && _b !== void 0 ? _b : null;
+}
+function walkFlowPath(input) {
+    var _a, _b, _c, _d, _e, _f;
+    const steps = [];
+    const toolIds = [];
+    const visited = new Set((_a = input.visited) !== null && _a !== void 0 ? _a : []);
+    let current = (_b = input.nodesById.get(input.fromNodeId)) !== null && _b !== void 0 ? _b : null;
+    while (current && !visited.has(current.id)) {
+        visited.add(current.id);
+        const title = (_c = current.title) !== null && _c !== void 0 ? _c : current.id;
+        if (current.type !== "initial") {
+            if (current.prompt) {
+                steps.push(`At "${title}", ${current.prompt}`);
+            }
+            else if (current.type === "case") {
+                steps.push(`Handle "${title}" as the active case.`);
+            }
+        }
+        const currentToolIds = collectNodeToolIds(current);
+        if (current.type === "tool" && currentToolIds.length === 0 && current.title) {
+            const inferred = [...input.toolsById.keys()].find((toolId) => { var _a; return toolId === (current === null || current === void 0 ? void 0 : current.title) || toolId.replace(/[_-]/g, " ").toLowerCase() === ((_a = current === null || current === void 0 ? void 0 : current.title) === null || _a === void 0 ? void 0 : _a.toLowerCase()); });
+            if (inferred)
+                currentToolIds.push(inferred);
+        }
+        for (const toolId of currentToolIds) {
+            input.referencedToolIds.add(toolId);
+            toolIds.push(toolId);
+            const tool = input.toolsById.get(toolId);
+            const requiredInputs = toolRequiredInputs(tool);
+            if (current.type === "sub_agent") {
+                steps.push(`Call sub-agent tool ${toolLabel(toolId, input.toolsById)}${requiredInputs ? ` after collecting: ${requiredInputs}` : ""}. Wait for its final result, read the returned \`outcome\`, and continue through the matching outcome branch.`);
+                if (current.outputs && current.outputs.length > 0) {
+                    steps.push(`Sub-agent outcome branches: ${current.outputs.map((output) => `${output.label}${outputDescription(output) ? ` (${outputDescription(output)})` : ""}`).join("; ")}.`);
+                }
+            }
+            else {
+                steps.push(`Use ${toolLabel(toolId, input.toolsById)}${requiredInputs ? ` after collecting: ${requiredInputs}` : ""}.`);
+            }
+        }
+        if (current.type === "end" || current.type === "transfer") {
+            return { steps, toolIds, terminal: current };
+        }
+        const edges = outgoingEdges(current.id, input.edgesBySource);
+        const defaultEdge = (_e = (_d = edges.find((edge) => !edge.fromPort)) !== null && _d !== void 0 ? _d : edges[0]) !== null && _e !== void 0 ? _e : null;
+        if (!defaultEdge)
+            return { steps, toolIds, terminal: current };
+        const output = outputForEdge(current, defaultEdge);
+        if (output) {
+            const condition = outputDescription(output);
+            steps.push(`If "${output.label}"${condition ? ` (${condition})` : ""} matches inside this step, continue.`);
+        }
+        current = (_f = input.nodesById.get(defaultEdge.to)) !== null && _f !== void 0 ? _f : null;
+    }
+    return { steps: [...steps, "Stop following this route if it loops back to a node already visited."], toolIds, terminal: current };
+}
+function terminalInstruction(node) {
+    var _a;
+    if (!node)
+        return "";
+    const title = (_a = node.title) !== null && _a !== void 0 ? _a : node.id;
+    if (node.type === "end") {
+        return node.prompt ? `Then end with: ${node.prompt}` : `Then end at "${title}" with a brief polite closing.`;
+    }
+    if (node.type === "transfer") {
+        const target = node.transferTarget || node.transferDestinationId || title;
+        return node.prompt ? `Then transfer/escalate to ${target}: ${node.prompt}` : `Then transfer/escalate to ${target} with a concise handoff summary.`;
+    }
+    return "";
+}
+function compileVoiceGraphToInstructions(graphInput, options = {}) {
+    var _a, _b, _c, _d;
+    const graph = normalizeFlowGraph(graphInput);
+    if (!graph)
+        return null;
+    const entryMode = (_a = options.entryMode) !== null && _a !== void 0 ? _a : entryModeForChannel(options.channel);
+    const start = resolveFlowStartNode(graph, { entryMode });
+    const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const edgesBySource = new Map();
+    for (const edge of graph.edges) {
+        const list = (_b = edgesBySource.get(edge.from)) !== null && _b !== void 0 ? _b : [];
+        list.push(edge);
+        edgesBySource.set(edge.from, list);
+    }
+    const toolsById = new Map(((_c = options.tools) !== null && _c !== void 0 ? _c : []).map((tool) => [tool.id, tool]));
+    const referencedToolIds = new Set();
+    const warnings = [];
+    const signature = graphSignature(graph);
+    const lines = [
+        (start === null || start === void 0 ? void 0 : start.prompt) || "You are a realtime voice agent. Help the caller clearly and concisely.",
+        "",
+        "Use this conversation flow as the source of truth for routing and tool usage.",
+        "Do not reveal internal node IDs, graph structure, or implementation details to the caller.",
+        "Choose the first route that clearly matches the caller's intent. If no route clearly matches, ask one concise clarifying question.",
+    ];
+    if (start === null || start === void 0 ? void 0 : start.firstMessage) {
+        lines.push(`Opening rule: if you speak first, say exactly this as your first sentence before any other greeting or introduction: ${start.firstMessage}`, "Do not prepend, replace, or append an internal agent name, agent number, slug, node name, or workflow name to that first sentence.");
+    }
+    if (start === null || start === void 0 ? void 0 : start.language)
+        lines.push(`Use this language guidance when possible: ${start.language}.`);
+    if ((start === null || start === void 0 ? void 0 : start.maxDuration) !== undefined)
+        lines.push(`Keep the call within ${String(start.maxDuration)} minutes unless the caller needs a short final clarification.`);
+    const startEdges = start ? outgoingEdges(start.id, edgesBySource) : [];
+    const routeEdges = start && start.outputs && start.outputs.length > 0
+        ? start.outputs.flatMap((output) => startEdges.filter((edge) => edge.fromPort === output.id).map((edge) => ({ output, edge })))
+        : startEdges.map((edge) => ({ output: outputForEdge(start !== null && start !== void 0 ? start : undefined, edge), edge }));
+    if (routeEdges.length > 0) {
+        lines.push("", "Routes:");
+    }
+    routeEdges.forEach(({ output, edge }, index) => {
+        var _a;
+        const condition = output ? outputDescription(output) : "";
+        const routeName = (_a = output === null || output === void 0 ? void 0 : output.label) !== null && _a !== void 0 ? _a : edgeTargetTitle(edge, nodesById);
+        const path = walkFlowPath({
+            fromNodeId: edge.to,
+            nodesById,
+            edgesBySource,
+            toolsById,
+            referencedToolIds,
+            visited: start ? new Set([start.id]) : undefined,
+        });
+        lines.push("", `${index + 1}. When ${condition || routeName}:`);
+        if ((output === null || output === void 0 ? void 0 : output.label) && condition)
+            lines.push(`   Treat this as the "${output.label}" route.`);
+        if (path.steps.length === 0) {
+            lines.push(`   Continue to "${routeName}" and handle it according to its instruction.`);
+        }
+        else {
+            path.steps.forEach((step, stepIndex) => lines.push(`   ${stepIndex + 1}. ${step}`));
+        }
+        const uniqueToolIds = [...new Set(path.toolIds)];
+        if (uniqueToolIds.length > 0) {
+            lines.push(`   Use tools in this route: ${uniqueToolIds.map((toolId) => toolLabel(toolId, toolsById)).join(", ")}.`);
+            lines.push("   Never invent tool results. If a required tool is unavailable or returns no result, explain that limitation and ask for the next best detail.");
+        }
+        const terminal = terminalInstruction(path.terminal);
+        if (terminal)
+            lines.push(`   ${terminal}`);
+    });
+    if (routeEdges.length === 0 && start) {
+        lines.push("", "No explicit routes are connected. Follow the start node instructions, answer concisely, and ask one clarifying question when intent is unclear.");
+    }
+    lines.push("", "General tool and closing rules:", "- Use tools only when the matching route requires them or the caller provides enough context for that route.", "- Collect required tool inputs before calling a tool.", "- Summarize tool results in natural spoken language; do not read raw JSON or internal IDs unless they are useful to the caller.", "- Before ending, ask whether the caller needs anything else unless the caller already clearly ended the conversation.");
+    const missingToolIds = [...referencedToolIds].filter((toolId) => !toolsById.has(toolId));
+    if (missingToolIds.length > 0) {
+        warnings.push(`Flow graph references tools that are not configured on this agent: ${missingToolIds.join(", ")}`);
+        lines.push("", `Unavailable graph tools: ${missingToolIds.join(", ")}. If these are needed, explain that the action is unavailable instead of inventing results.`);
+    }
+    const toolManifest = [...referencedToolIds]
+        .flatMap((toolId) => {
+        const tool = toolsById.get(toolId);
+        return tool ? [toolToManifest(tool)] : [];
+    });
+    return {
+        instructions: lines.join("\n"),
+        compilerVersion: exports.CLOUD_VOICE_FLOW_INSTRUCTION_COMPILER_VERSION,
+        graphSignature: signature,
+        startNodeId: (_d = start === null || start === void 0 ? void 0 : start.id) !== null && _d !== void 0 ? _d : null,
+        entryMode,
+        nodeCount: graph.nodes.length,
+        edgeCount: graph.edges.length,
+        referencedToolIds: [...referencedToolIds],
+        missingToolIds,
+        toolManifest,
+        warnings,
+    };
+}
+function compileCloudVoiceGraphConfig(config) {
+    const compiledFlow = compileVoiceGraphToInstructions((0, utils_1.getRecord)(config.metadata).flowGraph, { tools: config.tools });
+    if (!compiledFlow)
+        return config;
+    const runtimeConfig = applyFlowStartRuntimeConfig(config);
+    return Object.assign(Object.assign({}, runtimeConfig), { instructions: compiledFlow.instructions, metadata: Object.assign(Object.assign({}, (0, utils_1.getRecord)(runtimeConfig.metadata)), { flowGraphInstructionCompiler: {
+                version: compiledFlow.compilerVersion,
+                graphSignature: compiledFlow.graphSignature,
+                entryMode: compiledFlow.entryMode,
+                compiledAt: new Date().toISOString(),
+            } }) });
+}
+function getFlowStartNode(config, options = {}) {
+    var _a, _b, _c, _d;
+    const flowGraph = (0, utils_1.getRecord)(config.metadata).flowGraph;
+    const graph = (0, utils_1.getRecord)(flowGraph);
+    const nodes = Array.isArray(graph.nodes) ? graph.nodes.map(utils_1.getRecord) : [];
+    if (nodes.length === 0)
+        return null;
+    const entryMode = (_a = options.entryMode) !== null && _a !== void 0 ? _a : "both";
+    const initialNodes = nodes.filter((node) => (0, utils_1.getString)(node.type) === "initial");
+    const matchingStart = entryMode !== "both"
+        ? initialNodes.find((node) => normalizeEntryMode(node.entryMode) === entryMode)
+        : null;
+    if (matchingStart)
+        return matchingStart;
+    const bothStart = initialNodes.find((node) => normalizeEntryMode(node.entryMode) === "both");
+    if (bothStart)
+        return bothStart;
+    const startNodeId = (0, utils_1.getString)(graph.startNodeId);
+    return (_d = (_c = (_b = nodes.find((node) => (0, utils_1.getString)(node.id) === startNodeId)) !== null && _b !== void 0 ? _b : initialNodes[0]) !== null && _c !== void 0 ? _c : nodes[0]) !== null && _d !== void 0 ? _d : null;
+}
+function isCloudVoiceProvider(value) {
+    return value === "openai-realtime"
+        || value === "gemini-live"
+        || value === "kognitive-voice"
+        || value === "xai-realtime";
+}
+function isCloudVoiceTransport(value) {
+    return value === "webrtc" || value === "websocket";
+}
+function applyFlowStartRuntimeConfig(config, options = {}) {
+    const start = getFlowStartNode(config, options);
+    if (!start)
+        return config;
+    const provider = (0, utils_1.getString)(start.provider);
+    const transport = (0, utils_1.getString)(start.transport);
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, config), (isCloudVoiceProvider(provider) ? { provider } : {})), ((0, utils_1.getString)(start.model) ? { model: (0, utils_1.getString)(start.model) } : {})), ((0, utils_1.getString)(start.voice) ? { voice: (0, utils_1.getString)(start.voice) } : {})), (isCloudVoiceTransport(transport) ? { transport } : {})), (start.providerOptions && typeof start.providerOptions === "object" && !Array.isArray(start.providerOptions)
+        ? { providerOptions: start.providerOptions }
+        : {})), (start.transcription === null || (start.transcription && typeof start.transcription === "object" && !Array.isArray(start.transcription))
+        ? { transcription: start.transcription }
+        : {})), (start.turnDetection === null || (start.turnDetection && typeof start.turnDetection === "object" && !Array.isArray(start.turnDetection))
+        ? { turnDetection: start.turnDetection }
+        : {})), (start.inputNoiseReduction === null || (start.inputNoiseReduction && typeof start.inputNoiseReduction === "object" && !Array.isArray(start.inputNoiseReduction))
+        ? { inputNoiseReduction: start.inputNoiseReduction }
+        : {})), (start.humanization && typeof start.humanization === "object" && !Array.isArray(start.humanization)
+        ? { humanization: start.humanization }
+        : {})), { metadata: Object.assign(Object.assign({}, (0, utils_1.getRecord)(config.metadata)), (start.speech && typeof start.speech === "object" && !Array.isArray(start.speech)
+            ? { speech: start.speech }
+            : {})) });
+}
+function normalizeClientToolManifests(value) {
+    if (!Array.isArray(value))
+        return [];
+    const tools = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const record = item;
+        const id = (0, utils_1.getString)(record.id, "");
+        if (!id || !/^[A-Za-z0-9_-]{1,64}$/.test(id))
+            continue;
+        const inputSchema = record.inputSchema && typeof record.inputSchema === "object" && !Array.isArray(record.inputSchema)
+            ? record.inputSchema
+            : { type: "object", additionalProperties: true };
+        tools.push({
+            id,
+            name: (0, utils_1.getString)(record.name, id),
+            description: (0, utils_1.getString)(record.description, (0, utils_1.getString)(record.name, id)),
+            inputSchema,
+        });
+    }
+    return tools.slice(0, 32);
+}
+function prepareCloudVoiceSessionConfig(config, input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+    const parameters = (_a = input.parameters) !== null && _a !== void 0 ? _a : {};
+    const channel = (_b = input.channel) !== null && _b !== void 0 ? _b : "web";
+    const entryMode = entryModeForChannel(channel);
+    const renderedConfig = (0, cloud_voice_parameters_1.renderCloudVoiceParameterObject)(applyFlowStartRuntimeConfig(config, { entryMode }), parameters);
+    const compiledFlow = compileVoiceGraphToInstructions((0, utils_1.getRecord)(renderedConfig.metadata).flowGraph, {
+        tools: renderedConfig.tools,
+        entryMode,
+    });
+    const compiledMarker = (0, utils_1.getRecord)((0, utils_1.getRecord)(config.metadata).flowGraphInstructionCompiler);
+    const useCompiledFlowAsAuthoredInstructions = Boolean(compiledMarker.version) && Boolean(compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.instructions);
+    const promptConfig = useCompiledFlowAsAuthoredInstructions
+        ? Object.assign(Object.assign({}, renderedConfig), { instructions: (_c = compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.instructions) !== null && _c !== void 0 ? _c : renderedConfig.instructions }) : renderedConfig;
+    const instructionsAlreadyIncludeCompiledFlow = Boolean(compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.instructions)
+        && (0, utils_1.getString)(promptConfig.instructions, "").includes((_d = compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.instructions) !== null && _d !== void 0 ? _d : "");
+    const shouldAppendCompiledFlow = Boolean(compiledFlow)
+        && !useCompiledFlowAsAuthoredInstructions
+        && !instructionsAlreadyIncludeCompiledFlow
+        && ((0, utils_1.getString)(compiledMarker.version, "") !== exports.CLOUD_VOICE_FLOW_INSTRUCTION_COMPILER_VERSION
+            || (0, utils_1.getString)(compiledMarker.graphSignature, "") !== (compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.graphSignature)
+            || (0, utils_1.getString)(compiledMarker.entryMode, "") !== entryMode);
+    const providerOptions = (0, utils_1.getRecord)(renderedConfig.providerOptions);
+    const speech = (0, cloud_voice_runtime_service_1.normalizeSpeechConfig)(renderedConfig);
+    const languageCode = (0, cloud_voice_runtime_service_1.resolveCloudVoiceSpeechLanguageCode)(renderedConfig);
+    const turnDetection = (0, cloud_voice_runtime_service_1.normalizeCloudVoiceTurnDetection)(renderedConfig.provider, channel, renderedConfig.turnDetection);
+    const capabilities = (0, cloud_voice_runtime_service_1.getCloudVoiceProviderCapabilities)(renderedConfig.provider);
+    const pipeline = renderedConfig.provider === "kognitive-voice" ? (0, cloud_voice_runtime_service_1.normalizeCloudVoicePipelineConfig)(renderedConfig) : undefined;
+    const cartesiaTtsOptions = renderedConfig.provider === "kognitive-voice" ? (0, cloud_voice_runtime_service_1.compileCartesiaTtsOptions)(renderedConfig) : undefined;
+    const maxOutputTokens = typeof providerOptions.maxOutputTokens === "number" && Number.isFinite(providerOptions.maxOutputTokens)
+        ? Math.max(1, Math.round(providerOptions.maxOutputTokens))
+        : typeof providerOptions.maxTokens === "number" && Number.isFinite(providerOptions.maxTokens)
+            ? Math.max(1, Math.round(providerOptions.maxTokens))
+            : "inf";
+    const temperature = typeof providerOptions.temperature === "number" && Number.isFinite(providerOptions.temperature)
+        ? Math.max(0, Math.min(2, providerOptions.temperature))
+        : undefined;
+    const toolManifestByName = new Map();
+    for (const tool of renderedConfig.tools) {
+        toolManifestByName.set(tool.id, {
+            type: "function",
+            name: tool.id,
+            description: (_e = tool.description) !== null && _e !== void 0 ? _e : tool.name,
+            parameters: resolveToolInputSchema(tool),
+        });
+    }
+    for (const tool of (_f = input.clientTools) !== null && _f !== void 0 ? _f : []) {
+        toolManifestByName.set(tool.id, {
+            type: "function",
+            name: tool.id,
+            description: (_h = (_g = tool.description) !== null && _g !== void 0 ? _g : tool.name) !== null && _h !== void 0 ? _h : tool.id,
+            parameters: (_j = tool.inputSchema) !== null && _j !== void 0 ? _j : { type: "object", additionalProperties: true },
+        });
+    }
+    if (shouldInjectPhoneControlTools(channel)) {
+        toolManifestByName.set(exports.CLOUD_VOICE_PHONE_HANGUP_TOOL.name, exports.CLOUD_VOICE_PHONE_HANGUP_TOOL);
+    }
+    if (shouldInjectSipControlTools(config, channel)) {
+        toolManifestByName.set(exports.CLOUD_VOICE_SIP_TRANSFER_TOOL.name, exports.CLOUD_VOICE_SIP_TRANSFER_TOOL);
+    }
+    const toolManifest = Array.from(toolManifestByName.values())
+        .sort((left, right) => {
+        if (left.name === exports.CLOUD_VOICE_PHONE_HANGUP_TOOL.name)
+            return 1;
+        if (right.name === exports.CLOUD_VOICE_PHONE_HANGUP_TOOL.name)
+            return -1;
+        return 0;
+    });
+    const phoneControlRule = (0, cloud_voice_prompt_service_1.buildPhoneControlRule)({ config: renderedConfig, channel });
+    const system = (0, cloud_voice_parameters_1.renderCloudVoiceParameterTemplate)((0, cloud_voice_prompt_service_1.compileCloudVoiceInstructions)({
+        config: promptConfig,
+        agentName: input.agentName,
+        channel,
+        toolCount: toolManifest.length,
+        phoneControlRule,
+        compiledFlowInstructions: shouldAppendCompiledFlow ? (_k = compiledFlow === null || compiledFlow === void 0 ? void 0 : compiledFlow.instructions) !== null && _k !== void 0 ? _k : "" : "",
+    }), parameters);
+    return {
+        name: input.agentName,
+        system,
+        runtime: Object.assign(Object.assign({ provider: renderedConfig.provider, mode: renderedConfig.provider === "kognitive-voice" ? "pipeline" : "realtime", transport: (_l = pipeline === null || pipeline === void 0 ? void 0 : pipeline.transport.type) !== null && _l !== void 0 ? _l : renderedConfig.transport, model: (_m = pipeline === null || pipeline === void 0 ? void 0 : pipeline.llm.model) !== null && _m !== void 0 ? _m : renderedConfig.model, voice: (_o = pipeline === null || pipeline === void 0 ? void 0 : pipeline.tts.voice) !== null && _o !== void 0 ? _o : renderedConfig.voice, providerOptions: renderedConfig.providerOptions }, (pipeline ? { pipeline } : {})), { capabilities }),
+        voiceConfig: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ system, model: (_p = pipeline === null || pipeline === void 0 ? void 0 : pipeline.llm.model) !== null && _p !== void 0 ? _p : renderedConfig.model, voice: (_q = pipeline === null || pipeline === void 0 ? void 0 : pipeline.tts.voice) !== null && _q !== void 0 ? _q : renderedConfig.voice }, (speech ? { speech } : {})), (languageCode ? { languageCode } : {})), { turnDetection, transcription: (0, cloud_voice_runtime_service_1.toPreparedTranscription)(renderedConfig), inputNoiseReduction: (0, cloud_voice_runtime_service_1.normalizeCloudVoiceInputNoiseReduction)(renderedConfig.provider, channel, renderedConfig.inputNoiseReduction), maxOutputTokens }), (temperature !== undefined ? { temperature } : {})), (cartesiaTtsOptions ? { tts: { provider: "cartesia", options: cartesiaTtsOptions } } : {})),
+        tools: [],
+        toolManifest,
+        resourceId: input.resourceId,
+        parameters,
+        metadata: Object.assign({ cloudVoice: true, sessionId: input.sessionId, cloudVoiceConfigVersion: cloud_voice_runtime_service_1.CLOUD_VOICE_CONFIG_VERSION, promptCompilerVersion: cloud_voice_runtime_service_1.CLOUD_VOICE_PROMPT_COMPILER_VERSION, clientTools: ((_r = input.clientTools) !== null && _r !== void 0 ? _r : []).map((tool) => tool.id), transferDestinations: getTransferDestinations(renderedConfig).map((destination) => destination.id), parameterKeys: Object.keys(parameters), missingRequiredParameters: (_t = (_s = input.parameterResolution) === null || _s === void 0 ? void 0 : _s.missingRequired) !== null && _t !== void 0 ? _t : [], sensitiveParameterKeys: (_v = (_u = input.parameterResolution) === null || _u === void 0 ? void 0 : _u.sensitiveKeys) !== null && _v !== void 0 ? _v : [] }, (compiledFlow
+            ? {
+                flowGraph: {
+                    startNodeId: compiledFlow.startNodeId,
+                    entryMode: compiledFlow.entryMode,
+                    nodeCount: compiledFlow.nodeCount,
+                    edgeCount: compiledFlow.edgeCount,
+                    referencedToolIds: compiledFlow.referencedToolIds,
+                    missingToolIds: compiledFlow.missingToolIds,
+                },
+            }
+            : {})),
+    };
+}
+function createPhonePrepareSnapshot(input) {
+    var _a, _b;
+    return {
+        schemaVersion: 1,
+        createdAt: ((_a = input.now) !== null && _a !== void 0 ? _a : new Date()).toISOString(),
+        channel: input.channel,
+        agent: {
+            id: input.agent.id,
+            slug: input.agent.slug,
+            name: input.agent.name,
+            version: (_b = input.agent.publishedVersion) !== null && _b !== void 0 ? _b : input.agent.draftVersion,
+        },
+        runtime: input.prepare.runtime,
+        voiceConfig: input.prepare.voiceConfig,
+        toolManifest: input.prepare.toolManifest,
+        config: input.config,
+        parameters: input.prepare.parameters,
+    };
+}