@kognitivedev/backend-cloud 0.2.29

package/dist/tools.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteCloudVoiceToolBindingInput, ExecuteCloudVoiceToolBindingResult } from "./types";
+export declare function executeCloudVoiceToolBinding(input: ExecuteCloudVoiceToolBindingInput): Promise<ExecuteCloudVoiceToolBindingResult>;

package/dist/tools.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCloudVoiceToolBinding = executeCloudVoiceToolBinding;
+const cloud_voice_parameters_1 = require("./cloud-voice-parameters");
+const utils_1 = require("./utils");
+function requiredHandler(handler, toolType) {
+    if (!handler)
+        throw new Error(`Cloud Voice tool type "${toolType}" is not configured`);
+    return handler;
+}
+function applyParameterBindings(input) {
+    const args = Object.assign({}, (0, utils_1.getRecord)(input.args));
+    const bindings = (0, utils_1.getRecord)(input.tool.parameterBindings);
+    const parameters = (0, utils_1.getRecord)(input.parameters);
+    for (const [field, rawBinding] of Object.entries(bindings)) {
+        const binding = (0, utils_1.getRecord)(rawBinding);
+        const parameterKey = (0, utils_1.getString)(binding.parameter, "");
+        if (!field || !parameterKey || !Object.prototype.hasOwnProperty.call(parameters, parameterKey))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(args, field) && args[field] !== undefined && args[field] !== null && args[field] !== "")
+            continue;
+        args[field] = parameters[parameterKey];
+    }
+    return args;
+}
+function omitReservedToolArgs(args) {
+    const next = Object.assign({}, args);
+    delete next.to;
+    delete next.fromNumberId;
+    delete next.timeoutMs;
+    delete next.intervalMs;
+    return next;
+}
+function readMappedValue(value, context) {
+    var _a, _b;
+    if (typeof value === "string")
+        return (0, cloud_voice_parameters_1.renderCloudVoiceParameterTemplate)(value, context);
+    const record = (0, utils_1.getRecord)(value);
+    const mode = (0, utils_1.getString)(record.mode, "");
+    if (mode === "literal")
+        return record.value;
+    if (mode === "tool_input")
+        return context[(0, utils_1.getString)((_a = record.value) !== null && _a !== void 0 ? _a : record.key, "")];
+    if (mode === "parent_parameter")
+        return context[(0, utils_1.getString)((_b = record.value) !== null && _b !== void 0 ? _b : record.parameter, "")];
+    if (Object.keys(record).length > 0 && "value" in record)
+        return record.value;
+    return undefined;
+}
+function resolveCloudVoiceAgentParameters(input, args) {
+    var _a;
+    const config = (0, utils_1.getRecord)(input.tool.config);
+    const context = Object.assign(Object.assign({}, ((_a = input.parameters) !== null && _a !== void 0 ? _a : {})), args);
+    const parameters = omitReservedToolArgs(args);
+    const mappings = (0, utils_1.getRecord)(config.parameterMappings);
+    for (const [key, mapping] of Object.entries(mappings)) {
+        const mapped = readMappedValue(mapping, context);
+        if (mapped !== undefined && mapped !== null && mapped !== "") {
+            parameters[key] = mapped;
+        }
+    }
+    return parameters;
+}
+function resolveTransferDestination(value) {
+    const record = (0, utils_1.getRecord)(value);
+    if (record.type === "phone_number" && typeof record.phoneNumber === "string" && record.phoneNumber.trim()) {
+        return {
+            type: "phone_number",
+            phoneNumber: record.phoneNumber.trim(),
+            connectionId: (0, utils_1.getString)(record.connectionId, "") || undefined,
+            callerId: (0, utils_1.getString)(record.callerId, "") || undefined,
+            metadata: (0, utils_1.getRecord)(record.metadata),
+        };
+    }
+    if (record.type === "sip_uri" && typeof record.uri === "string" && record.uri.trim()) {
+        return {
+            type: "sip_uri",
+            uri: record.uri.trim(),
+            connectionId: (0, utils_1.getString)(record.connectionId, "") || undefined,
+            transport: record.transport === "udp" || record.transport === "tcp" || record.transport === "tls" ? record.transport : undefined,
+            metadata: (0, utils_1.getRecord)(record.metadata),
+        };
+    }
+    if (record.type === "extension" && typeof record.extension === "string" && record.extension.trim()) {
+        const connectionId = (0, utils_1.getString)(record.connectionId, "");
+        if (!connectionId)
+            throw new Error("SIP extension transfer destination is missing connectionId");
+        return {
+            type: "extension",
+            extension: record.extension.trim(),
+            connectionId,
+            metadata: (0, utils_1.getRecord)(record.metadata),
+        };
+    }
+    if (record.type === "queue" && typeof record.queueId === "string" && record.queueId.trim()) {
+        return {
+            type: "queue",
+            queueId: record.queueId.trim(),
+            metadata: (0, utils_1.getRecord)(record.metadata),
+        };
+    }
+    throw new Error("SIP transfer destination is invalid");
+}
+async function executeCloudVoiceToolBinding(input) {
+    var _a, _b, _c, _d;
+    const { tool } = input;
+    const args = applyParameterBindings(input);
+    if (tool.type === "web_search") {
+        const query = (0, utils_1.getString)(args.query, (0, utils_1.getString)(tool.config.query, ""));
+        const result = await requiredHandler(input.executeWebSearch, tool.type)({
+            query,
+            parameters: (0, utils_1.getRecord)(tool.config.parameters),
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "cloud_flow") {
+        const flowSlug = (0, utils_1.getString)(tool.config.flowSlug, "");
+        const result = await requiredHandler(input.executeCloudFlow, tool.type)({
+            flowSlug,
+            args,
+            resourceId: input.resourceId,
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "knowledge_base") {
+        const result = await requiredHandler(input.executeKnowledgeBase, tool.type)({
+            pipelineId: (0, utils_1.getString)(tool.config.pipelineId, ""),
+            query: (0, utils_1.getString)(args.query, ""),
+            topK: (0, utils_1.getNumber)(tool.config.topK, 5),
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "platform_action") {
+        const result = await requiredHandler(input.executePlatformAction, tool.type)({
+            actionSlug: (0, utils_1.getString)(tool.config.actionSlug, ""),
+            connectionId: (0, utils_1.getString)(tool.config.connectionId, ""),
+            args,
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "calendar_action") {
+        const result = await requiredHandler(input.executeCalendarAction, tool.type)({
+            action: (0, utils_1.getString)(tool.config.action, (0, utils_1.getString)(tool.config.actionSlug, tool.id)),
+            args,
+            config: (0, utils_1.getRecord)(tool.config),
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "appointment_action") {
+        const result = await requiredHandler(input.executeAppointmentAction, tool.type)({
+            action: (0, utils_1.getString)(tool.config.action, (0, utils_1.getString)(tool.config.actionSlug, tool.id)),
+            args,
+            config: (0, utils_1.getRecord)(tool.config),
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "cloud_voice_agent") {
+        const config = (0, utils_1.getRecord)(tool.config);
+        const context = Object.assign(Object.assign({}, ((_a = input.parameters) !== null && _a !== void 0 ? _a : {})), args);
+        const toTemplate = (0, utils_1.getString)(config.toTemplate, (0, utils_1.getString)(config.to, ""));
+        const to = (0, utils_1.getString)(args.to, toTemplate ? (0, cloud_voice_parameters_1.renderCloudVoiceParameterTemplate)(toTemplate, context) : "");
+        const fromNumberId = (0, utils_1.getString)(args.fromNumberId, (0, utils_1.getString)(config.fromNumberId, ""));
+        const timeoutMs = (0, utils_1.getNumber)(args.timeoutMs, (0, utils_1.getNumber)(config.timeoutMs, 600000));
+        const intervalMs = (0, utils_1.getNumber)(args.intervalMs, (0, utils_1.getNumber)(config.intervalMs, 2000));
+        const result = await requiredHandler(input.executeCloudVoiceAgent, tool.type)({
+            agentSlug: (0, utils_1.getString)(config.agentSlug, ""),
+            fromNumberId,
+            to,
+            parameters: resolveCloudVoiceAgentParameters(input, args),
+            timeoutMs,
+            intervalMs,
+            metadata: (0, utils_1.getRecord)(config.metadata),
+            tool,
+            args,
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "external_webhook") {
+        const result = await requiredHandler(input.executeExternalWebhook, tool.type)({
+            tool,
+            args,
+        });
+        return { result, metadata: {} };
+    }
+    if (tool.type === "sip_transfer") {
+        const config = (0, utils_1.getRecord)(tool.config);
+        const providerCallId = (0, utils_1.getString)(args.providerCallId, (0, utils_1.getString)(config.providerCallId, ""));
+        if (!providerCallId)
+            throw new Error(`SIP transfer tool "${tool.id}" is missing providerCallId`);
+        const mode = args.mode === "attended" || args.mode === "warm" || args.mode === "blind"
+            ? args.mode
+            : config.mode === "attended" || config.mode === "warm" || config.mode === "blind"
+                ? config.mode
+                : undefined;
+        const result = await requiredHandler(input.executeSipTransfer, tool.type)({
+            providerCallId,
+            destination: resolveTransferDestination((_b = args.destination) !== null && _b !== void 0 ? _b : config.destination),
+            mode,
+            reason: (0, utils_1.getString)(args.reason, (0, utils_1.getString)(config.reason, "agent_requested_transfer")),
+            policy: (0, utils_1.getRecord)((_c = args.policy) !== null && _c !== void 0 ? _c : config.policy),
+            metadata: Object.assign({ projectId: input.projectId, sessionId: input.sessionId, toolId: tool.id }, ((_d = input.resourceId) !== null && _d !== void 0 ? _d : {})),
+        });
+        return {
+            result,
+            metadata: {
+                transfer: {
+                    providerCallId: result.providerCallId,
+                    transferId: result.transferId,
+                    mode: result.mode,
+                    status: result.status,
+                },
+            },
+        };
+    }
+    throw new Error(`Unsupported Cloud Voice tool type "${String(tool.type)}"`);
+}

package/dist/types.d.ts

@@ -0,0 +1,468 @@
+import type { TelephonyDestination, TelephonyProvider, TelephonyTransferCallResult, TelephonyTransferMode, TelephonyTransferPolicy } from "@kognitivedev/telephony";
+export type CloudVoiceChannel = "web" | "iframe" | "script" | "phone" | "sip" | "outbound";
+export type CloudVoiceProvider = "openai-realtime" | "gemini-live" | "kognitive-voice" | "xai-realtime";
+export type CloudVoiceTransport = "webrtc" | "websocket";
+export type CloudVoicePipelineTransportProvider = "kognitive-websocket" | "daily";
+export type CloudVoiceToolType = "cloud_flow" | "web_search" | "knowledge_base" | "platform_action" | "calendar_action" | "appointment_action" | "cloud_voice_agent" | "external_webhook" | "sip_transfer" | "code_defined_tool";
+export interface CloudVoiceToolBinding {
+    id: string;
+    type: CloudVoiceToolType;
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    parameterBindings?: Record<string, {
+        parameter: string;
+    }>;
+    ui?: {
+        type?: "card" | "status" | "table" | "timeline" | "custom";
+        title?: string;
+        description?: string;
+        renderer?: string;
+        config?: Record<string, unknown>;
+    };
+    config: Record<string, unknown>;
+}
+export type CloudVoiceTelephonyProvider = Exclude<TelephonyProvider, "twilio"> | string;
+export type CloudVoiceTelephonyDestination = TelephonyDestination;
+export type CloudVoiceTransferMode = TelephonyTransferMode;
+export type CloudVoiceTransferPolicy = TelephonyTransferPolicy & {
+    fallbackDestinationId?: string;
+};
+export interface CloudVoiceTransferDestination {
+    id: string;
+    name: string;
+    provider?: CloudVoiceTelephonyProvider;
+    destination: CloudVoiceTelephonyDestination;
+    policy?: CloudVoiceTransferPolicy;
+    metadata?: Record<string, unknown>;
+}
+export interface CloudVoiceSipConfig {
+    enabled?: boolean;
+    defaultConnectionId?: string;
+    defaultProvider?: CloudVoiceTelephonyProvider;
+    inboundRouting?: {
+        mode: "agent" | "flow" | "queue";
+        agentId?: string;
+        flowId?: string;
+        queueId?: string;
+    };
+    transferPolicy?: CloudVoiceTransferPolicy;
+}
+export type CloudVoiceFlowNodeType = "initial" | "case" | "tool" | "transfer" | "end" | string;
+export interface CloudVoiceFlowNodeOutput {
+    id: string;
+    label: string;
+    description?: string;
+    desc?: string;
+    condition?: string;
+    icon?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CloudVoiceSpeechConfig extends Record<string, unknown> {
+    language?: string;
+    accent?: string;
+    style?: string;
+    pace?: string;
+    emotion?: string;
+}
+export interface CloudVoiceNodeVoiceSettings extends Record<string, unknown> {
+    speed?: number;
+    pitch?: number;
+    backgroundNoise?: boolean;
+    fillerWords?: boolean;
+}
+export interface CloudVoiceNodeModelSettings extends Record<string, unknown> {
+    temperature?: number;
+    maxOutputTokens?: number;
+    sentimentGuardrails?: boolean;
+    recordTranscript?: boolean;
+}
+export interface CloudVoiceFlowNode {
+    id: string;
+    type: CloudVoiceFlowNodeType;
+    entryMode?: "incoming" | "outgoing" | "both" | "default" | string;
+    title?: string;
+    prompt?: string;
+    firstMessage?: string;
+    language?: string;
+    maxDuration?: string | number;
+    provider?: CloudVoiceProvider;
+    model?: string;
+    voice?: string;
+    transport?: CloudVoiceTransport;
+    providerOptions?: Record<string, unknown>;
+    transcription?: Record<string, unknown> | null;
+    turnDetection?: Record<string, unknown> | null;
+    inputNoiseReduction?: Record<string, unknown> | null;
+    humanization?: CloudVoiceHumanizationConfig;
+    speech?: CloudVoiceSpeechConfig;
+    phoneNumberIds?: string[];
+    voiceSettings?: CloudVoiceNodeVoiceSettings;
+    modelSettings?: CloudVoiceNodeModelSettings;
+    outputs?: CloudVoiceFlowNodeOutput[];
+    toolId?: string;
+    toolIds?: string[];
+    transferTarget?: string;
+    transferDestinationId?: string;
+    transferMode?: CloudVoiceTransferMode;
+    metadata?: Record<string, unknown>;
+}
+export interface CloudVoiceFlowEdge {
+    id?: string;
+    from: string;
+    fromPort?: string | null;
+    to: string;
+}
+export interface CloudVoiceFlowGraph {
+    version?: 1;
+    startNodeId?: string;
+    nodes: CloudVoiceFlowNode[];
+    edges: CloudVoiceFlowEdge[];
+    metadata?: Record<string, unknown>;
+}
+export interface CloudVoiceAgentMetadata extends Record<string, unknown> {
+    flowGraph?: CloudVoiceFlowGraph;
+    speech?: CloudVoiceSpeechConfig;
+    sip?: CloudVoiceSipConfig;
+    transferDestinations?: CloudVoiceTransferDestination[];
+}
+export interface CloudVoiceClientToolManifest {
+    id: string;
+    name?: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+export interface CloudVoiceHumanizationConfig {
+    enabled?: boolean;
+    openingMode?: "auto" | "wait";
+    openingStyle?: "brief" | "warm" | "professional";
+    fillerStyle?: "off" | "light" | "natural";
+    backchannelFrequency?: "off" | "low" | "medium";
+    disfluency?: "off" | "rare";
+    toolLatencyFillerMs?: number;
+    conversationProfile?: CloudVoiceConversationProfile;
+}
+export interface CloudVoiceConversationProfile {
+    personality: "neutral" | "warm" | "expert" | "concierge";
+    tone: "casual" | "professional" | "empathetic" | "polished";
+    pacing: "concise" | "measured" | "deliberate" | "energetic";
+    unclearAudio: "ask_repeat" | "confirm_best_guess";
+    confirmation: "critical_fields" | "all_actions" | "minimal";
+    escalation: "when_blocked" | "on_request" | "never";
+    numberReadback: boolean;
+}
+export interface CloudVoiceRuntimeCapabilities {
+    canUpdateInstructionsLive: boolean;
+    supportsSessionResume: boolean;
+    supportsToolCalling: boolean;
+    supportsOutputAudioTranscripts: boolean;
+    supportsServerVadConfig: boolean;
+    supportsSemanticVad?: boolean;
+    supportsNativeAudioOptions?: boolean;
+    supportsAffectiveDialog?: boolean;
+    supportsProactiveAudio?: boolean;
+    supportsPipelineEotConfig?: boolean;
+    supportsCartesiaTtsControls?: boolean;
+}
+export interface CloudVoiceCartesiaTtsOptions extends Record<string, unknown> {
+    modelId?: string;
+    voice?: string;
+    speed?: number | "slow" | "normal" | "fast";
+    emotion?: string[];
+    pronunciationDictId?: string;
+    contextMode?: "continue" | "reset";
+}
+export interface CloudVoicePipelineTransportConfig {
+    type: CloudVoiceTransport;
+    provider?: CloudVoicePipelineTransportProvider;
+}
+export interface CloudVoicePipelineSTTConfig {
+    provider: string;
+    model: string;
+    language?: string;
+}
+export interface CloudVoicePipelineLLMConfig {
+    provider: string;
+    model: string;
+}
+export interface CloudVoicePipelineTTSConfig {
+    provider: string;
+    model: string;
+    voice?: string;
+    options?: CloudVoiceCartesiaTtsOptions;
+}
+export interface CloudVoicePipelineTurnConfig extends Record<string, unknown> {
+    interruptResponse?: boolean;
+    createResponse?: boolean;
+    prefixPaddingMs?: number;
+    silenceDurationMs?: number;
+    threshold?: number;
+}
+export interface CloudVoicePipelineConfig {
+    transport: CloudVoicePipelineTransportConfig;
+    stt: CloudVoicePipelineSTTConfig;
+    llm: CloudVoicePipelineLLMConfig;
+    tts: CloudVoicePipelineTTSConfig;
+    turn?: CloudVoicePipelineTurnConfig;
+    backgroundAudio?: {
+        preset?: string;
+    };
+}
+export type CloudVoiceParameterType = "string" | "number" | "boolean" | "json" | "phone" | "email";
+export type CloudVoiceParameterSource = "system" | "session" | "call" | "custom";
+export type CloudVoiceParameterPreset = "user_id" | "session_id" | "agent_slug" | "channel" | "phone" | "caller_phone" | "from_phone" | "to_phone" | "provider" | "provider_call_id" | "call_direction" | "phone_number_id" | "embed_origin";
+export type CloudVoiceParameterResolutionMode = "strict" | "permissive";
+export type CloudVoiceParameterValueMap = Record<string, unknown>;
+export interface CloudVoiceParameterDefinition {
+    key: string;
+    label: string;
+    type: CloudVoiceParameterType;
+    required?: boolean;
+    description?: string;
+    defaultValue?: unknown;
+    enum?: unknown[];
+    source?: CloudVoiceParameterSource;
+    preset?: CloudVoiceParameterPreset;
+    sensitive?: boolean;
+    jsonSchema?: Record<string, unknown>;
+}
+export interface CloudVoiceParameterResolutionResult {
+    definitions: CloudVoiceParameterDefinition[];
+    values: CloudVoiceParameterValueMap;
+    missingRequired: string[];
+    errors: string[];
+    sensitiveKeys: string[];
+}
+export interface CloudVoiceAgentConfig {
+    instructions: string;
+    provider: CloudVoiceProvider;
+    model: string;
+    voice: string;
+    transport: CloudVoiceTransport;
+    pipeline?: CloudVoicePipelineConfig;
+    memoryEnabled?: boolean;
+    providerOptions?: Record<string, unknown>;
+    transcription?: Record<string, unknown> | null;
+    turnDetection?: Record<string, unknown> | null;
+    inputNoiseReduction?: Record<string, unknown> | null;
+    tools: CloudVoiceToolBinding[];
+    knowledgeBases: Array<{
+        pipelineId: string;
+        name?: string;
+        topK?: number;
+    }>;
+    webSearch?: {
+        enabled?: boolean;
+        maxResults?: number;
+        maxPages?: number;
+    };
+    widget: {
+        title: string;
+        subtitle?: string;
+        layout?: "expanded" | "compact";
+        accentColor?: string;
+        backgroundColor?: string;
+        surfaceColor?: string;
+        textColor?: string;
+        mutedColor?: string;
+        ctaLabel?: string;
+        launcher?: "button" | "inline";
+        position?: "bottom-right" | "bottom-left";
+    };
+    channels: {
+        web: boolean;
+        iframe: boolean;
+        script: boolean;
+        phone: boolean;
+        sip: boolean;
+        outbound: boolean;
+    };
+    humanization?: CloudVoiceHumanizationConfig;
+    cloudVoiceConfigVersion?: 2;
+    parameters?: CloudVoiceParameterDefinition[];
+    metadata?: CloudVoiceAgentMetadata;
+}
+export interface CloudVoiceFunctionToolManifest {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export interface CompiledCloudVoiceFlowInstructions {
+    instructions: string;
+    compilerVersion: string;
+    graphSignature: string;
+    startNodeId: string | null;
+    entryMode?: "incoming" | "outgoing" | "both";
+    nodeCount: number;
+    edgeCount: number;
+    referencedToolIds: string[];
+    missingToolIds: string[];
+    toolManifest: CloudVoiceFunctionToolManifest[];
+    warnings: string[];
+}
+export interface PreparedCloudVoiceConfig {
+    name: string;
+    system: string;
+    runtime: {
+        provider: CloudVoiceProvider;
+        mode: "pipeline" | "realtime";
+        transport: CloudVoiceTransport;
+        model: string;
+        voice: string;
+        providerOptions?: Record<string, unknown>;
+        pipeline?: CloudVoicePipelineConfig;
+        capabilities: CloudVoiceRuntimeCapabilities;
+    };
+    voiceConfig: {
+        system: string;
+        model: string;
+        voice: string;
+        speech?: CloudVoiceSpeechConfig;
+        languageCode?: string;
+        turnDetection?: Record<string, unknown> | null;
+        transcription?: Record<string, unknown> | null;
+        inputNoiseReduction?: Record<string, unknown> | null;
+        maxOutputTokens: number | "inf";
+        temperature?: number;
+        tts?: {
+            provider: "cartesia";
+            options: CloudVoiceCartesiaTtsOptions;
+        };
+    };
+    tools: [];
+    toolManifest: CloudVoiceFunctionToolManifest[];
+    resourceId: Record<string, unknown>;
+    parameters: CloudVoiceParameterValueMap;
+    metadata: {
+        cloudVoice: true;
+        sessionId: string;
+        cloudVoiceConfigVersion: 2;
+        promptCompilerVersion: string;
+        clientTools: string[];
+        transferDestinations: string[];
+        parameterKeys: string[];
+        missingRequiredParameters: string[];
+        sensitiveParameterKeys: string[];
+        flowGraph?: {
+            startNodeId: string | null;
+            entryMode?: "incoming" | "outgoing" | "both";
+            nodeCount: number;
+            edgeCount: number;
+            referencedToolIds: string[];
+            missingToolIds: string[];
+        };
+    };
+}
+export interface CloudVoiceAgentSnapshot {
+    id: string;
+    slug: string;
+    name: string;
+    draftVersion: number;
+    publishedVersion: number | null;
+}
+export interface CloudVoicePhonePrepareSnapshot {
+    schemaVersion: 1;
+    createdAt: string;
+    channel: CloudVoiceChannel;
+    agent: {
+        id: string;
+        slug: string;
+        name: string;
+        version: number;
+    };
+    runtime: PreparedCloudVoiceConfig["runtime"];
+    voiceConfig: PreparedCloudVoiceConfig["voiceConfig"];
+    toolManifest: CloudVoiceFunctionToolManifest[];
+    config: CloudVoiceAgentConfig;
+    parameters: CloudVoiceParameterValueMap;
+}
+export interface ExecuteCloudVoiceToolBindingInput {
+    projectId: string;
+    sessionId: string;
+    tool: CloudVoiceToolBinding;
+    args: unknown;
+    resourceId?: Record<string, unknown>;
+    parameters?: CloudVoiceParameterValueMap;
+    executeWebSearch?: (input: {
+        query: string;
+        parameters: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeCloudFlow?: (input: {
+        flowSlug: string;
+        args: unknown;
+        resourceId?: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeKnowledgeBase?: (input: {
+        pipelineId: string;
+        query: string;
+        topK: number;
+    }) => Promise<unknown>;
+    executePlatformAction?: (input: {
+        actionSlug: string;
+        connectionId: string;
+        args: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeCalendarAction?: (input: {
+        action: string;
+        args: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeAppointmentAction?: (input: {
+        action: string;
+        args: Record<string, unknown>;
+        config?: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeCloudVoiceAgent?: (input: {
+        agentSlug: string;
+        fromNumberId: string;
+        to: string;
+        parameters: Record<string, unknown>;
+        timeoutMs: number;
+        intervalMs: number;
+        metadata: Record<string, unknown>;
+        tool: CloudVoiceToolBinding;
+        args: Record<string, unknown>;
+    }) => Promise<unknown>;
+    executeExternalWebhook?: (input: {
+        tool: CloudVoiceToolBinding;
+        args: unknown;
+    }) => Promise<unknown>;
+    executeSipTransfer?: (input: {
+        providerCallId: string;
+        destination: CloudVoiceTelephonyDestination;
+        mode?: CloudVoiceTransferMode;
+        reason?: string;
+        policy?: CloudVoiceTransferPolicy;
+        metadata?: Record<string, unknown>;
+    }) => Promise<TelephonyTransferCallResult>;
+}
+export interface ExecuteCloudVoiceToolBindingResult {
+    result: unknown;
+    metadata: Record<string, unknown>;
+}
+export interface CloudVoicePhoneControlAdapter {
+    provider: string;
+    hangUpCall(input: {
+        providerCallId: string;
+        reason?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        provider: string;
+        providerCallId: string;
+        status: string;
+        raw?: unknown;
+    }>;
+}
+export interface CloudVoiceSipControlAdapter {
+    provider: string;
+    transferCall(input: {
+        providerCallId: string;
+        destination: CloudVoiceTelephonyDestination;
+        mode?: CloudVoiceTransferMode;
+        reason?: string;
+        policy?: CloudVoiceTransferPolicy;
+        metadata?: Record<string, unknown>;
+    }): Promise<TelephonyTransferCallResult>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getString(value: unknown, fallback?: string): string;
+export declare function getNumber(value: unknown, fallback: number): number;
+export declare function getRecord(value: unknown): Record<string, unknown>;