@kognitivedev/adapter-chat-local 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-local
+
+ ✓ src/__tests__/local-backend.test.ts (3 tests) 6ms
+
+ Test Files  1 passed (1)
+      Tests  3 passed (3)
+   Start at  17:30:04
+   Duration  529ms (transform 58ms, setup 0ms, collect 64ms, tests 6ms, environment 0ms, prepare 152ms)
+

package/CHANGELOG.md

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

package/README.md

@@ -0,0 +1,5 @@
+# @kognitivedev/adapter-chat-local
+
+In-memory local chat backend adapter for `@kognitivedev/ui`.
+
+Useful for demos, tests, and local-first prototypes.

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../index");
+(0, vitest_1.describe)("createLocalChatBackend", () => {
+    (0, vitest_1.it)("manages thread state in memory", async () => {
+        const backend = (0, index_1.createLocalChatBackend)();
+        const threadClient = backend.createThreadClient({ agentName: "assistant" });
+        const created = await threadClient.create({ title: "Prototype" });
+        const listed = await threadClient.list();
+        const detail = await threadClient.get(created.sessionId);
+        (0, vitest_1.expect)(created.title).toBe("Prototype");
+        (0, vitest_1.expect)(listed.total).toBe(1);
+        (0, vitest_1.expect)(detail.session.sessionId).toBe(created.sessionId);
+    });
+    (0, vitest_1.it)("persists assistant messages from the default responder", async () => {
+        const backend = (0, index_1.createLocalChatBackend)();
+        const executionClient = backend.createExecutionClient({ agentName: "assistant" });
+        const threadClient = backend.createThreadClient({ agentName: "assistant" });
+        await executionClient.stream({
+            sessionId: "s1",
+            messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "Hello" }] }],
+            onEvent: async () => { },
+        });
+        const detail = await threadClient.get("s1");
+        (0, vitest_1.expect)(detail.messages).toHaveLength(2);
+        (0, vitest_1.expect)(detail.messages[1]).toMatchObject({
+            role: "assistant",
+            content: [{ type: "text", text: "Local adapter reply: Hello" }],
+        });
+    });
+    (0, vitest_1.it)("supports custom streaming responders", async () => {
+        const onEvent = vitest_1.vi.fn(async () => { });
+        const backend = (0, index_1.createLocalChatBackend)({
+            stream: async ({ emit }) => {
+                await emit("debug", { step: "started" });
+                await emit("custom", {
+                    role: "assistant",
+                    content: [{ type: "text", text: "Custom reply" }],
+                });
+            },
+        });
+        await backend.createExecutionClient({ agentName: "assistant" }).stream({
+            sessionId: "s1",
+            messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "Hello" }] }],
+            onEvent,
+        });
+        (0, vitest_1.expect)(onEvent).toHaveBeenCalledWith("debug", { step: "started" });
+        (0, vitest_1.expect)(onEvent).toHaveBeenCalledWith("custom", {
+            role: "assistant",
+            content: [{ type: "text", text: "Custom reply" }],
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import type { KognitiveMessage, KognitiveUIMessage } from "@kognitivedev/shared";
+import type { ChatBackendAdapter, ChatBackendContext, ChatBackendEventSink, ThreadSummary } from "@kognitivedev/ui";
+export interface LocalChatBackendOptions {
+    initialThreads?: ThreadSummary[];
+    initialMessagesBySessionId?: Record<string, KognitiveMessage[]>;
+    idGenerator?: () => string;
+    now?: () => Date;
+    respond?: (input: {
+        messages: KognitiveUIMessage[];
+        sessionId?: string;
+        context: ChatBackendContext;
+    }) => Promise<KognitiveMessage> | KognitiveMessage;
+    stream?: (input: {
+        messages: KognitiveUIMessage[];
+        sessionId?: string;
+        context: ChatBackendContext;
+        emit: ChatBackendEventSink;
+    }) => Promise<KognitiveMessage | void> | KognitiveMessage | void;
+}
+export declare function createLocalChatBackend(options?: LocalChatBackendOptions): ChatBackendAdapter;

package/dist/index.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalChatBackend = createLocalChatBackend;
+function defaultId() {
+    return crypto.randomUUID();
+}
+function defaultNow() {
+    return new Date();
+}
+function getMessageText(message) {
+    return message.parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join(" ")
+        .trim();
+}
+function toRuntimeMessage(message) {
+    return {
+        role: message.role,
+        content: message.parts,
+        metadata: message.metadata,
+    };
+}
+function truncate(value, limit = 72) {
+    const normalized = value.trim();
+    if (normalized.length <= limit)
+        return normalized;
+    return `${normalized.slice(0, limit - 1)}…`;
+}
+function textParts(parts) {
+    return parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join(" ");
+}
+function defaultAssistantReply(messages) {
+    const lastUserMessage = [...messages].reverse().find((message) => message.role === "user");
+    const text = lastUserMessage ? getMessageText(lastUserMessage) : "";
+    return {
+        role: "assistant",
+        content: [{
+                type: "text",
+                text: text
+                    ? `Local adapter reply: ${text}`
+                    : "Local adapter reply ready.",
+            }],
+    };
+}
+function getDurableMessageId(message) {
+    const value = message.metadata?.kognitiveMessageId;
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function withDurableMessageMetadata(message, fallbackId, feedback) {
+    const messageId = getDurableMessageId(message) ?? fallbackId;
+    const metadata = (message.metadata ?? {});
+    const { feedback: _ignoredFeedback, ...restMetadata } = metadata;
+    return {
+        ...message,
+        metadata: {
+            ...restMetadata,
+            kognitiveMessageId: messageId,
+            ...(feedback ? { feedback } : {}),
+        },
+    };
+}
+function createSummary(now, id, title = "", metadata = null) {
+    return {
+        sessionDbId: `local-${id}`,
+        sessionId: id,
+        title,
+        status: "idle",
+        updatedAt: now.toISOString(),
+        messageCount: 0,
+        lastUserPreview: "",
+        lastAssistantPreview: "",
+        lastError: null,
+        lastTraceDbId: null,
+        metadata,
+    };
+}
+function createDetail(record) {
+    return {
+        session: {
+            id: record.summary.sessionDbId,
+            sessionId: record.summary.sessionId,
+            messageCount: record.summary.messageCount,
+            metadata: record.summary.metadata ?? null,
+        },
+        messages: record.messages.map((message) => withDurableMessageMetadata(message, crypto.randomUUID(), (() => {
+            const messageId = getDurableMessageId(message);
+            return messageId ? record.feedbackByMessageId.get(messageId) : undefined;
+        })())),
+        events: [],
+        traces: [],
+        runs: [],
+    };
+}
+function createLocalChatBackend(options = {}) {
+    const makeId = options.idGenerator ?? defaultId;
+    const now = options.now ?? defaultNow;
+    const sessions = new Map();
+    for (const thread of options.initialThreads ?? []) {
+        sessions.set(thread.sessionId, {
+            summary: thread,
+            messages: (options.initialMessagesBySessionId?.[thread.sessionId] ?? []).map((message) => withDurableMessageMetadata(message, makeId())),
+            feedbackByMessageId: new Map(),
+        });
+    }
+    const ensureSession = (sessionId, input) => {
+        const id = sessionId ?? input?.sessionId ?? makeId();
+        const existing = sessions.get(id);
+        if (existing)
+            return existing;
+        const record = {
+            summary: createSummary(now(), id, input?.title ?? "", input?.metadata ?? null),
+            messages: [],
+            feedbackByMessageId: new Map(),
+        };
+        sessions.set(id, record);
+        return record;
+    };
+    const updateSummaryFromMessages = (record) => {
+        const userMessages = record.messages.filter((message) => message.role === "user");
+        const assistantMessages = record.messages.filter((message) => message.role === "assistant");
+        const latestUser = userMessages.at(-1);
+        const latestAssistant = assistantMessages.at(-1);
+        const latestUserText = typeof latestUser?.content === "string"
+            ? latestUser.content
+            : Array.isArray(latestUser?.content)
+                ? textParts(latestUser.content)
+                : "";
+        const latestAssistantText = typeof latestAssistant?.content === "string"
+            ? latestAssistant.content
+            : Array.isArray(latestAssistant?.content)
+                ? textParts(latestAssistant.content)
+                : "";
+        record.summary = {
+            ...record.summary,
+            title: record.summary.title || truncate(latestUserText, 48) || "New chat",
+            updatedAt: now().toISOString(),
+            messageCount: record.messages.length,
+            lastUserPreview: truncate(latestUserText),
+            lastAssistantPreview: truncate(latestAssistantText),
+        };
+    };
+    const threadManager = {
+        async list(query) {
+            const all = [...sessions.values()]
+                .map((record) => record.summary)
+                .sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+            const offset = query?.offset ?? 0;
+            const limit = query?.limit ?? all.length;
+            return {
+                threads: all.slice(offset, offset + limit),
+                total: all.length,
+            };
+        },
+        async get(sessionId) {
+            const record = sessions.get(sessionId);
+            if (!record) {
+                throw new Error(`Thread "${sessionId}" not found.`);
+            }
+            return createDetail(record);
+        },
+        async create(input) {
+            const record = ensureSession(undefined, input);
+            updateSummaryFromMessages(record);
+            return record.summary;
+        },
+        async delete(sessionId) {
+            sessions.delete(sessionId);
+        },
+        async rename(sessionId, title) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                title,
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async archive(sessionId) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                status: "archived",
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async unarchive(sessionId) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                status: "idle",
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async setMessageFeedback(sessionId, messageId, value) {
+            const record = ensureSession(sessionId);
+            if (value) {
+                record.feedbackByMessageId.set(messageId, value);
+            }
+            else {
+                record.feedbackByMessageId.delete(messageId);
+            }
+            record.messages = record.messages.map((message) => {
+                if (getDurableMessageId(message) !== messageId)
+                    return message;
+                return withDurableMessageMetadata(message, messageId, value ?? undefined);
+            });
+        },
+    };
+    return {
+        capabilities: {
+            threads: true,
+            threadDelete: true,
+            threadRename: true,
+            threadArchive: true,
+            messageFeedback: true,
+        },
+        createExecutionClient(context) {
+            return {
+                async stream(request) {
+                    const record = ensureSession(request.sessionId);
+                    record.messages = request.messages
+                        .map(toRuntimeMessage)
+                        .map((message) => withDurableMessageMetadata(message, makeId(), (() => {
+                        const messageId = getDurableMessageId(message);
+                        return messageId ? record.feedbackByMessageId.get(messageId) : undefined;
+                    })()));
+                    let assistantMessage;
+                    if (options.stream) {
+                        const streamedMessages = [];
+                        const result = await options.stream({
+                            messages: request.messages,
+                            sessionId: request.sessionId,
+                            context,
+                            emit: async (eventName, data) => {
+                                if (eventName === "custom" && data && typeof data === "object" && "role" in data) {
+                                    streamedMessages.push(withDurableMessageMetadata(data, makeId()));
+                                }
+                                await request.onEvent(eventName, data);
+                            },
+                        });
+                        assistantMessage = result ? withDurableMessageMetadata(result, makeId()) : streamedMessages.at(-1);
+                    }
+                    else {
+                        assistantMessage = withDurableMessageMetadata(options.respond
+                            ? await options.respond({ messages: request.messages, sessionId: request.sessionId, context })
+                            : defaultAssistantReply(request.messages), makeId());
+                        await request.onEvent("custom", assistantMessage);
+                    }
+                    if (assistantMessage) {
+                        record.messages = [...record.messages, assistantMessage];
+                        updateSummaryFromMessages(record);
+                    }
+                },
+            };
+        },
+        createThreadClient() {
+            return threadManager;
+        },
+    };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kognitivedev/adapter-chat-local",
+  "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": "In-memory local chat backend adapter for @kognitivedev/ui",
+  "keywords": [
+    "kognitive",
+    "chat",
+    "local",
+    "adapter"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/adapter-chat-local"
+  },
+  "homepage": "https://kognitive.dev",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}

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

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from "vitest";
+import { createLocalChatBackend } from "../index";
+
+describe("createLocalChatBackend", () => {
+    it("manages thread state in memory", async () => {
+        const backend = createLocalChatBackend();
+        const threadClient = backend.createThreadClient!({ agentName: "assistant" })!;
+
+        const created = await threadClient.create({ title: "Prototype" });
+        const listed = await threadClient.list();
+        const detail = await threadClient.get(created.sessionId);
+
+        expect(created.title).toBe("Prototype");
+        expect(listed.total).toBe(1);
+        expect(detail.session.sessionId).toBe(created.sessionId);
+    });
+
+    it("persists assistant messages from the default responder", async () => {
+        const backend = createLocalChatBackend();
+        const executionClient = backend.createExecutionClient({ agentName: "assistant" });
+        const threadClient = backend.createThreadClient!({ agentName: "assistant" })!;
+
+        await executionClient.stream({
+            sessionId: "s1",
+            messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "Hello" }] }],
+            onEvent: async () => {},
+        });
+
+        const detail = await threadClient.get("s1");
+        expect(detail.messages).toHaveLength(2);
+        expect(detail.messages[1]).toMatchObject({
+            role: "assistant",
+            content: [{ type: "text", text: "Local adapter reply: Hello" }],
+        });
+    });
+
+    it("supports custom streaming responders", async () => {
+        const onEvent = vi.fn(async () => {});
+        const backend = createLocalChatBackend({
+            stream: async ({ emit }) => {
+                await emit("debug", { step: "started" });
+                await emit("custom", {
+                    role: "assistant",
+                    content: [{ type: "text", text: "Custom reply" }],
+                });
+            },
+        });
+
+        await backend.createExecutionClient({ agentName: "assistant" }).stream({
+            sessionId: "s1",
+            messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "Hello" }] }],
+            onEvent,
+        });
+
+        expect(onEvent).toHaveBeenCalledWith("debug", { step: "started" });
+        expect(onEvent).toHaveBeenCalledWith("custom", {
+            role: "assistant",
+            content: [{ type: "text", text: "Custom reply" }],
+        });
+    });
+});

package/src/index.ts

@@ -0,0 +1,332 @@
+import type { KognitiveContentPart, KognitiveMessage, KognitiveUIMessage } from "@kognitivedev/shared";
+import type {
+    ChatBackendAdapter,
+    ChatBackendContext,
+    ChatBackendEventSink,
+    ChatThreadClient,
+    ThreadCreateInput,
+    ThreadDetail,
+    ThreadMetadata,
+    ThreadSummary,
+} from "@kognitivedev/ui";
+
+export interface LocalChatBackendOptions {
+    initialThreads?: ThreadSummary[];
+    initialMessagesBySessionId?: Record<string, KognitiveMessage[]>;
+    idGenerator?: () => string;
+    now?: () => Date;
+    respond?: (input: {
+        messages: KognitiveUIMessage[];
+        sessionId?: string;
+        context: ChatBackendContext;
+    }) => Promise<KognitiveMessage> | KognitiveMessage;
+    stream?: (input: {
+        messages: KognitiveUIMessage[];
+        sessionId?: string;
+        context: ChatBackendContext;
+        emit: ChatBackendEventSink;
+    }) => Promise<KognitiveMessage | void> | KognitiveMessage | void;
+}
+
+interface LocalSessionRecord {
+    summary: ThreadSummary;
+    messages: KognitiveMessage[];
+    feedbackByMessageId: Map<string, "positive" | "negative">;
+}
+
+function defaultId() {
+    return crypto.randomUUID();
+}
+
+function defaultNow() {
+    return new Date();
+}
+
+function getMessageText(message: KognitiveUIMessage): string {
+    return message.parts
+        .filter((part): part is Extract<KognitiveUIMessage["parts"][number], { type: "text" }> => part.type === "text")
+        .map((part) => part.text)
+        .join(" ")
+        .trim();
+}
+
+function toRuntimeMessage(message: KognitiveUIMessage): KognitiveMessage {
+    return {
+        role: message.role,
+        content: message.parts,
+        metadata: message.metadata,
+    };
+}
+
+function truncate(value: string, limit = 72) {
+    const normalized = value.trim();
+    if (normalized.length <= limit) return normalized;
+    return `${normalized.slice(0, limit - 1)}…`;
+}
+
+function textParts(parts: readonly KognitiveContentPart[]) {
+    return parts
+        .filter((part): part is Extract<KognitiveContentPart, { type: "text" }> => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join(" ");
+}
+
+function defaultAssistantReply(messages: KognitiveUIMessage[]): KognitiveMessage {
+    const lastUserMessage = [...messages].reverse().find((message) => message.role === "user");
+    const text = lastUserMessage ? getMessageText(lastUserMessage) : "";
+    return {
+        role: "assistant",
+        content: [{
+            type: "text",
+            text: text
+                ? `Local adapter reply: ${text}`
+                : "Local adapter reply ready.",
+        }],
+    };
+}
+
+function getDurableMessageId(message: Pick<KognitiveMessage, "metadata">): string | null {
+    const value = message.metadata?.kognitiveMessageId;
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function withDurableMessageMetadata(
+    message: KognitiveMessage,
+    fallbackId: string,
+    feedback?: "positive" | "negative",
+): KognitiveMessage {
+    const messageId = getDurableMessageId(message) ?? fallbackId;
+    const metadata = (message.metadata ?? {}) as Record<string, unknown>;
+    const { feedback: _ignoredFeedback, ...restMetadata } = metadata;
+    return {
+        ...message,
+        metadata: {
+            ...restMetadata,
+            kognitiveMessageId: messageId,
+            ...(feedback ? { feedback } : {}),
+        },
+    };
+}
+
+function createSummary(now: Date, id: string, title = "", metadata: ThreadMetadata | null = null): ThreadSummary {
+    return {
+        sessionDbId: `local-${id}`,
+        sessionId: id,
+        title,
+        status: "idle",
+        updatedAt: now.toISOString(),
+        messageCount: 0,
+        lastUserPreview: "",
+        lastAssistantPreview: "",
+        lastError: null,
+        lastTraceDbId: null,
+        metadata,
+    };
+}
+
+function createDetail(record: LocalSessionRecord): ThreadDetail {
+    return {
+        session: {
+            id: record.summary.sessionDbId,
+            sessionId: record.summary.sessionId,
+            messageCount: record.summary.messageCount,
+            metadata: record.summary.metadata ?? null,
+        },
+        messages: record.messages.map((message) =>
+            withDurableMessageMetadata(
+                message,
+                crypto.randomUUID(),
+                (() => {
+                    const messageId = getDurableMessageId(message);
+                    return messageId ? record.feedbackByMessageId.get(messageId) : undefined;
+                })(),
+            ),
+        ),
+        events: [],
+        traces: [],
+        runs: [],
+    };
+}
+
+export function createLocalChatBackend(options: LocalChatBackendOptions = {}): ChatBackendAdapter {
+    const makeId = options.idGenerator ?? defaultId;
+    const now = options.now ?? defaultNow;
+    const sessions = new Map<string, LocalSessionRecord>();
+
+    for (const thread of options.initialThreads ?? []) {
+        sessions.set(thread.sessionId, {
+            summary: thread,
+            messages: (options.initialMessagesBySessionId?.[thread.sessionId] ?? []).map((message) =>
+                withDurableMessageMetadata(message, makeId()),
+            ),
+            feedbackByMessageId: new Map(),
+        });
+    }
+
+    const ensureSession = (sessionId?: string, input?: ThreadCreateInput) => {
+        const id = sessionId ?? input?.sessionId ?? makeId();
+        const existing = sessions.get(id);
+        if (existing) return existing;
+        const record: LocalSessionRecord = {
+            summary: createSummary(now(), id, input?.title ?? "", input?.metadata ?? null),
+            messages: [],
+            feedbackByMessageId: new Map(),
+        };
+        sessions.set(id, record);
+        return record;
+    };
+
+    const updateSummaryFromMessages = (record: LocalSessionRecord) => {
+        const userMessages = record.messages.filter((message) => message.role === "user");
+        const assistantMessages = record.messages.filter((message) => message.role === "assistant");
+        const latestUser = userMessages.at(-1);
+        const latestAssistant = assistantMessages.at(-1);
+        const latestUserText = typeof latestUser?.content === "string"
+            ? latestUser.content
+            : Array.isArray(latestUser?.content)
+                ? textParts(latestUser.content)
+                : "";
+        const latestAssistantText = typeof latestAssistant?.content === "string"
+            ? latestAssistant.content
+            : Array.isArray(latestAssistant?.content)
+                ? textParts(latestAssistant.content)
+                : "";
+
+        record.summary = {
+            ...record.summary,
+            title: record.summary.title || truncate(latestUserText, 48) || "New chat",
+            updatedAt: now().toISOString(),
+            messageCount: record.messages.length,
+            lastUserPreview: truncate(latestUserText),
+            lastAssistantPreview: truncate(latestAssistantText),
+        };
+    };
+
+    const threadManager: ChatThreadClient = {
+        async list(query) {
+            const all = [...sessions.values()]
+                .map((record) => record.summary)
+                .sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime());
+            const offset = query?.offset ?? 0;
+            const limit = query?.limit ?? all.length;
+            return {
+                threads: all.slice(offset, offset + limit),
+                total: all.length,
+            };
+        },
+        async get(sessionId) {
+            const record = sessions.get(sessionId);
+            if (!record) {
+                throw new Error(`Thread "${sessionId}" not found.`);
+            }
+            return createDetail(record);
+        },
+        async create(input) {
+            const record = ensureSession(undefined, input);
+            updateSummaryFromMessages(record);
+            return record.summary;
+        },
+        async delete(sessionId) {
+            sessions.delete(sessionId);
+        },
+        async rename(sessionId, title) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                title,
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async archive(sessionId) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                status: "archived",
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async unarchive(sessionId) {
+            const record = ensureSession(sessionId);
+            record.summary = {
+                ...record.summary,
+                status: "idle",
+                updatedAt: now().toISOString(),
+            };
+            return record.summary;
+        },
+        async setMessageFeedback(sessionId, messageId, value) {
+            const record = ensureSession(sessionId);
+            if (value) {
+                record.feedbackByMessageId.set(messageId, value);
+            } else {
+                record.feedbackByMessageId.delete(messageId);
+            }
+            record.messages = record.messages.map((message) => {
+                if (getDurableMessageId(message) !== messageId) return message;
+                return withDurableMessageMetadata(message, messageId, value ?? undefined);
+            });
+        },
+    };
+
+    return {
+        capabilities: {
+            threads: true,
+            threadDelete: true,
+            threadRename: true,
+            threadArchive: true,
+            messageFeedback: true,
+        },
+        createExecutionClient(context) {
+            return {
+                async stream(request) {
+                    const record = ensureSession(request.sessionId);
+                    record.messages = request.messages
+                        .map(toRuntimeMessage)
+                        .map((message) => withDurableMessageMetadata(
+                            message,
+                            makeId(),
+                            (() => {
+                                const messageId = getDurableMessageId(message);
+                                return messageId ? record.feedbackByMessageId.get(messageId) : undefined;
+                            })(),
+                        ));
+
+                    let assistantMessage: KognitiveMessage | undefined;
+                    if (options.stream) {
+                        const streamedMessages: KognitiveMessage[] = [];
+                        const result = await options.stream({
+                            messages: request.messages,
+                            sessionId: request.sessionId,
+                            context,
+                            emit: async (eventName, data) => {
+                                if (eventName === "custom" && data && typeof data === "object" && "role" in (data as Record<string, unknown>)) {
+                                    streamedMessages.push(withDurableMessageMetadata(data as KognitiveMessage, makeId()));
+                                }
+                                await request.onEvent(eventName, data);
+                            },
+                        });
+                        assistantMessage = result ? withDurableMessageMetadata(result, makeId()) : streamedMessages.at(-1);
+                    } else {
+                        assistantMessage = withDurableMessageMetadata(
+                            options.respond
+                                ? await options.respond({ messages: request.messages, sessionId: request.sessionId, context })
+                                : defaultAssistantReply(request.messages),
+                            makeId(),
+                        );
+                        await request.onEvent("custom", assistantMessage);
+                    }
+
+                    if (assistantMessage) {
+                        record.messages = [...record.messages, assistantMessage];
+                        updateSummaryFromMessages(record);
+                    }
+                },
+            };
+        },
+        createThreadClient() {
+            return threadManager;
+        },
+    };
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "jsx": "react-jsx",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"]
+}