@kognitivedev/adapter-chat-kognitive 0.2.29

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/.turbo/turbo-test.log

@@ -0,0 +1,11 @@
+$ vitest run
+
+ RUN  v3.2.4 /Users/vserifsaglam/work/memory-experiment/packages/adapter-chat-kognitive
+
+ ✓ src/__tests__/kognitive-backend.test.ts (12 tests) 16ms
+
+ Test Files  1 passed (1)
+      Tests  12 passed (12)
+   Start at  17:30:04
+   Duration  605ms (transform 79ms, setup 0ms, collect 142ms, tests 16ms, environment 0ms, prepare 160ms)
+

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @kognitivedev/adapter-chat-kognitive
+
+## 0.2.29
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/shared@0.2.29
+  - @kognitivedev/ui@0.2.29

package/README.md

@@ -0,0 +1,8 @@
+# @kognitivedev/adapter-chat-kognitive
+
+Backend adapter for `@kognitivedev/ui` that targets Kognitive-compatible chat routes.
+
+Default routes:
+
+- `/api/kognitive/agents/:agentName/stream`
+- `/api/kognitive/threads/agents/:agentName`

package/dist/__tests__/kognitive-backend.test.d.ts

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

package/dist/__tests__/kognitive-backend.test.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const vitest_1 = require("vitest");
+const shared_1 = require("@kognitivedev/shared");
+const index_1 = require("../index");
+(0, vitest_1.describe)("createKognitiveChatBackend", () => {
+    const originalFetch = globalThis.fetch;
+    const fetchMock = vitest_1.vi.fn();
+    const userMessage = {
+        id: "u1",
+        role: "user",
+        parts: [{ type: "text", text: "Hello" }],
+    };
+    function loadFixture(name) {
+        const fixturePath = node_path_1.default.resolve(__dirname, "../../../shared/src/__tests__/fixtures/runtime", `${name}.json`);
+        return JSON.parse((0, node_fs_1.readFileSync)(fixturePath, "utf8"));
+    }
+    (0, vitest_1.beforeEach)(() => {
+        fetchMock.mockReset();
+        globalThis.fetch = fetchMock;
+    });
+    (0, vitest_1.afterEach)(() => {
+        globalThis.fetch = originalFetch;
+    });
+    (0, vitest_1.it)("uses product-local kognitive routes by default", async () => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+        const backend = (0, index_1.createKognitiveChatBackend)();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+        await client.stream({
+            messages: [userMessage],
+            onEvent: async () => { },
+        });
+        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith("/api/kognitive/agents/assistant/stream", vitest_1.expect.objectContaining({ method: "POST" }));
+    });
+    (0, vitest_1.it)("preserves the canonical request body shape", async () => {
+        fetchMock.mockResolvedValueOnce(new Response("", {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream" },
+        }));
+        const backend = (0, index_1.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 () => { },
+        });
+        (0, vitest_1.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" }],
+        });
+    });
+    vitest_1.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 = (0, index_1.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 () => { },
+        });
+        (0, vitest_1.expect)(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual(fixture.request.expectedRequestBody);
+    });
+    (0, vitest_1.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 = (0, index_1.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 });
+        (0, vitest_1.expect)(fetchMock.mock.calls[0]?.[0]).toBe("https://example.com/api/runtime/agents/assistant/stream");
+        (0, vitest_1.expect)(fetchMock.mock.calls[1]?.[0]).toBe("https://example.com/api/cognitive/threads/agents/assistant?limit=10&offset=5");
+    });
+    (0, vitest_1.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 = (0, index_1.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 () => { },
+        });
+        (0, vitest_1.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",
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    (0, vitest_1.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 = vitest_1.vi.fn(async () => { });
+        const backend = (0, index_1.createKognitiveChatBackend)();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+        await client.stream({
+            messages: [userMessage],
+            onEvent,
+        });
+        (0, vitest_1.expect)(onEvent).toHaveBeenCalledWith("custom", {
+            role: "assistant",
+            content: "Hi",
+        });
+    });
+    (0, vitest_1.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 = (0, index_1.createKognitiveChatBackend)();
+        const client = backend.createExecutionClient({ agentName: "assistant" });
+        await (0, vitest_1.expect)(client.stream({
+            messages: [userMessage],
+            onEvent: async () => { },
+        })).rejects.toBeInstanceOf(shared_1.ModerationError);
+    });
+    (0, vitest_1.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 = (0, index_1.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"] },
+        });
+        (0, vitest_1.expect)(fetchMock.mock.calls[0]?.[0]).toBe("/api/kognitive/threads/agents/assistant");
+        (0, vitest_1.expect)(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toEqual({
+            title: "Prototype",
+            metadata: { pinned: true },
+        });
+        (0, vitest_1.expect)(fetchMock.mock.calls[1]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1");
+        (0, vitest_1.expect)(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body))).toEqual({
+            title: "Renamed",
+        });
+        (0, vitest_1.expect)(fetchMock.mock.calls[2]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1");
+        (0, vitest_1.expect)(JSON.parse(String(fetchMock.mock.calls[2]?.[1]?.body))).toEqual({
+            metadataPatch: { platforms: { selectedConnectionIds: ["conn-1"] } },
+        });
+        (0, vitest_1.expect)(updated?.metadata).toEqual({ platforms: { selectedConnectionIds: ["conn-1"] } });
+    });
+    (0, vitest_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 = (0, index_1.createKognitiveChatBackend)();
+        const threadClient = backend.createThreadClient({
+            agentName: "assistant",
+            resourceId: { userId: "user-1" },
+        });
+        await (0, vitest_1.expect)(threadClient.updateMetadata?.("s1", {
+            platforms: { selectedConnectionIds: [] },
+        })).rejects.toThrow("metadata failed");
+        (0, vitest_1.expect)(fetchMock.mock.calls[0]?.[0]).toBe("/api/kognitive/threads/agents/assistant/s1?userId=user-1");
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { ChatBackendAdapter, ChatBackendContext } from "@kognitivedev/ui";
+export interface KognitiveChatBackendOptions {
+    serverUrl?: string;
+    streamPath?: string | ((context: ChatBackendContext) => string);
+    threadBasePath?: string | ((context: ChatBackendContext) => string);
+    headers?: Record<string, string> | ((context: ChatBackendContext) => Record<string, string> | undefined);
+    fetch?: typeof fetch;
+}
+export declare function createKognitiveChatBackend(options?: KognitiveChatBackendOptions): ChatBackendAdapter;
+export declare const createKognitiveUIChatBackend: typeof createKognitiveChatBackend;
+export type KognitiveUIChatBackendOptions = KognitiveChatBackendOptions;

package/dist/index.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKognitiveUIChatBackend = void 0;
+exports.createKognitiveChatBackend = createKognitiveChatBackend;
+const shared_1 = require("@kognitivedev/shared");
+const ABSOLUTE_URL_RE = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+function isAbsoluteUrl(value) {
+    return ABSOLUTE_URL_RE.test(value);
+}
+function resolveServerUrl(serverUrl) {
+    const resolved = serverUrl ?? "";
+    if (resolved === "/")
+        return "";
+    return resolved.replace(/\/$/, "");
+}
+function joinServerPath(serverUrl, path) {
+    const normalizedServerUrl = resolveServerUrl(serverUrl);
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${normalizedServerUrl}${normalizedPath}`;
+}
+function appendQueryParams(urlString, params) {
+    if (isAbsoluteUrl(urlString)) {
+        const url = new URL(urlString);
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, value);
+            }
+        }
+        return url.toString();
+    }
+    const [pathAndQuery, hash = ""] = urlString.split("#", 2);
+    const [pathname, query = ""] = pathAndQuery.split("?", 2);
+    const searchParams = new URLSearchParams(query);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            searchParams.set(key, value);
+        }
+    }
+    const nextQuery = searchParams.toString();
+    return `${pathname}${nextQuery ? `?${nextQuery}` : ""}${hash ? `#${hash}` : ""}`;
+}
+function resolveTemplate(template, context, fallback) {
+    const resolved = typeof template === "function" ? template(context) : template ?? fallback;
+    return resolved.replace(/:agentName/g, encodeURIComponent(context.agentName));
+}
+function resolveEndpoint(serverUrl, path) {
+    if (isAbsoluteUrl(path)) {
+        return path.replace(/\/$/, "");
+    }
+    return joinServerPath(serverUrl, path);
+}
+function resolveAdapterHeaders(context, source) {
+    return {
+        ...(typeof source === "function" ? source(context) ?? {} : source ?? {}),
+        ...(context.headers ?? {}),
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function extractInlineFileData(url) {
+    if (!url.startsWith("data:")) {
+        return undefined;
+    }
+    const commaIndex = url.indexOf(",");
+    if (commaIndex === -1) {
+        return undefined;
+    }
+    const metadata = url.slice(0, commaIndex);
+    const payload = url.slice(commaIndex + 1);
+    if (metadata.includes(";base64")) {
+        return payload;
+    }
+    try {
+        return decodeURIComponent(payload);
+    }
+    catch {
+        return payload;
+    }
+}
+function serializeRuntimePart(part) {
+    if (part.type !== "file") {
+        return part;
+    }
+    const filePart = part;
+    if (filePart.data !== undefined) {
+        return filePart;
+    }
+    const inlineData = typeof filePart.url === "string" ? extractInlineFileData(filePart.url) : undefined;
+    if (inlineData === undefined) {
+        return filePart;
+    }
+    return {
+        type: "file",
+        data: inlineData,
+        filename: filePart.filename ?? filePart.name,
+        mediaType: filePart.mediaType ?? filePart.mimeType ?? filePart.mime_type,
+    };
+}
+function serializeRuntimeMetadata(metadata) {
+    if (!metadata || typeof metadata !== "object") {
+        return metadata;
+    }
+    const { feedback: _ignoredFeedback, ...rest } = metadata;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+}
+function uiMessageToRuntimeMessage(message) {
+    return {
+        role: message.role,
+        content: message.parts.map(serializeRuntimePart),
+        metadata: serializeRuntimeMetadata(message.metadata),
+    };
+}
+async function buildKognitiveTransportError(response) {
+    const responseText = await response.clone().text();
+    if (responseText !== "") {
+        try {
+            const parsed = JSON.parse(responseText);
+            if ((0, shared_1.isModerationErrorPayload)(parsed)) {
+                return new shared_1.ModerationError(parsed, response.status);
+            }
+            if (parsed && typeof parsed === "object" && typeof parsed.error === "string") {
+                return new Error(parsed.error);
+            }
+        }
+        catch {
+            // fall back to raw text
+        }
+    }
+    return new Error(`Kognitive transport failed: HTTP ${response.status}`);
+}
+function createKognitiveChatBackend(options = {}) {
+    const serverUrl = resolveServerUrl(options.serverUrl);
+    const fetchImpl = options.fetch ?? fetch;
+    return {
+        capabilities: {
+            threads: true,
+            threadFork: true,
+            threadInterrupt: true,
+            threadDelete: true,
+            threadRename: true,
+            threadArchive: true,
+            messageFeedback: true,
+        },
+        createExecutionClient(context) {
+            const api = resolveEndpoint(serverUrl, resolveTemplate(options.streamPath, context, "/api/kognitive/agents/:agentName/stream"));
+            const baseHeaders = {
+                "Content-Type": "application/json",
+                ...resolveAdapterHeaders(context, options.headers),
+            };
+            return {
+                async stream(request) {
+                    const contextBody = asRecord(context.body);
+                    const requestBody = asRecord(request.body);
+                    const mergedMetadata = {
+                        ...(asRecord(contextBody?.metadata) ?? {}),
+                        ...(asRecord(requestBody?.metadata) ?? {}),
+                    };
+                    const response = await fetchImpl(api, {
+                        method: "POST",
+                        headers: baseHeaders,
+                        body: JSON.stringify({
+                            ...(contextBody ?? {}),
+                            ...(requestBody ?? {}),
+                            ...(Object.keys(mergedMetadata).length > 0 ? { metadata: mergedMetadata } : {}),
+                            ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+                            ...(context.runScope ? { runScope: context.runScope } : {}),
+                            ...(context.resourceId ? { resourceId: context.resourceId } : {}),
+                            messages: (0, shared_1.buildCanonicalConversationMessages)(request.messages.map(uiMessageToRuntimeMessage)),
+                        }),
+                        signal: request.signal,
+                    });
+                    if (!response.ok) {
+                        throw await buildKognitiveTransportError(response);
+                    }
+                    await (0, shared_1.readKognitiveEventStream)(response, async (eventName, data) => {
+                        if (eventName === "messages" || eventName === "custom" || eventName === "debug") {
+                            await request.onEvent(eventName, data);
+                        }
+                    });
+                },
+            };
+        },
+        createThreadClient(context) {
+            const apiBase = resolveEndpoint(serverUrl, resolveTemplate(options.threadBasePath, context, "/api/kognitive/threads/agents/:agentName")).replace(/\/$/, "");
+            const headers = {
+                "Content-Type": "application/json",
+                ...resolveAdapterHeaders(context, options.headers),
+            };
+            const userId = context.resourceId?.userId ? String(context.resourceId.userId) : undefined;
+            const buildUrl = (path = "") => appendQueryParams(`${apiBase}${path}`, { userId });
+            return {
+                async list(query) {
+                    const url = appendQueryParams(buildUrl(), {
+                        userId,
+                        ...(query?.limit !== undefined ? { limit: String(query.limit) } : {}),
+                        ...(query?.offset !== undefined ? { offset: String(query.offset) } : {}),
+                    });
+                    const res = await fetchImpl(url, { headers });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to list threads" }))).error);
+                    }
+                    const data = await res.json();
+                    return {
+                        threads: (data.threads ?? []),
+                        total: typeof data.total === "number" ? data.total : (data.threads ?? []).length,
+                    };
+                },
+                async get(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), { headers });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to get thread" }))).error);
+                    }
+                    return (await res.json());
+                },
+                async create(input) {
+                    const res = await fetchImpl(buildUrl(), {
+                        method: "POST",
+                        headers,
+                        body: JSON.stringify({
+                            ...(userId ? { userId } : {}),
+                            ...(input ?? {}),
+                        }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to create thread" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async fork(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}/fork`), {
+                        method: "POST",
+                        headers,
+                        body: JSON.stringify(userId ? { userId } : {}),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to fork thread" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async interrupt(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}/interrupt`), {
+                        method: "POST",
+                        headers,
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to interrupt thread" }))).error);
+                    }
+                },
+                async delete(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), {
+                        method: "DELETE",
+                        headers,
+                    });
+                    if (!res.ok && res.status !== 204) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to delete thread" }))).error);
+                    }
+                },
+                async rename(sessionId, title) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), {
+                        method: "PATCH",
+                        headers,
+                        body: JSON.stringify({ title }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to rename thread" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async updateMetadata(sessionId, metadataPatch) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), {
+                        method: "PATCH",
+                        headers,
+                        body: JSON.stringify({ metadataPatch }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to update thread metadata" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async archive(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), {
+                        method: "PATCH",
+                        headers,
+                        body: JSON.stringify({ archived: true }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to archive thread" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async unarchive(sessionId) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}`), {
+                        method: "PATCH",
+                        headers,
+                        body: JSON.stringify({ archived: false }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to unarchive thread" }))).error);
+                    }
+                    const data = await res.json();
+                    return data.thread;
+                },
+                async setMessageFeedback(sessionId, messageId, value) {
+                    const res = await fetchImpl(buildUrl(`/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(messageId)}/feedback`), {
+                        method: "PUT",
+                        headers,
+                        body: JSON.stringify({ value }),
+                    });
+                    if (!res.ok) {
+                        throw new Error((await res.json().catch(() => ({ error: "Failed to set message feedback" }))).error);
+                    }
+                },
+            };
+        },
+    };
+}
+exports.createKognitiveUIChatBackend = createKognitiveChatBackend;