@kognitivedev/cloud-voice 0.2.29

package/dist/client.js

@@ -0,0 +1,535 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KognitiveCloudVoiceEmbedClient = exports.KognitiveCloudVoiceClient = void 0;
+const client_core_1 = require("@kognitivedev/client-core");
+const sse_1 = require("./sse");
+function isTransportLike(value) {
+    return Boolean(value && typeof value === "object" && "baseUrl" in value && "json" in value && "raw" in value);
+}
+function assertString(value, name) {
+    if (!value || !value.trim())
+        throw new Error(`${name} is required`);
+    return value.trim();
+}
+function isNotFoundError(error) {
+    return error instanceof client_core_1.KognitiveApiError && error.status === 404
+        || Boolean(error && typeof error === "object" && "status" in error && error.status === 404);
+}
+const TERMINAL_CALL_STATUSES = new Set(["completed", "cancelled", "canceled", "failed", "busy", "no-answer", "error"]);
+const TERMINAL_SESSION_STATUSES = new Set(["completed", "cancelled", "canceled", "error"]);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isTerminalCall(call) {
+    return Boolean(call.endedAt)
+        || TERMINAL_CALL_STATUSES.has(call.status)
+        || Boolean(call.sessionStatus && TERMINAL_SESSION_STATUSES.has(call.sessionStatus));
+}
+function callStatusFingerprint(call) {
+    var _a, _b, _c;
+    return [
+        call.status,
+        (_a = call.sessionStatus) !== null && _a !== void 0 ? _a : "",
+        call.stateLabel,
+        (_b = call.latestEventType) !== null && _b !== void 0 ? _b : "",
+        (_c = call.outcomeStatus) !== null && _c !== void 0 ? _c : "",
+    ].join("|");
+}
+function toCallStatusChange(call, previousStatus) {
+    return {
+        call,
+        status: call.status,
+        previousStatus,
+        sessionStatus: call.sessionStatus,
+        stateLabel: call.stateLabel,
+        latestEventType: call.latestEventType,
+        outcomeStatus: call.outcomeStatus,
+    };
+}
+class KognitiveCloudVoiceClient {
+    constructor(config) {
+        this.agents = {
+            list: () => this.listAgents(),
+            get: (slug) => this.getAgent(slug),
+            use: (slug, input = {}) => this.useAgent(slug, input),
+            management: {
+                list: () => this.listAgents(),
+                create: (input) => this.createAgent(input),
+                createOrUse: (slug, input = {}) => this.useAgent(slug, input),
+                get: (slug) => this.getAgent(slug),
+                update: (slug, input) => this.updateAgent(slug, input),
+                delete: (slug) => this.deleteAgent(slug),
+                publish: (slug) => this.publishAgent(slug),
+                unpublish: (slug) => this.unpublishAgent(slug),
+                use: (slug, input = {}) => this.useAgent(slug, input),
+            },
+        };
+        this.sessions = {
+            list: (agentId) => this.listSessions(agentId),
+            create: (agentSlug, input = {}) => this.createSession(Object.assign(Object.assign({}, input), { agentSlug })),
+            get: (sessionId) => this.getSession(sessionId),
+            cancel: (sessionId, reason) => this.cancelSession(sessionId, reason),
+            events: (sessionId) => this.getSessionEvents(sessionId),
+            appendEvent: (sessionId, event) => this.appendSessionEvent(sessionId, event),
+            stream: (sessionId, init) => this.streamSessionEvents(sessionId, init),
+            subscribe: (sessionId, init) => this.subscribeToSession(sessionId, init),
+            executeTool: (sessionId, toolId, input) => this.executeTool(sessionId, toolId, input),
+            recordings: (sessionId) => this.getSessionRecordings(sessionId),
+        };
+        this.calls = {
+            list: () => this.listCalls(),
+            live: (input = {}) => this.listLiveCalls(input),
+            get: (sessionId) => this.getCall(sessionId),
+            create: (input) => this.createCall(input),
+            wait: (sessionId, options) => this.waitForCall(sessionId, options),
+            hangup: (sessionId, reason) => this.hangupCall(sessionId, reason),
+            listenToken: (sessionId, input = {}) => this.createCallListenToken(sessionId, input),
+            handoff: {
+                create: (sessionId, input = {}) => this.createCallHandoff(sessionId, input),
+                accept: (sessionId, handoffId, input = {}) => this.acceptCallHandoff(sessionId, handoffId, input),
+                cancel: (sessionId, handoffId, input = {}) => this.cancelCallHandoff(sessionId, handoffId, input),
+            },
+            events: (sessionId) => this.getSessionEvents(sessionId),
+            stream: (sessionId, init) => this.streamSessionEvents(sessionId, init),
+            subscribe: (sessionId, init) => this.subscribeToSession(sessionId, init),
+            executeTool: (sessionId, toolId, input) => this.executeCallTool(sessionId, toolId, input),
+        };
+        this.phone = {
+            connections: {
+                list: () => this.listPhoneConnections(),
+                create: (input) => this.createPhoneConnection(input),
+            },
+            numbers: {
+                list: () => this.listPhoneNumbers(),
+                create: (input) => this.createPhoneNumber(input),
+                update: (input) => this.updatePhoneNumber(input),
+            },
+            bridge: {
+                health: () => this.getPhoneBridgeHealth(),
+            },
+            sip: {
+                diagnostics: () => this.getSipDiagnostics(),
+                reload: () => this.reloadSipBridge(),
+            },
+        };
+        this.recordings = {
+            getForSession: (sessionId) => this.getSessionRecordings(sessionId),
+        };
+        this.tools = {
+            catalog: {
+                list: () => this.listToolCatalog(),
+                sync: (input) => this.syncToolCatalog(input),
+            },
+        };
+        this.customVoices = {
+            list: () => this.listCustomVoices(),
+            import: (input) => this.importCustomVoice(input),
+            clone: (input) => this.cloneCustomVoice(input),
+            update: (voiceId, input) => this.updateCustomVoice(voiceId, input),
+            delete: (voiceId) => this.deleteCustomVoice(voiceId),
+        };
+        this.transport = isTransportLike(config) ? config : new client_core_1.HttpTransport(config);
+    }
+    async listAgents() {
+        const res = await this.transport.json("/api/cloud/voice/agents");
+        return res.agents;
+    }
+    async getAgent(slug) {
+        return this.transport.json(`/api/cloud/voice/agents/${encodeURIComponent(assertString(slug, "slug"))}`);
+    }
+    async createAgent(input) {
+        return this.transport.json("/api/cloud/voice/agents", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async listCustomVoices() {
+        const res = await this.transport.json("/api/cloud/voice/custom-voices");
+        return res.voices;
+    }
+    async importCustomVoice(input) {
+        return this.transport.json("/api/cloud/voice/custom-voices/import", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async cloneCustomVoice(input) {
+        var _a;
+        const form = new FormData();
+        form.append("file", input.file, (_a = input.fileName) !== null && _a !== void 0 ? _a : "reference.wav");
+        const fields = {
+            name: input.name,
+            description: input.description,
+            gender: input.gender,
+            accent: input.accent,
+            age: input.age,
+            language: input.language,
+            use_case: input.useCase,
+            tone: input.tone,
+        };
+        for (const [key, value] of Object.entries(fields)) {
+            if (typeof value === "string" && value.trim())
+                form.append(key, value.trim());
+        }
+        form.append("consent", JSON.stringify(input.consent));
+        return this.transport.multipart("/api/cloud/voice/custom-voices/clone", form, {
+            method: "POST",
+        });
+    }
+    async updateCustomVoice(voiceId, input) {
+        return this.transport.json(`/api/cloud/voice/custom-voices/${encodeURIComponent(assertString(voiceId, "voiceId"))}`, {
+            method: "PATCH",
+            body: JSON.stringify(Object.assign(Object.assign({}, input), (input.useCase !== undefined ? { use_case: input.useCase } : {}))),
+        });
+    }
+    async deleteCustomVoice(voiceId) {
+        return this.transport.json(`/api/cloud/voice/custom-voices/${encodeURIComponent(assertString(voiceId, "voiceId"))}`, {
+            method: "DELETE",
+        });
+    }
+    async updateAgent(slug, input) {
+        return this.transport.json(`/api/cloud/voice/agents/${encodeURIComponent(assertString(slug, "slug"))}`, {
+            method: "PUT",
+            body: JSON.stringify(input),
+        });
+    }
+    async useAgent(slug, input = {}) {
+        var _a;
+        const normalizedSlug = assertString(slug, "slug");
+        let existing = null;
+        try {
+            existing = await this.getAgent(normalizedSlug);
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+        }
+        const hasUpdates = input.name !== undefined
+            || input.description !== undefined
+            || input.status !== undefined
+            || input.config !== undefined;
+        let action = existing ? "used" : "created";
+        let agent = existing;
+        if (existing && hasUpdates) {
+            agent = await this.updateAgent(normalizedSlug, Object.assign(Object.assign(Object.assign(Object.assign({}, (input.name !== undefined ? { name: input.name } : {})), (input.description !== undefined ? { description: input.description } : {})), (input.status !== undefined ? { status: input.status } : {})), (input.config !== undefined ? { config: input.config } : {})));
+            action = "updated";
+        }
+        else if (!existing) {
+            agent = await this.createAgent({
+                name: (_a = input.name) !== null && _a !== void 0 ? _a : normalizedSlug,
+                slug: normalizedSlug,
+                description: input.description,
+                config: input.config,
+            });
+        }
+        if (!agent) {
+            throw new Error(`Cloud voice agent "${normalizedSlug}" could not be created or resolved`);
+        }
+        if (input.publish) {
+            agent = await this.publishAgent(agent.slug);
+        }
+        return { action, agent };
+    }
+    async deleteAgent(slug) {
+        return this.transport.json(`/api/cloud/voice/agents/${encodeURIComponent(assertString(slug, "slug"))}`, {
+            method: "DELETE",
+        });
+    }
+    async publishAgent(slug) {
+        return this.transport.json(`/api/cloud/voice/agents/${encodeURIComponent(assertString(slug, "slug"))}/publish`, {
+            method: "POST",
+        });
+    }
+    async unpublishAgent(slug) {
+        return this.transport.json(`/api/cloud/voice/agents/${encodeURIComponent(assertString(slug, "slug"))}/unpublish`, {
+            method: "POST",
+        });
+    }
+    async listSessions(agentId) {
+        const path = agentId ? `/api/cloud/voice/sessions?agentId=${encodeURIComponent(agentId)}` : "/api/cloud/voice/sessions";
+        const res = await this.transport.json(path);
+        return res.sessions;
+    }
+    async createSession(input) {
+        return this.transport.json("/api/cloud/voice/sessions", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async getSession(sessionId) {
+        return this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}`);
+    }
+    async cancelSession(sessionId, reason) {
+        return this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/cancel`, {
+            method: "POST",
+            body: JSON.stringify({ reason }),
+        });
+    }
+    async getSessionEvents(sessionId) {
+        const res = await this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/events`);
+        return res.events;
+    }
+    async appendSessionEvent(sessionId, event) {
+        return this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/events`, {
+            method: "POST",
+            body: JSON.stringify(event),
+        });
+    }
+    async streamSessionEvents(sessionId, init) {
+        return this.transport.raw(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/events/stream`, init);
+    }
+    async subscribeToSession(sessionId, init) {
+        const response = await this.streamSessionEvents(sessionId, init);
+        if (!response.body)
+            throw new Error("Cloud voice event stream response did not include a body");
+        const events = (0, sse_1.readSSEStream)(response.body);
+        function decode() {
+            return __asyncGenerator(this, arguments, function* decode_1() {
+                var _a, e_1, _b, _c;
+                try {
+                    for (var _d = true, events_1 = __asyncValues(events), events_1_1; events_1_1 = yield __await(events_1.next()), _a = events_1_1.done, !_a; _d = true) {
+                        _c = events_1_1.value;
+                        _d = false;
+                        const frame = _c;
+                        try {
+                            yield yield __await(JSON.parse(frame.data));
+                        }
+                        catch (_e) {
+                            yield yield __await({ type: "unknown", frame });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = events_1.return)) yield __await(_b.call(events_1));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        }
+        return decode();
+    }
+    async executeTool(sessionId, toolId, input) {
+        return this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/tools/${encodeURIComponent(assertString(toolId, "toolId"))}/execute`, {
+            method: "POST",
+            body: JSON.stringify({ input }),
+        });
+    }
+    async getSessionRecordings(sessionId) {
+        return this.transport.json(`/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/recordings`);
+    }
+    async listPhoneConnections() {
+        const res = await this.transport.json("/api/cloud/voice/phone/connections");
+        return res.connections;
+    }
+    async createPhoneConnection(input) {
+        return this.transport.json("/api/cloud/voice/phone/connections", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async listPhoneNumbers() {
+        const res = await this.transport.json("/api/cloud/voice/phone/numbers");
+        return res.numbers;
+    }
+    async createPhoneNumber(input) {
+        return this.transport.json("/api/cloud/voice/phone/numbers", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async updatePhoneNumber(input) {
+        return this.transport.json("/api/cloud/voice/phone/numbers", {
+            method: "PATCH",
+            body: JSON.stringify(input),
+        });
+    }
+    async getPhoneBridgeHealth() {
+        const res = await this.transport.json("/api/cloud/voice/phone/bridge");
+        return res.bridge;
+    }
+    async getSipDiagnostics() {
+        const res = await this.transport.json("/api/cloud/voice/phone/sip");
+        return res.sip;
+    }
+    async reloadSipBridge() {
+        const res = await this.transport.json("/api/cloud/voice/phone/sip", {
+            method: "POST",
+            body: "{}",
+        });
+        return res.sip;
+    }
+    async listToolCatalog() {
+        return this.transport.json("/api/cloud/voice/tools/catalog");
+    }
+    async syncToolCatalog(input) {
+        return this.transport.json("/api/cloud/voice/tools/sync", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async listCalls() {
+        const res = await this.transport.json("/api/cloud/voice/calls");
+        return res.calls;
+    }
+    async listLiveCalls(input = {}) {
+        const params = new URLSearchParams();
+        if (input.status === "all")
+            params.set("status", "all");
+        if (input.limit !== undefined)
+            params.set("limit", String(input.limit));
+        const qs = params.toString();
+        const res = await this.transport.json(`/api/cloud/voice/calls/live${qs ? `?${qs}` : ""}`);
+        return res.calls;
+    }
+    async getCall(sessionId) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}`);
+    }
+    async createCall(input) {
+        return this.transport.json("/api/cloud/voice/calls", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async finalizeCall(sessionId) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/finalize`, {
+            method: "POST",
+            body: JSON.stringify({}),
+        });
+    }
+    async waitForCall(sessionId, options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        const normalizedSessionId = assertString(sessionId, "sessionId");
+        const intervalMs = Math.max(10, (_a = options.intervalMs) !== null && _a !== void 0 ? _a : 1000);
+        const timeoutMs = Math.max(intervalMs, (_b = options.timeoutMs) !== null && _b !== void 0 ? _b : 30 * 60000);
+        const deadline = Date.now() + timeoutMs;
+        let lastFingerprint = null;
+        let previousStatus;
+        while (true) {
+            const call = await this.getCall(normalizedSessionId);
+            const fingerprint = callStatusFingerprint(call);
+            if (fingerprint !== lastFingerprint) {
+                const event = toCallStatusChange(call, previousStatus);
+                (_c = options.onStatusChange) === null || _c === void 0 ? void 0 : _c.call(options, event);
+                (_d = options.onEvent) === null || _d === void 0 ? void 0 : _d.call(options, event);
+                lastFingerprint = fingerprint;
+                previousStatus = call.status;
+            }
+            if (isTerminalCall(call)) {
+                const result = await this.finalizeCall(normalizedSessionId);
+                const finalFingerprint = callStatusFingerprint(result.call);
+                if (finalFingerprint !== lastFingerprint) {
+                    const event = toCallStatusChange(result.call, previousStatus);
+                    (_e = options.onStatusChange) === null || _e === void 0 ? void 0 : _e.call(options, event);
+                    (_f = options.onEvent) === null || _f === void 0 ? void 0 : _f.call(options, event);
+                }
+                return result;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Cloud voice call ${normalizedSessionId} did not complete within ${timeoutMs}ms`);
+            }
+            await sleep(intervalMs);
+        }
+    }
+    async executeCallTool(sessionId, toolId, input) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/tools/${encodeURIComponent(assertString(toolId, "toolId"))}`, {
+            method: "POST",
+            body: JSON.stringify({ input }),
+        });
+    }
+    async hangupCall(sessionId, reason) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/hangup`, {
+            method: "POST",
+            body: JSON.stringify({ reason }),
+        });
+    }
+    async createCallListenToken(sessionId, input = {}) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/listen-token`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async createCallHandoff(sessionId, input = {}) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/handoff`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async acceptCallHandoff(sessionId, handoffId, input = {}) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/handoff/${encodeURIComponent(assertString(handoffId, "handoffId"))}/accept`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async cancelCallHandoff(sessionId, handoffId, input = {}) {
+        return this.transport.json(`/api/cloud/voice/calls/${encodeURIComponent(assertString(sessionId, "sessionId"))}/handoff/${encodeURIComponent(assertString(handoffId, "handoffId"))}/cancel`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+}
+exports.KognitiveCloudVoiceClient = KognitiveCloudVoiceClient;
+class KognitiveCloudVoiceEmbedClient {
+    constructor(config) {
+        var _a;
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.publicKey = assertString(config.publicKey, "publicKey");
+        this.fetchImpl = (_a = config.fetch) !== null && _a !== void 0 ? _a : globalThis.fetch.bind(globalThis);
+    }
+    headers(extra) {
+        const headers = new Headers(extra);
+        headers.set("x-kognitive-public-key", this.publicKey);
+        headers.set("Content-Type", "application/json");
+        return headers;
+    }
+    async config(agent) {
+        const res = await this.fetchImpl(`${this.baseUrl}/api/cloud/voice/embed/config?agent=${encodeURIComponent(agent)}`, {
+            headers: this.headers(),
+        });
+        if (!res.ok)
+            throw new Error(await res.text());
+        return res.json();
+    }
+    async createSession(input) {
+        const res = await this.fetchImpl(`${this.baseUrl}/api/cloud/voice/embed/sessions`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify(input),
+        });
+        if (!res.ok)
+            throw new Error(await res.text());
+        return res.json();
+    }
+    async executeTool(sessionId, toolId, input) {
+        const res = await this.fetchImpl(`${this.baseUrl}/api/cloud/voice/sessions/${encodeURIComponent(assertString(sessionId, "sessionId"))}/tools/${encodeURIComponent(assertString(toolId, "toolId"))}/execute`, {
+            method: "POST",
+            headers: this.headers(),
+            body: JSON.stringify({ input }),
+        });
+        if (!res.ok)
+            throw new Error(await res.text());
+        return res.json();
+    }
+}
+exports.KognitiveCloudVoiceEmbedClient = KognitiveCloudVoiceEmbedClient;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { KognitiveCloudVoiceClient, KognitiveCloudVoiceEmbedClient } from "./client";
+export { createCloudVoiceTools, syncCloudVoiceCodeDefinedTools } from "./server";
+export { createVoiceSession, createVoiceWidget, mountIframe } from "./browser";
+export { readSSEStream } from "./sse";
+export type { ParsedSSEEvent } from "./sse";
+export type { CloudVoiceAgentConfig, CloudVoiceAgentConfigInput, CloudVoiceAgentMetadata, CloudVoiceAgentRecord, CloudVoiceAgentStatus, CloudVoiceChannel, CloudVoiceChannelSettings, CloudVoiceClientTool, CloudVoiceClientConfig, CloudVoiceClientToolDefinition, CloudVoiceClientToolExecuteContext, CloudVoiceClientToolManifest, CloudVoiceClientToolRenderContext, CloudVoiceClientToolRenderer, CloudVoiceClientTools, CloudVoiceClientToolState, CloudVoiceCustomVoiceConsent, CloudVoiceCustomVoiceRecord, CloudVoiceCustomVoiceSource, CloudVoiceCustomVoiceVerificationStatus, CloudVoiceHumanizationConfig, CloudVoiceSipConfig, CloudVoiceTelephonyDestination, CloudVoiceTelephonyProvider, CloudVoiceTransferDestination, CloudVoiceTransferMode, CloudVoiceTransferPolicy, CloudVoiceFlowEdge, CloudVoiceFlowGraph, CloudVoiceFlowNode, CloudVoiceFlowNodeOutput, CloudVoiceFlowNodeType, CloudVoiceNodeModelSettings, CloudVoiceNodeVoiceSettings, CloudVoiceParameterDefinition, CloudVoiceParameterPreset, CloudVoiceParameterSource, CloudVoiceParameterType, CloudVoiceParameterValueMap, CloudVoiceSpeechConfig, CloudVoiceEmbedConfig, CloudVoiceEmbedOptions, CloudVoiceCallLegRecord, CloudVoiceCallOutcome, CloudVoiceCallOutcomeSource, CloudVoiceCallStatusChange, CloudVoiceCallWaitOptions, CloudVoiceCallWaitResult, CloudVoiceHandoffAction, CloudVoiceHandoffMode, CloudVoiceHandoffRecord, CloudVoiceHandoffStatus, CloudVoiceCallJudgeResult, CloudVoiceListenTokenResult, CloudVoiceLiveCallRecord, CloudVoiceLiveCallHandoffState, CloudVoiceLiveCallTranscriptMessage, CloudVoicePhoneBridgeHealth, CloudVoicePhoneConnectionRecord, CloudVoicePhoneNumberRecord, CloudVoiceSipDiagnostics, CloudVoiceRecordingAsset, CloudVoiceRecordingAssetKind, CloudVoiceSessionBootstrap, CloudVoiceSessionEventRecord, CloudVoiceSessionRecord, CloudVoiceSessionStatus, CloudVoiceProvider, CloudVoiceToolType, CloudVoiceTransport, CloudVoiceToolBinding, CloudVoiceToolCatalog, CloudVoiceToolCatalogEntry, CloudVoiceToolCatalogSource, CloudVoiceWidgetConfig, CreateCloudVoiceAgentInput, CloneCloudVoiceCustomVoiceInput, ImportCloudVoiceCustomVoiceInput, AcceptCloudVoiceHandoffInput, CancelCloudVoiceHandoffInput, CreateCloudVoiceHandoffInput, CreateCloudVoiceOutboundCallInput, CreateCloudVoicePhoneConnectionInput, CreateCloudVoicePhoneNumberInput, CreateCloudVoiceSessionInput, LogLevel, UpdateCloudVoiceAgentInput, UpdateCloudVoiceCustomVoiceInput, UpdateCloudVoicePhoneNumberInput, SyncCloudVoiceToolCatalogInput, UseCloudVoiceAgentInput, UseCloudVoiceAgentResult, UseCloudVoiceAgentAction, } from "./types";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSSEStream = exports.mountIframe = exports.createVoiceWidget = exports.createVoiceSession = exports.syncCloudVoiceCodeDefinedTools = exports.createCloudVoiceTools = exports.KognitiveCloudVoiceEmbedClient = exports.KognitiveCloudVoiceClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "KognitiveCloudVoiceClient", { enumerable: true, get: function () { return client_1.KognitiveCloudVoiceClient; } });
+Object.defineProperty(exports, "KognitiveCloudVoiceEmbedClient", { enumerable: true, get: function () { return client_1.KognitiveCloudVoiceEmbedClient; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "createCloudVoiceTools", { enumerable: true, get: function () { return server_1.createCloudVoiceTools; } });
+Object.defineProperty(exports, "syncCloudVoiceCodeDefinedTools", { enumerable: true, get: function () { return server_1.syncCloudVoiceCodeDefinedTools; } });
+var browser_1 = require("./browser");
+Object.defineProperty(exports, "createVoiceSession", { enumerable: true, get: function () { return browser_1.createVoiceSession; } });
+Object.defineProperty(exports, "createVoiceWidget", { enumerable: true, get: function () { return browser_1.createVoiceWidget; } });
+Object.defineProperty(exports, "mountIframe", { enumerable: true, get: function () { return browser_1.mountIframe; } });
+var sse_1 = require("./sse");
+Object.defineProperty(exports, "readSSEStream", { enumerable: true, get: function () { return sse_1.readSSEStream; } });

package/dist/server.d.ts

@@ -0,0 +1,58 @@
+import { KognitiveCloudVoiceClient } from "./client";
+import type { CloudVoiceToolCatalog } from "./types";
+export interface CloudVoiceToolRequest<TInput = unknown> {
+    type: "cloud_voice.tool.execute";
+    toolCallId: string;
+    toolId: string;
+    toolName?: string;
+    input: TInput;
+    session: {
+        id: string;
+        sessionId: string;
+        agentSlug: string;
+        channel: string;
+        userId: string;
+        resourceId: Record<string, unknown>;
+        parameters: Record<string, unknown>;
+        metadata: Record<string, unknown>;
+    };
+}
+export interface CloudVoiceToolContext<TInput = unknown> {
+    request: CloudVoiceToolRequest<TInput>;
+    abortSignal: AbortSignal;
+    toolCallId: string;
+    session: CloudVoiceToolRequest<TInput>["session"];
+}
+export interface CloudVoiceToolDefinition<TInput = unknown, TOutput = unknown> {
+    description?: string;
+    input?: {
+        parse: (value: unknown) => TInput;
+    };
+    execute: (input: TInput, context: CloudVoiceToolContext<TInput>) => Promise<TOutput> | TOutput;
+}
+export type CloudVoiceToolMap = Record<string, CloudVoiceToolDefinition<any, any> | ((input: any, context: CloudVoiceToolContext<any>) => unknown)>;
+export interface CreateCloudVoiceToolsOptions<TTools extends CloudVoiceToolMap> {
+    tools: TTools;
+    secret?: string;
+    signatureToleranceMs?: number;
+}
+export declare function createCloudVoiceTools<TTools extends CloudVoiceToolMap>(options: CreateCloudVoiceToolsOptions<TTools>): (request: Request) => Promise<Response>;
+export declare function syncCloudVoiceCodeDefinedTools(input: {
+    kognitive: {
+        getToolMetadataList: () => Array<{
+            id: string;
+            description?: string;
+            inputSchema?: unknown;
+            requireApproval?: boolean;
+        }>;
+    };
+    sourceKey: string;
+    bridgeUrl: string;
+    name?: string;
+    bridgeAuthorization?: string | null;
+    bridgeToken?: string | null;
+    metadata?: Record<string, unknown>;
+    client?: KognitiveCloudVoiceClient;
+    baseUrl?: string;
+    apiKey?: string;
+}): Promise<CloudVoiceToolCatalog>;