@kognitivedev/cloud-voice 0.2.29

package/dist/server.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCloudVoiceTools = createCloudVoiceTools;
+exports.syncCloudVoiceCodeDefinedTools = syncCloudVoiceCodeDefinedTools;
+const node_crypto_1 = require("node:crypto");
+const client_1 = require("./client");
+function json(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function verifySignature(input) {
+    var _a;
+    if (!input.secret)
+        return;
+    if (!input.timestamp || !((_a = input.signature) === null || _a === void 0 ? void 0 : _a.startsWith("sha256="))) {
+        throw new Error("Missing Kognitive signature");
+    }
+    const timestampMs = Date.parse(input.timestamp);
+    if (!Number.isFinite(timestampMs) || Math.abs(Date.now() - timestampMs) > input.toleranceMs) {
+        throw new Error("Kognitive signature timestamp is outside the allowed window");
+    }
+    const expected = `sha256=${(0, node_crypto_1.createHmac)("sha256", input.secret).update(`${input.timestamp}.${input.body}`).digest("hex")}`;
+    const actualBuffer = Buffer.from(input.signature);
+    const expectedBuffer = Buffer.from(expected);
+    if (actualBuffer.length !== expectedBuffer.length || !(0, node_crypto_1.timingSafeEqual)(actualBuffer, expectedBuffer)) {
+        throw new Error("Invalid Kognitive signature");
+    }
+}
+function resolveTool(tools, toolId) {
+    var _a, _b;
+    return (_b = (_a = tools[toolId]) !== null && _a !== void 0 ? _a : tools[toolId.replace(/-/g, "_")]) !== null && _b !== void 0 ? _b : tools[toolId.replace(/_/g, "-")];
+}
+function createCloudVoiceTools(options) {
+    return async function handleCloudVoiceTool(request) {
+        var _a, _b;
+        const rawBody = await request.text();
+        try {
+            verifySignature({
+                body: rawBody,
+                timestamp: request.headers.get("x-kognitive-timestamp"),
+                signature: request.headers.get("x-kognitive-signature"),
+                secret: options.secret,
+                toleranceMs: (_a = options.signatureToleranceMs) !== null && _a !== void 0 ? _a : 5 * 60 * 1000,
+            });
+            const payload = JSON.parse(rawBody || "{}");
+            const toolId = payload.toolId || payload.toolName || "";
+            const tool = resolveTool(options.tools, toolId);
+            if (!tool) {
+                return json({ error: `Unknown Cloud Voice tool: ${toolId}` }, 404);
+            }
+            const definition = typeof tool === "function" ? { execute: tool } : tool;
+            const input = ((_b = definition.input) === null || _b === void 0 ? void 0 : _b.parse) ? definition.input.parse(payload.input) : payload.input;
+            const result = await definition.execute(input, {
+                request: payload,
+                abortSignal: request.signal,
+                toolCallId: payload.toolCallId,
+                session: payload.session,
+            });
+            return json({ result });
+        }
+        catch (error) {
+            return json({ error: error instanceof Error ? error.message : "Cloud Voice tool failed" }, 400);
+        }
+    };
+}
+async function syncCloudVoiceCodeDefinedTools(input) {
+    var _a, _b, _c, _d;
+    const client = (_a = input.client) !== null && _a !== void 0 ? _a : new client_1.KognitiveCloudVoiceClient({
+        baseUrl: (_c = (_b = input.baseUrl) !== null && _b !== void 0 ? _b : process.env.COGNITIVE_API_URL) !== null && _c !== void 0 ? _c : "http://localhost:3001",
+        apiKey: (_d = input.apiKey) !== null && _d !== void 0 ? _d : process.env.COGNITIVE_API_KEY,
+    });
+    const payload = {
+        sourceKey: input.sourceKey,
+        name: input.name,
+        bridgeUrl: input.bridgeUrl,
+        bridgeAuthorization: input.bridgeAuthorization,
+        bridgeToken: input.bridgeToken,
+        metadata: input.metadata,
+        tools: input.kognitive.getToolMetadataList().map((tool) => ({
+            id: tool.id,
+            name: tool.id,
+            description: tool.description,
+            inputSchema: tool.inputSchema && typeof tool.inputSchema === "object" && !Array.isArray(tool.inputSchema)
+                ? tool.inputSchema
+                : { type: "object", additionalProperties: true },
+            requireApproval: Boolean(tool.requireApproval),
+        })),
+    };
+    return client.tools.catalog.sync(payload);
+}

package/dist/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const vitest_1 = require("vitest");
+const server_1 = require("./server");
+function signedRequest(body, secret) {
+    const timestamp = new Date().toISOString();
+    const raw = JSON.stringify(body);
+    const signature = `sha256=${(0, node_crypto_1.createHmac)("sha256", secret).update(`${timestamp}.${raw}`).digest("hex")}`;
+    return new Request("https://example.com/api/voice-tools", {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-kognitive-timestamp": timestamp,
+            "x-kognitive-signature": signature,
+        },
+        body: raw,
+    });
+}
+(0, vitest_1.describe)("createCloudVoiceTools", () => {
+    (0, vitest_1.it)("routes a signed cloud voice tool request to the matching handler", async () => {
+        const handler = (0, server_1.createCloudVoiceTools)({
+            secret: "secret",
+            tools: {
+                lookup_order: async (input, ctx) => ({
+                    orderNumber: input.orderNumber,
+                    userId: ctx.session.userId,
+                }),
+            },
+        });
+        const response = await handler(signedRequest({
+            type: "cloud_voice.tool.execute",
+            toolCallId: "tool_call_1",
+            toolId: "lookup_order",
+            input: { orderNumber: "A-1024" },
+            session: {
+                id: "session-db-id",
+                sessionId: "voice_session_1",
+                agentSlug: "support",
+                channel: "iframe",
+                userId: "user_1",
+                resourceId: { userId: "user_1" },
+                metadata: {},
+            },
+        }, "secret"));
+        await (0, vitest_1.expect)(response.json()).resolves.toEqual({
+            result: {
+                orderNumber: "A-1024",
+                userId: "user_1",
+            },
+        });
+    });
+    (0, vitest_1.it)("rejects invalid signatures", async () => {
+        const handler = (0, server_1.createCloudVoiceTools)({
+            secret: "secret",
+            tools: {
+                lookup_order: async () => ({ ok: true }),
+            },
+        });
+        const response = await handler(signedRequest({
+            type: "cloud_voice.tool.execute",
+            toolCallId: "tool_call_1",
+            toolId: "lookup_order",
+            input: {},
+            session: {
+                id: "session-db-id",
+                sessionId: "voice_session_1",
+                agentSlug: "support",
+                channel: "iframe",
+                userId: "user_1",
+                resourceId: {},
+                metadata: {},
+            },
+        }, "wrong"));
+        (0, vitest_1.expect)(response.status).toBe(400);
+        await (0, vitest_1.expect)(response.json()).resolves.toEqual({ error: "Invalid Kognitive signature" });
+    });
+});

package/dist/sse.d.ts

@@ -0,0 +1,7 @@
+export interface ParsedSSEEvent {
+    event?: string;
+    data: string;
+    id?: string;
+    retry?: number;
+}
+export declare function readSSEStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<ParsedSSEEvent>;

package/dist/sse.js

@@ -0,0 +1,75 @@
+"use strict";
+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.readSSEStream = readSSEStream;
+function readSSEStream(stream) {
+    return __asyncGenerator(this, arguments, function* readSSEStream_1() {
+        var _a;
+        const reader = stream.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let event = "";
+        let data = [];
+        let id;
+        let retry;
+        function flush() {
+            if (!event && data.length === 0 && !id && retry === undefined)
+                return null;
+            const frame = {
+                event: event || undefined,
+                data: data.join("\n"),
+                id,
+                retry,
+            };
+            event = "";
+            data = [];
+            id = undefined;
+            retry = undefined;
+            return frame;
+        }
+        while (true) {
+            const { value, done } = yield __await(reader.read());
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r\n|\r|\n/);
+            buffer = (_a = lines.pop()) !== null && _a !== void 0 ? _a : "";
+            for (const line of lines) {
+                if (line === "") {
+                    const frame = flush();
+                    if (frame)
+                        yield yield __await(frame);
+                    continue;
+                }
+                if (line.startsWith(":"))
+                    continue;
+                const separator = line.indexOf(":");
+                const field = separator === -1 ? line : line.slice(0, separator);
+                const rawValue = separator === -1 ? "" : line.slice(separator + 1).replace(/^ /, "");
+                if (field === "event")
+                    event = rawValue;
+                if (field === "data")
+                    data.push(rawValue);
+                if (field === "id")
+                    id = rawValue;
+                if (field === "retry")
+                    retry = Number(rawValue);
+            }
+        }
+        const tail = flush();
+        if (tail)
+            yield yield __await(tail);
+    });
+}