@kognitivedev/adapter-chat-kognitive 0.2.29

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kognitivedev/adapter-chat-kognitive",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@kognitivedev/shared": "^0.2.29",
+    "@kognitivedev/ui": "^0.2.29"
+  },
+  "description": "Kognitive chat backend adapter for @kognitivedev/ui",
+  "keywords": [
+    "kognitive",
+    "chat",
+    "adapter",
+    "ui"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/adapter-chat-kognitive"
+  },
+  "homepage": "https://kognitive.dev",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/__tests__/kognitive-backend.test.ts

@@ -0,0 +1,331 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { ModerationError, type KognitiveUIMessage } from "@kognitivedev/shared";
+import { createKognitiveChatBackend } from "../index";
+
+describe("createKognitiveChatBackend", () => {
+    const originalFetch = globalThis.fetch;
+    const fetchMock = vi.fn();
+
+    const userMessage: KognitiveUIMessage = {
+        id: "u1",
+        role: "user",
+        parts: [{ type: "text", text: "Hello" }],
+    };
+
+    function loadFixture(name: string) {
+        const fixturePath = path.resolve(
+            __dirname,
+            "../../../shared/src/__tests__/fixtures/runtime",
+            `${name}.json`,
+        );
+        return JSON.parse(readFileSync(fixturePath, "utf8")) as {
+            request: {
+                sessionId: string;
+                messages: KognitiveUIMessage[];
+                expectedRequestBody: Record<string, unknown>;
+            };
+        };
+    }
+
+    beforeEach(() => {
+        fetchMock.mockReset();
+        globalThis.fetch = fetchMock as unknown as typeof fetch;
+    });
+
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+
+    it("uses product-local kognitive routes by default", async () => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+
+        const backend = createKognitiveChatBackend();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+
+        await client.stream({
+            messages: [userMessage],
+            onEvent: async () => {},
+        });
+
+        expect(fetchMock).toHaveBeenCalledWith(
+            "/api/kognitive/agents/assistant/stream",
+            expect.objectContaining({ method: "POST" }),
+        );
+    });
+
+    it("preserves the canonical request body shape", async () => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+
+        const backend = createKognitiveChatBackend();
+        const client = backend.createExecutionClient({
+            agentName: "assistant",
+            runScope: "session",
+            resourceId: { userId: "user-1" },
+        });
+
+        await client.stream({
+            messages: [userMessage],
+            sessionId: "session-1",
+            body: { customField: true },
+            onEvent: async () => {},
+        });
+
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
+            customField: true,
+            sessionId: "session-1",
+            runScope: "session",
+            resourceId: { userId: "user-1" },
+            messages: [{ role: "user", content: "Hello" }],
+        });
+    });
+
+    it.each([
+        "assistant-tool-stream",
+        "assistant-reasoning-stream",
+        "assistant-error-stream",
+        "assistant-cancelled-stream",
+    ])("matches the shared canonical request fixture for %s", async (fixtureName) => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+        const fixture = loadFixture(fixtureName);
+        const backend = createKognitiveChatBackend({
+            serverUrl: "http://localhost:3001",
+            streamPath: "/api/runtime/agents/:agentName/stream",
+        });
+
+        await backend.createExecutionClient({
+            agentName: "assistant",
+        }).stream({
+            messages: fixture.request.messages,
+            sessionId: fixture.request.sessionId,
+            onEvent: async () => {},
+        });
+
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual(
+            fixture.request.expectedRequestBody,
+        );
+    });
+
+    it("supports custom stream and thread routes", async () => {
+        fetchMock
+            .mockResolvedValueOnce(new Response("", {
+                status: 200,
+                headers: { "Content-Type": "text/event-stream" },
+            }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                threads: [],
+                total: 0,
+            }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }));
+
+        const backend = createKognitiveChatBackend({
+            serverUrl: "https://example.com",
+            streamPath: "/api/runtime/agents/:agentName/stream",
+            threadBasePath: "/api/cognitive/threads/agents/:agentName",
+        });
+        const executionClient = backend.createExecutionClient({ agentName: "assistant" });
+        const threadClient = backend.createThreadClient!({ agentName: "assistant" })!;
+
+        await executionClient.stream({
+            messages: [userMessage],
+            onEvent: async () => {},
+        });
+        await threadClient.list({ limit: 10, offset: 5 });
+
+        expect(fetchMock.mock.calls[0]?.[0]).toBe("https://example.com/api/runtime/agents/assistant/stream");
+        expect(fetchMock.mock.calls[1]?.[0]).toBe("https://example.com/api/cognitive/threads/agents/assistant?limit=10&offset=5");
+    });
+
+    it("preserves canonical tool-result and file history when sending the next turn", async () => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+
+        const backend = createKognitiveChatBackend();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+
+        await client.stream({
+            messages: [
+                {
+                    id: "assistant-1",
+                    role: "assistant",
+                    parts: [
+                        { type: "tool-call", toolCallId: "table-1", toolName: "table", input: { topic: "revenue" } },
+                        { type: "tool-result", toolCallId: "table-1", toolName: "table", result: { rows: [{ region: "EMEA" }] } },
+                        { type: "text", text: "Here is the breakdown." },
+                    ],
+                },
+                {
+                    id: "user-2",
+                    role: "user",
+                    parts: [
+                        {
+                            type: "file",
+                            data: "JVBERi0xLjc=",
+                            filename: "q3.pdf",
+                            mediaType: "application/pdf",
+                        },
+                    ],
+                },
+            ],
+            onEvent: async () => {},
+        });
+
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
+            messages: [
+                {
+                    role: "assistant",
+                    content: [
+                        { type: "tool-call", toolCallId: "table-1", toolName: "table", input: { topic: "revenue" } },
+                        { type: "tool-result", toolCallId: "table-1", toolName: "table", result: { rows: [{ region: "EMEA" }] } },
+                        { type: "text", text: "Here is the breakdown." },
+                    ],
+                },
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "file",
+                            data: "JVBERi0xLjc=",
+                            filename: "q3.pdf",
+                            mediaType: "application/pdf",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    it("maps stream events into the normalized event sink", async () => {
+        fetchMock.mockResolvedValueOnce(new Response([
+            "event: custom",
+            'data: {"role":"assistant","content":"Hi"}',
+            "",
+            "",
+        ].join("\n"), {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+
+        const onEvent = vi.fn(async () => {});
+        const backend = createKognitiveChatBackend();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+
+        await client.stream({
+            messages: [userMessage],
+            onEvent,
+        });
+
+        expect(onEvent).toHaveBeenCalledWith("custom", {
+            role: "assistant",
+            content: "Hi",
+        });
+    });
+
+    it("throws typed moderation errors", async () => {
+        fetchMock.mockResolvedValueOnce(new Response(JSON.stringify({
+            error: "USER_RESTRICTED",
+            code: "user_banned",
+            kind: "ban",
+            surface: "runtime_ui",
+            reasonCode: "abuse",
+            message: "This user is banned.",
+            retryable: false,
+            expiresAt: null,
+        }), {
+            status: 403,
+            headers: { "Content-Type": "application/json" },
+        }));
+
+        const backend = createKognitiveChatBackend();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+
+        await expect(client.stream({
+            messages: [userMessage],
+            onEvent: async () => {},
+        })).rejects.toBeInstanceOf(ModerationError);
+    });
+
+    it("supports thread create and update routes", async () => {
+        fetchMock
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                thread: { sessionId: "s1", title: "Prototype", metadata: { pinned: true } },
+            }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                thread: { sessionId: "s1", title: "Renamed" },
+            }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({
+                thread: {
+                    sessionId: "s1",
+                    title: "Renamed",
+                    metadata: { platforms: { selectedConnectionIds: ["conn-1"] } },
+                },
+            }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            }));
+
+        const backend = createKognitiveChatBackend();
+        const threadClient = backend.createThreadClient!({ agentName: "assistant" })!;
+
+        await threadClient.create({ title: "Prototype", metadata: { pinned: true } });
+        await threadClient.rename?.("s1", "Renamed");
+        const updated = await threadClient.updateMetadata?.("s1", {
+            platforms: { selectedConnectionIds: ["conn-1"] },
+        });
+
+        expect(fetchMock.mock.calls[0]?.[0]).toBe("/api/kognitive/threads/agents/assistant");
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
+            title: "Prototype",
+            metadata: { pinned: true },
+        });
+        expect(fetchMock.mock.calls[1]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1");
+        expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+            title: "Renamed",
+        });
+        expect(fetchMock.mock.calls[2]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1");
+        expect(JSON.parse(String(fetchMock.mock.calls[2]?.[1]?.body))).toEqual({
+            metadataPatch: { platforms: { selectedConnectionIds: ["conn-1"] } },
+        });
+        expect(updated?.metadata).toEqual({ platforms: { selectedConnectionIds: ["conn-1"] } });
+    });
+
+    it("surfaces thread metadata update errors", async () => {
+        fetchMock.mockResolvedValueOnce(new Response(JSON.stringify({
+            error: "metadata failed",
+        }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" },
+        }));
+
+        const backend = createKognitiveChatBackend();
+        const threadClient = backend.createThreadClient!({
+            agentName: "assistant",
+            resourceId: { userId: "user-1" },
+        })!;
+
+        await expect(threadClient.updateMetadata?.("s1", {
+            platforms: { selectedConnectionIds: [] },
+        })).rejects.toThrow("metadata failed");
+        expect(fetchMock.mock.calls[0]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1?userId=user-1");
+    });
+});