@btst/stack 2.0.1 → 2.2.0

package/dist/shared/stack.Dg09R0oB.d.mts

@@ -0,0 +1,289 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { M as Message, C as Conversation, S as SerializedConversation, a as SerializedMessage } from './stack.Be1QIHEn.mjs';
+import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
+import * as better_call from 'better-call';
+import * as zod_v4_core from 'zod/v4/core';
+import * as zod from 'zod';
+import { LanguageModel, Tool } from 'ai';
+
+/**
+ * Context passed to AI Chat API hooks
+ */
+interface ChatApiContext<TBody = any, TParams = any, TQuery = any> {
+    body?: TBody;
+    params?: TParams;
+    query?: TQuery;
+    request?: Request;
+    headers?: Headers;
+    [key: string]: any;
+}
+/**
+ * Configuration hooks for AI Chat backend plugin
+ * All hooks are optional and allow consumers to customize behavior
+ */
+interface AiChatBackendHooks {
+    /**
+     * Called before processing a chat message. Return false to deny access.
+     * @param messages - Array of messages being sent
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeChat?: (messages: Array<{
+        role: string;
+        content: string;
+    }>, context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called before listing conversations. Return false to deny access.
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeListConversations?: (context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called before getting a single conversation. Return false to deny access.
+     * @param conversationId - ID of the conversation being accessed
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeGetConversation?: (conversationId: string, context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called before creating a conversation. Return false to deny access.
+     * @param data - Conversation data being created
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeCreateConversation?: (data: {
+        id?: string;
+        title?: string;
+    }, context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called before updating a conversation. Return false to deny access.
+     * @param conversationId - ID of the conversation being updated
+     * @param data - Updated conversation data
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeUpdateConversation?: (conversationId: string, data: {
+        title?: string;
+    }, context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called before deleting a conversation. Return false to deny access.
+     * @param conversationId - ID of the conversation being deleted
+     * @param context - Request context with headers, etc.
+     */
+    onBeforeDeleteConversation?: (conversationId: string, context: ChatApiContext) => Promise<boolean> | boolean;
+    /**
+     * Called after a chat message is processed successfully
+     * @param conversationId - ID of the conversation
+     * @param messages - Array of messages in the conversation
+     * @param context - Request context
+     */
+    onAfterChat?: (conversationId: string, messages: Message[], context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called after conversations are read successfully
+     * @param conversations - Array of conversations that were read
+     * @param context - Request context
+     */
+    onConversationsRead?: (conversations: Conversation[], context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called after a single conversation is read successfully
+     * @param conversation - The conversation with messages
+     * @param context - Request context
+     */
+    onConversationRead?: (conversation: Conversation & {
+        messages: Message[];
+    }, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called after a conversation is created successfully
+     * @param conversation - The created conversation
+     * @param context - Request context
+     */
+    onConversationCreated?: (conversation: Conversation, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called after a conversation is updated successfully
+     * @param conversation - The updated conversation
+     * @param context - Request context
+     */
+    onConversationUpdated?: (conversation: Conversation, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called after a conversation is deleted successfully
+     * @param conversationId - ID of the deleted conversation
+     * @param context - Request context
+     */
+    onConversationDeleted?: (conversationId: string, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when a chat operation fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onChatError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when listing conversations fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onListConversationsError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when getting a conversation fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onGetConversationError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when creating a conversation fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onCreateConversationError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when updating a conversation fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onUpdateConversationError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+    /**
+     * Called when deleting a conversation fails
+     * @param error - The error that occurred
+     * @param context - Request context
+     */
+    onDeleteConversationError?: (error: Error, context: ChatApiContext) => Promise<void> | void;
+}
+/**
+ * Plugin mode for AI Chat
+ * - 'authenticated': Conversations persisted with userId (default)
+ * - 'public': Stateless chat, no persistence (ideal for public chatbots)
+ */
+type AiChatMode = "authenticated" | "public";
+/**
+ * Configuration for AI Chat backend plugin
+ */
+interface AiChatBackendConfig {
+    /**
+     * The language model to use for chat completions.
+     * Supports any model from AI SDK providers (OpenAI, Anthropic, Google, etc.)
+     */
+    model: LanguageModel;
+    /**
+     * Plugin mode:
+     * - 'authenticated': Conversations persisted with userId (requires getUserId)
+     * - 'public': Stateless chat, no persistence (ideal for public chatbots)
+     * @default 'authenticated'
+     */
+    mode?: AiChatMode;
+    /**
+     * Extract userId from request context (authenticated mode only).
+     * Return null/undefined to deny access in authenticated mode.
+     * This function is called for all conversation operations.
+     * @example (ctx) => ctx.headers?.get('x-user-id')
+     */
+    getUserId?: (context: ChatApiContext) => string | null | undefined | Promise<string | null | undefined>;
+    /**
+     * Optional system prompt to prepend to all conversations
+     */
+    systemPrompt?: string;
+    /**
+     * Optional tools to make available to the model.
+     * Uses AI SDK v5 tool format.
+     * @see https://ai-sdk.dev/docs/ai-sdk-core/tools-and-tool-calling
+     */
+    tools?: Record<string, Tool>;
+    /**
+     * Optional hooks for customizing plugin behavior
+     */
+    hooks?: AiChatBackendHooks;
+}
+/**
+ * AI Chat backend plugin
+ * Provides API endpoints for AI-powered chat with conversation history
+ * Uses AI SDK v5 for model interactions
+ *
+ * @param config - Configuration including model, tools, and optional hooks
+ */
+declare const aiChatBackendPlugin: (config: AiChatBackendConfig) => _btst_stack_plugins_api.BackendPlugin<{
+    chat: better_call.StrictEndpoint<"/chat", {
+        method: "POST";
+        body: zod.ZodObject<{
+            messages: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+                role: zod.ZodEnum<{
+                    system: "system";
+                    user: "user";
+                    assistant: "assistant";
+                    data: "data";
+                }>;
+                content: zod.ZodString;
+                id: zod.ZodOptional<zod.ZodString>;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                role: zod.ZodEnum<{
+                    system: "system";
+                    user: "user";
+                    assistant: "assistant";
+                    data: "data";
+                }>;
+                parts: zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    text: zod.ZodOptional<zod.ZodString>;
+                }, zod_v4_core.$loose>>;
+                id: zod.ZodOptional<zod.ZodString>;
+                metadata: zod.ZodOptional<zod.ZodAny>;
+            }, zod_v4_core.$strip>]>>;
+            conversationId: zod.ZodOptional<zod.ZodString>;
+            model: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+    }, Response>;
+    createConversation: better_call.StrictEndpoint<"/chat/conversations", {
+        method: "POST";
+        body: zod.ZodObject<{
+            id: zod.ZodOptional<zod.ZodString>;
+            title: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+    }, Conversation>;
+    listConversations: better_call.StrictEndpoint<"/chat/conversations", {
+        method: "GET";
+    }, Conversation[]>;
+    getConversation: better_call.StrictEndpoint<"/chat/conversations/:id", {
+        method: "GET";
+    }, Conversation & {
+        messages: Message[];
+    }>;
+    updateConversation: better_call.StrictEndpoint<"/chat/conversations/:id", {
+        method: "PUT";
+        body: zod.ZodObject<{
+            title: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strip>;
+    }, Conversation>;
+    deleteConversation: better_call.StrictEndpoint<"/chat/conversations/:id", {
+        method: "DELETE";
+    }, {
+        success: boolean;
+    }>;
+}, {
+    getAllConversations: (userId?: string) => Promise<Conversation[]>;
+    getConversationById: (id: string) => Promise<(Conversation & {
+        messages: Message[];
+    }) | null>;
+}>;
+type AiChatApiRouter = ReturnType<ReturnType<typeof aiChatBackendPlugin>["routes"]>;
+
+type ConversationWithMessages = SerializedConversation & {
+    messages: SerializedMessage[];
+};
+declare function createAiChatQueryKeys(client: ReturnType<typeof createApiClient<AiChatApiRouter>>, headers?: HeadersInit): {
+    conversations: {
+        _def: readonly ["conversations"];
+    } & {
+        list: (() => Omit<{
+            queryKey: readonly ["conversations", "list", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedConversation[], readonly ["conversations", "list", string]>;
+        } & {
+            _def: readonly ["conversations", "list"];
+        }, "_def">) & {
+            _def: readonly ["conversations", "list"];
+        };
+        detail: ((id: string) => Omit<{
+            queryKey: readonly ["conversations", "detail", string];
+            queryFn: _tanstack_react_query.QueryFunction<ConversationWithMessages | null, readonly ["conversations", "detail", string]>;
+        } & {
+            _def: readonly ["conversations", "detail"];
+        }, "_def">) & {
+            _def: readonly ["conversations", "detail"];
+        };
+    };
+};
+
+export { createAiChatQueryKeys as c, aiChatBackendPlugin as d };
+export type { AiChatBackendHooks as A, ChatApiContext as C, AiChatMode as a, AiChatBackendConfig as b, AiChatApiRouter as e, ConversationWithMessages as f };

package/dist/shared/{stack.EhM4pmtN.d.ts → stack.GygI_T3X.d.ts}

@@ -11,8 +11,8 @@ interface ComponentLayer<TProps extends Record<string, PropValue> = Record<strin
     props: ComponentProps<TProps>;
     children: ComponentLayer[] | string | VariableReference;
 }
-type VariableValueType = 'string' | 'number' | 'boolean';
-type VariableValue<T extends VariableValueType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : never;
+type VariableValueType = 'string' | 'number' | 'boolean' | 'function';
+type VariableValue<T extends VariableValueType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'function' ? string : never;
 interface Variable<T extends VariableValueType = VariableValueType> {
     id: string;
     name: string;

package/dist/shared/{stack.DKDMI-QO.d.mts → stack.QD1y_7NY.d.cts}

@@ -48,6 +48,12 @@ type Task = {
 type ColumnWithTasks = Column & {
     tasks: Task[];
 };
+/**
+ * Board with columns and tasks
+ */
+type BoardWithColumns = Board & {
+    columns: ColumnWithTasks[];
+};
 interface SerializedTask extends Omit<Task, "createdAt" | "updatedAt" | "completedAt"> {
     completedAt?: string;
     createdAt: string;
@@ -67,4 +73,4 @@ interface SerializedBoardWithColumns extends SerializedBoard {
     columns: SerializedColumn[];
 }
 
-export type { Board as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, ColumnWithTasks as d };
+export type { BoardWithColumns as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, Board as d, ColumnWithTasks as e };

package/dist/shared/{stack.DKDMI-QO.d.ts → stack.QD1y_7NY.d.mts}

@@ -48,6 +48,12 @@ type Task = {
 type ColumnWithTasks = Column & {
     tasks: Task[];
 };
+/**
+ * Board with columns and tasks
+ */
+type BoardWithColumns = Board & {
+    columns: ColumnWithTasks[];
+};
 interface SerializedTask extends Omit<Task, "createdAt" | "updatedAt" | "completedAt"> {
     completedAt?: string;
     createdAt: string;
@@ -67,4 +73,4 @@ interface SerializedBoardWithColumns extends SerializedBoard {
     columns: SerializedColumn[];
 }
 
-export type { Board as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, ColumnWithTasks as d };
+export type { BoardWithColumns as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, Board as d, ColumnWithTasks as e };

package/dist/shared/{stack.DKDMI-QO.d.cts → stack.QD1y_7NY.d.ts}

@@ -48,6 +48,12 @@ type Task = {
 type ColumnWithTasks = Column & {
     tasks: Task[];
 };
+/**
+ * Board with columns and tasks
+ */
+type BoardWithColumns = Board & {
+    columns: ColumnWithTasks[];
+};
 interface SerializedTask extends Omit<Task, "createdAt" | "updatedAt" | "completedAt"> {
     completedAt?: string;
     createdAt: string;
@@ -67,4 +73,4 @@ interface SerializedBoardWithColumns extends SerializedBoard {
     columns: SerializedColumn[];
 }
 
-export type { Board as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, ColumnWithTasks as d };
+export type { BoardWithColumns as B, Column as C, Priority as P, SerializedBoardWithColumns as S, Task as T, SerializedBoard as a, SerializedColumn as b, SerializedTask as c, Board as d, ColumnWithTasks as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btst/stack",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "A composable, plugin-based library for building full-stack applications.",
   "repository": {
     "type": "git",

package/src/__tests__/stack-api.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import { stack } from "../api";
+import { defineBackendPlugin } from "../plugins/api";
+import { createDbPlugin } from "@btst/db";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import type { Adapter, DatabaseDefinition } from "@btst/db";
+import { blogBackendPlugin } from "../plugins/blog/api";
+import { kanbanBackendPlugin } from "../plugins/kanban/api";
+
+const testAdapter = (db: DatabaseDefinition): Adapter =>
+	createMemoryAdapter(db)({});
+
+/**
+ * A minimal plugin with no `api` factory, to verify backward compatibility.
+ */
+const noApiPlugin = defineBackendPlugin({
+	name: "no-api",
+	dbPlugin: createDbPlugin("no-api", {}),
+	routes: () => ({}),
+});
+
+describe("stack.api surface", () => {
+	it("exposes adapter on the returned backend", () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: { blog: blogBackendPlugin() },
+			adapter: testAdapter,
+		});
+
+		expect(backend.adapter).toBeDefined();
+		expect(typeof backend.adapter.findMany).toBe("function");
+		expect(typeof backend.adapter.findOne).toBe("function");
+		expect(typeof backend.adapter.create).toBe("function");
+	});
+
+	it("exposes typed api namespace for plugins with api factory", () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: { blog: blogBackendPlugin() },
+			adapter: testAdapter,
+		});
+
+		expect(backend.api).toBeDefined();
+		expect(backend.api.blog).toBeDefined();
+		expect(typeof backend.api.blog.getAllPosts).toBe("function");
+		expect(typeof backend.api.blog.getPostBySlug).toBe("function");
+		expect(typeof backend.api.blog.getAllTags).toBe("function");
+	});
+
+	it("exposes kanban api namespace", () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: { kanban: kanbanBackendPlugin() },
+			adapter: testAdapter,
+		});
+
+		expect(backend.api.kanban).toBeDefined();
+		expect(typeof backend.api.kanban.getAllBoards).toBe("function");
+		expect(typeof backend.api.kanban.getBoardById).toBe("function");
+	});
+
+	it("plugins without api factory are not present in api", () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: { noApi: noApiPlugin },
+			adapter: testAdapter,
+		});
+
+		expect((backend.api as any).noApi).toBeUndefined();
+	});
+
+	it("api functions are bound to the shared adapter and return real data", async () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: { blog: blogBackendPlugin() },
+			adapter: testAdapter,
+		});
+
+		// Seed data via adapter directly
+		await backend.adapter.create({
+			model: "post",
+			data: {
+				title: "Hello World",
+				slug: "hello-world",
+				content: "Content",
+				excerpt: "",
+				published: true,
+				tags: [],
+				createdAt: new Date(),
+				updatedAt: new Date(),
+			},
+		});
+
+		// Retrieve via stack.api
+		const posts = await backend.api.blog.getAllPosts();
+		expect(posts.items).toHaveLength(1);
+		expect(posts.items[0]!.slug).toBe("hello-world");
+
+		// Verify same adapter - data is shared
+		const bySlug = await backend.api.blog.getPostBySlug("hello-world");
+		expect(bySlug).not.toBeNull();
+		expect(bySlug!.title).toBe("Hello World");
+	});
+
+	it("combines multiple plugins in a single stack call", () => {
+		const backend = stack({
+			basePath: "/api",
+			plugins: {
+				blog: blogBackendPlugin(),
+				kanban: kanbanBackendPlugin(),
+			},
+			adapter: testAdapter,
+		});
+
+		expect(typeof backend.api.blog.getAllPosts).toBe("function");
+		expect(typeof backend.api.kanban.getAllBoards).toBe("function");
+	});
+});

package/src/api/index.ts

@@ -3,6 +3,7 @@ import type {
 	BackendLibConfig,
 	BackendLib,
 	PrefixedPluginRoutes,
+	PluginApis,
 	StackContext,
 } from "../types";
 import { defineDb } from "@btst/db";
@@ -33,7 +34,9 @@ export function stack<
 	TPlugins extends Record<string, any>,
 	TRoutes extends
 		PrefixedPluginRoutes<TPlugins> = PrefixedPluginRoutes<TPlugins>,
->(config: BackendLibConfig<TPlugins>): BackendLib<TRoutes> {
+>(
+	config: BackendLibConfig<TPlugins>,
+): BackendLib<TRoutes, PluginApis<TPlugins>> {
 	const { plugins, adapter, dbSchema, basePath } = config;
 
 	// Collect all routes from all plugins with type-safe prefixed keys
@@ -67,6 +70,14 @@ export function stack<
 		}
 	}
 
+	// Build the typed api surface by calling each plugin's api factory
+	const pluginApis = {} as PluginApis<TPlugins>;
+	for (const [pluginKey, plugin] of Object.entries(plugins)) {
+		if (plugin.api) {
+			(pluginApis as any)[pluginKey] = plugin.api(adapterInstance);
+		}
+	}
+
 	// Create the composed router
 	const router = createRouter(allRoutes, {
 		basePath: basePath,
@@ -76,6 +87,8 @@ export function stack<
 		handler: router.handler,
 		router,
 		dbSchema: betterDbSchema,
+		adapter: adapterInstance,
+		api: pluginApis,
 	};
 }
 
@@ -83,5 +96,6 @@ export type {
 	BackendPlugin,
 	BackendLibConfig,
 	BackendLib,
+	PluginApis,
 	StackContext,
 } from "../types";

package/src/plugins/ai-chat/__tests__/getters.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { defineDb } from "@btst/db";
+import type { Adapter } from "@btst/db";
+import { aiChatSchema } from "../db";
+import { getAllConversations, getConversationById } from "../api/getters";
+
+const createTestAdapter = (): Adapter => {
+	const db = defineDb({}).use(aiChatSchema);
+	return createMemoryAdapter(db)({});
+};
+
+async function createConversation(
+	adapter: Adapter,
+	title: string,
+	userId?: string,
+): Promise<any> {
+	return adapter.create({
+		model: "conversation",
+		data: {
+			title,
+			...(userId ? { userId } : {}),
+			createdAt: new Date(),
+			updatedAt: new Date(),
+		},
+	});
+}
+
+describe("ai-chat getters", () => {
+	let adapter: Adapter;
+
+	beforeEach(() => {
+		adapter = createTestAdapter();
+	});
+
+	describe("getAllConversations", () => {
+		it("returns empty array when no conversations exist", async () => {
+			const convs = await getAllConversations(adapter);
+			expect(convs).toEqual([]);
+		});
+
+		it("returns all conversations sorted by updatedAt desc", async () => {
+			await createConversation(adapter, "First");
+			await createConversation(adapter, "Second");
+
+			const convs = await getAllConversations(adapter);
+			expect(convs).toHaveLength(2);
+		});
+
+		it("filters conversations by userId", async () => {
+			await createConversation(adapter, "Alice Conv", "user-alice");
+			await createConversation(adapter, "Bob Conv", "user-bob");
+			await createConversation(adapter, "No User Conv");
+
+			const aliceConvs = await getAllConversations(adapter, "user-alice");
+			expect(aliceConvs).toHaveLength(1);
+			expect(aliceConvs[0]!.title).toBe("Alice Conv");
+
+			const allConvs = await getAllConversations(adapter);
+			expect(allConvs).toHaveLength(3);
+		});
+	});
+
+	describe("getConversationById", () => {
+		it("returns null when conversation does not exist", async () => {
+			const conv = await getConversationById(adapter, "nonexistent");
+			expect(conv).toBeNull();
+		});
+
+		it("returns conversation with messages", async () => {
+			const conv = (await createConversation(adapter, "My Chat")) as any;
+
+			await adapter.create({
+				model: "message",
+				data: {
+					conversationId: conv.id,
+					role: "user",
+					content: JSON.stringify([{ type: "text", text: "Hello!" }]),
+					createdAt: new Date(Date.now() - 1000),
+				},
+			});
+			await adapter.create({
+				model: "message",
+				data: {
+					conversationId: conv.id,
+					role: "assistant",
+					content: JSON.stringify([{ type: "text", text: "Hi there!" }]),
+					createdAt: new Date(),
+				},
+			});
+
+			const result = await getConversationById(adapter, conv.id);
+			expect(result).not.toBeNull();
+			expect(result!.id).toBe(conv.id);
+			expect(result!.title).toBe("My Chat");
+			expect(result!.messages).toHaveLength(2);
+			expect(result!.messages[0]!.role).toBe("user");
+			expect(result!.messages[1]!.role).toBe("assistant");
+		});
+
+		it("returns conversation with empty messages array if none exist", async () => {
+			const conv = (await createConversation(adapter, "Empty Chat")) as any;
+
+			const result = await getConversationById(adapter, conv.id);
+			expect(result).not.toBeNull();
+			expect(result!.messages).toEqual([]);
+		});
+	});
+});