@btst/stack 4.3.0 → 4.5.0

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

@@ -14,18 +14,53 @@ import {
 import { aiChatPermissions } from "../permissions";
 import type { Conversation, Message } from "../types";
 
-const { streamText } = vi.hoisted(() => ({
+const { streamText, completions } = vi.hoisted(() => ({
+	completions: [] as Array<
+		NonNullable<
+			Parameters<typeof import("ai").createUIMessageStream>[0]["onFinish"]
+		>
+	>,
 	streamText: vi.fn(() => ({
+		toUIMessageStream: () =>
+			new ReadableStream({
+				start(controller) {
+					controller.close();
+				},
+			}),
 		toUIMessageStreamResponse: () => new Response("stream", { status: 200 }),
 	})),
 }));
 
-vi.mock("ai", async (importOriginal) => ({
-	...(await importOriginal<typeof import("ai")>()),
-	convertToModelMessages: (messages: unknown) => messages,
-	stepCountIs: () => () => false,
-	streamText,
-}));
+vi.mock("ai", async (importOriginal) => {
+	const original = await importOriginal<typeof import("ai")>();
+	return {
+		...original,
+		createUIMessageStream: (
+			options: Parameters<typeof original.createUIMessageStream>[0],
+		) => {
+			if (options.onFinish) completions.push(options.onFinish);
+			return original.createUIMessageStream(options);
+		},
+		convertToModelMessages: (messages: unknown) => messages,
+		stepCountIs: () => () => false,
+		streamText,
+	};
+});
+
+function completion(text: string) {
+	const responseMessage = {
+		id: "server-response",
+		role: "assistant" as const,
+		parts: [{ type: "text" as const, text }],
+	};
+	return {
+		responseMessage,
+		messages: [responseMessage],
+		isAborted: false,
+		isContinuation: false,
+		finishReason: "stop" as const,
+	};
+}
 
 type Identity = { id: string; role: "user" | "admin" };
 
@@ -173,7 +208,10 @@ async function seedMessage(
 }
 
 describe("AI Chat operation authorization", () => {
-	beforeEach(() => streamText.mockClear());
+	beforeEach(() => {
+		streamText.mockClear();
+		completions.length = 0;
+	});
 
 	it("publishes one executable inventory for every maintained transport", () => {
 		const plugin = aiChatBackendPlugin({ model });
@@ -815,15 +853,7 @@ describe("AI Chat operation authorization", () => {
 		await app
 			.forRequest(request("/chat", { identity: owner }))
 			.operations.aiChat.startStream(messageBody);
-		const finish = (
-			streamText.mock.calls as unknown as Array<
-				[
-					{
-						onFinish: (completion: { text: string }) => Promise<void>;
-					},
-				]
-			>
-		)[0]?.[0].onFinish;
+		const finish = completions[0];
 		expect(finish).toBeDefined();
 		if (!finish) throw new Error("Missing stream completion callback");
 		const adapterConfig = app.adapter.options?.adapterConfig;
@@ -831,7 +861,7 @@ describe("AI Chat operation authorization", () => {
 		if (!adapterConfig) throw new Error("Missing adapter config");
 		adapterConfig.transaction = false;
 
-		await finish({ text: "unsafe answer" });
+		await finish(completion("unsafe answer"));
 
 		expect(
 			await app.adapter.count({
@@ -876,6 +906,7 @@ describe("AI Chat operation authorization", () => {
 			identity: z.object({ id: z.string(), role: z.enum(["user", "admin"]) }),
 			permissions: [aiChatPermissions] as const,
 			rules: ({ aiChat }) => [
+				aiChat.conversation.read.allow(),
 				aiChat.stream.start.allow(),
 				aiChat.message.retry.when(({ facts }) => {
 					observed.push({ intent: "retry", messageId: facts.messageId });
@@ -959,6 +990,7 @@ describe("AI Chat operation authorization", () => {
 			identity: z.object({ id: z.string(), role: z.enum(["user", "admin"]) }),
 			permissions: [aiChatPermissions] as const,
 			rules: ({ aiChat }) => [
+				aiChat.conversation.read.allow(),
 				aiChat.stream.start.allow(),
 				aiChat.message.retry.allow(),
 				aiChat.message.edit.when(() => false),
@@ -1030,6 +1062,7 @@ describe("AI Chat operation authorization", () => {
 			identity: z.object({ id: z.string(), role: z.enum(["user", "admin"]) }),
 			permissions: [aiChatPermissions] as const,
 			rules: ({ aiChat }) => [
+				aiChat.conversation.read.allow(),
 				aiChat.stream.start.allow(),
 				aiChat.message.send.allow(),
 				aiChat.message.retry.when(({ facts }) => observedRetry(facts)),
@@ -1490,7 +1523,7 @@ describe("AI Chat operation authorization", () => {
 		expect(before).not.toHaveBeenCalled();
 		expect(streamText).not.toHaveBeenCalled();
 		expect(await app.adapter.count({ model: "message" })).toBe(0);
-		expect(onError).toHaveBeenCalledOnce();
+		expect(onError).not.toHaveBeenCalled();
 	});
 
 	it("rechecks a missing requested conversation before entering hooks", async () => {
@@ -1962,20 +1995,13 @@ describe("AI Chat operation authorization", () => {
 		await app
 			.forRequest(request("/first", { identity: owner }))
 			.operations.aiChat.startStream(input);
-		const streamCalls = streamText.mock.calls as unknown as Array<
-			[
-				{
-					onFinish: (completion: { text: string }) => Promise<void>;
-				},
-			]
-		>;
-		const firstFinish = streamCalls[0]?.[0].onFinish;
+		const firstFinish = completions[0];
 		await app
 			.forRequest(request("/second", { identity: owner }))
 			.operations.aiChat.startStream(input);
-		const secondFinish = streamCalls[1]?.[0].onFinish;
+		const secondFinish = completions[1];
 
-		await firstFinish?.({ text: "stale answer" });
+		await firstFinish?.(completion("stale answer"));
 		expect(
 			await app.adapter.count({
 				model: "message",
@@ -1984,7 +2010,7 @@ describe("AI Chat operation authorization", () => {
 		).toBe(0);
 		expect(onErrorChat).toHaveBeenCalledOnce();
 
-		await secondFinish?.({ text: "current answer" });
+		await secondFinish?.(completion("current answer"));
 		const assistants = await app.adapter.findMany<Message>({
 			model: "message",
 			where: [{ field: "role", value: "assistant", operator: "eq" }],

package/src/plugins/ai-chat/__tests__/classnames-overrides.test.tsx

@@ -161,6 +161,31 @@ function query(selector: string): HTMLElement {
 }
 
 describe("ai-chat classNames overrides (issue #36)", () => {
+	it("labels interrupted responses and stops unfinished tool indicators", async () => {
+		await render(
+			<ChatMessage
+				message={{
+					...assistantMessage,
+					metadata: { interrupted: true },
+					parts: [
+						...assistantMessage.parts,
+						{
+							type: "tool-inspect",
+							toolCallId: "pending",
+							state: "input-available",
+							input: {},
+						},
+					],
+				}}
+			/>,
+		);
+		expect(query('[data-testid="chat-interrupted"]').textContent).toBe(
+			"Response interrupted",
+		);
+		expect(container.textContent).not.toContain("Executing...");
+		expect(container.querySelector(".animate-spin")).toBeNull();
+	});
+
 	it("applies message, userMessage and assistantMessage to a user message", async () => {
 		await render(<ChatMessage message={userMessage} />);
 

package/src/plugins/ai-chat/__tests__/client-sweep.test.tsx

@@ -301,6 +301,107 @@ function menuItem(text: string) {
 }
 
 describe("AI Chat permissions", () => {
+	it("shows authorized compaction status and ignores browser checkpoints", async () => {
+		let chatOptions: any;
+		const messages = [
+			{ id: "u1", role: "user", parts: [{ type: "text", text: "Hello" }] },
+		];
+		mocks.useAiChatIdentityPartition.mockReturnValue({
+			id: "owner-1",
+			role: "user",
+		});
+		mocks.useChat.mockImplementation((options) => {
+			chatOptions = options;
+			return {
+				messages,
+				status: "streaming",
+				error: null,
+				sendMessage: vi.fn(),
+				setMessages: vi.fn(),
+				regenerate: vi.fn(),
+				addToolOutput: vi.fn(),
+				stop: vi.fn(),
+			};
+		});
+		await render(<ChatInterface id={conversation.id} />);
+		await act(async () => {
+			chatOptions.transport.prepareSendMessagesRequest({ messages });
+			chatOptions.onData({
+				type: "data-context-status",
+				data: { compacting: true },
+			});
+			chatOptions.onData({
+				type: "data-context-checkpoint",
+				data: { summary: "Do not trust this", throughMessageId: "u1" },
+			});
+		});
+		expect(container.textContent).toContain("Summarizing");
+		let next: any;
+		await act(async () => {
+			next = chatOptions.transport.prepareSendMessagesRequest({ messages });
+		});
+		expect(next.body.messages).toEqual(messages);
+		expect(next.body).not.toHaveProperty("contextSummary");
+	});
+
+	it.each([
+		{ interrupted: true, state: "output-available" },
+		{ interrupted: false, state: "input-available" },
+		{ interrupted: false, state: "input-streaming" },
+	])(
+		"restores interrupted or abandoned $state tools without a live callback",
+		async ({ interrupted, state }) => {
+			const setMessages = vi.fn();
+			mocks.useChat.mockReturnValue({
+				messages: [],
+				status: "ready",
+				error: null,
+				sendMessage: vi.fn(),
+				setMessages,
+				regenerate: vi.fn(),
+				addToolOutput: vi.fn(),
+				stop: vi.fn(),
+			});
+			const parts = [
+				{ type: "text", text: "Partial response" },
+				{
+					type: "tool-inspect",
+					toolCallId: "call",
+					state,
+					input: {},
+					...(state === "output-available" ? { output: "saved result" } : {}),
+				},
+			];
+			mocks.useConversation.mockReturnValue({
+				conversation: {
+					...conversation,
+					messages: [
+						{
+							id: "answer",
+							conversationId: conversation.id,
+							role: "assistant",
+							content: JSON.stringify(parts),
+							interrupted,
+							createdAt: conversation.createdAt,
+						},
+					],
+				},
+				isLoading: false,
+				error: null,
+				refetch: vi.fn(),
+			});
+			await render(<ChatInterface id={conversation.id} />);
+			expect(setMessages).toHaveBeenCalledWith([
+				{
+					id: "answer",
+					role: "assistant",
+					parts,
+					metadata: { interrupted: true },
+				},
+			]);
+		},
+	);
+
 	it("uses the resolved AI Chat endpoint for the browser stream transport", async () => {
 		const observeRuntime = vi.fn();
 		const stack = createClientStack({

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

@@ -0,0 +1,272 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { MockLanguageModelV2 } from "ai/test";
+import { simulateReadableStream, type ModelMessage, type UIMessage } from "ai";
+import { createBackendStack } from "../../../api";
+import { aiChatBackendPlugin } from "../api";
+import {
+	compactConversation,
+	createStepCompactor,
+	createSummarizer,
+	estimateContextTokens,
+} from "../api/compaction";
+import {
+	captureContextCheckpoint,
+	contextRequest,
+} from "../client/context-checkpoint";
+
+const message = (
+	id: string,
+	role: "user" | "assistant",
+	text: string,
+): UIMessage => ({ id, role, parts: [{ type: "text", text }] });
+const history = [
+	message("u1", "user", "Remember my goal. " + "research ".repeat(2000)),
+	message("a1", "assistant", "https://example.org/source; evidence uncertain"),
+	message("u2", "user", "Compare the alternatives"),
+	message("a2", "assistant", "A comparison"),
+	message("u3", "user", "What was the uncertainty?"),
+];
+
+describe("public context compaction", () => {
+	it("uses size rather than message count and leaves the transcript untouched", async () => {
+		const summarize = vi
+			.fn()
+			.mockResolvedValue("Goal, sources, and uncertainty");
+		const original = structuredClone(history);
+		const result = await compactConversation({
+			messages: history,
+			budget: 3200,
+			overhead: "rules",
+			summarize,
+		});
+		expect(result.throughMessageId).toBe("a1");
+		expect(result.messages.map((m) => m.id)).toEqual(["u2", "a2", "u3"]);
+		expect(summarize.mock.calls[0]?.[0].messages).toEqual(history.slice(0, 2));
+		expect(history).toEqual(original);
+		const short = Array.from({ length: 100 }, (_, i) =>
+			message(String(i), i % 2 ? "assistant" : "user", "Hi"),
+		);
+		await compactConversation({
+			messages: short,
+			budget: 10000,
+			overhead: "",
+			summarize,
+		});
+		expect(summarize).toHaveBeenCalledOnce();
+	});
+
+	it("reuses a checkpoint only while all summarized messages are unchanged", () => {
+		const checkpoint = captureContextCheckpoint(history, "summary", "a1");
+		expect(contextRequest(history, checkpoint)).toEqual({
+			messages: history.slice(2),
+			contextSummary: "summary",
+		});
+		const edited = [
+			message("u1", "user", "Different goal"),
+			...history.slice(1),
+		];
+		expect(contextRequest(edited, checkpoint)).toEqual({ messages: edited });
+		expect(contextRequest(history.slice(0, 1), checkpoint)).toEqual({
+			messages: history.slice(0, 1),
+		});
+		expect(contextRequest([], checkpoint)).toEqual({ messages: [] });
+	});
+
+	it("retains tool pairs, recent questions, and system instructions between steps", async () => {
+		const messages: ModelMessage[] = [
+			{ role: "system", content: "Keep original instructions" },
+			{ role: "user", content: "Read this profile" },
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool-call",
+						toolName: "readPage",
+						toolCallId: "read-1",
+						input: { path: "/one" },
+					},
+				],
+			},
+			{
+				role: "tool",
+				content: [
+					{
+						type: "tool-result",
+						toolName: "readPage",
+						toolCallId: "read-1",
+						output: { type: "text", value: "evidence ".repeat(10000) },
+					},
+				],
+			},
+		];
+		const summarize = vi
+			.fn()
+			.mockResolvedValue(
+				"Source /one; preclinical evidence; uncertainty remains.",
+			);
+		const status = vi.fn();
+		const prepare = createStepCompactor({
+			budget: 3000,
+			overhead: "",
+			summarize,
+			onCompacting: status,
+		});
+		const result = await prepare({ messages });
+		expect(result.messages[0]).toEqual(messages[0]);
+		expect(result.messages[1]).toEqual(messages[1]);
+		expect(result.messages[2]).toEqual(messages[2]);
+		expect(JSON.stringify(result.messages[3])).toContain(
+			'"toolCallId":"read-1"',
+		);
+		expect(JSON.stringify(result.messages[3])).toContain(
+			"preclinical evidence",
+		);
+		expect(estimateContextTokens(result.messages)).toBeLessThan(3000);
+		await prepare({
+			messages: [...messages, { role: "assistant", content: "Answer" }],
+		});
+		expect(summarize).toHaveBeenCalledOnce();
+		expect(status.mock.calls).toEqual([[true], [false]]);
+	});
+
+	it("does not discard context when summarization fails", async () => {
+		const original = structuredClone(history);
+		await expect(
+			compactConversation({
+				messages: history,
+				budget: 3000,
+				overhead: "",
+				summarize: async () => {
+					throw new Error("provider unavailable");
+				},
+			}),
+		).rejects.toThrow("provider unavailable");
+		expect(history).toEqual(original);
+	});
+
+	it("chunks oversized Unicode histories and includes earlier summaries", async () => {
+		const model = new MockLanguageModelV2({
+			doGenerate: async () => ({
+				content: [{ type: "text", text: "Retained facts" }],
+				finishReason: "stop",
+				usage: { inputTokens: 100, outputTokens: 10, totalTokens: 110 },
+				warnings: [],
+			}),
+		});
+		await createSummarizer(model, 4096)({ text: "研究".repeat(4000) });
+		expect(model.doGenerateCalls.length).toBeGreaterThan(1);
+		for (const call of model.doGenerateCalls)
+			expect(estimateContextTokens(call.prompt)).toBeLessThan(4096);
+		expect(JSON.stringify(model.doGenerateCalls[1]?.prompt)).toContain(
+			"Retained facts",
+		);
+	});
+
+	it("streams status/checkpoints and continues with a compact model prompt", async () => {
+		const model = new MockLanguageModelV2({
+			doGenerate: async () => ({
+				content: [
+					{
+						type: "text",
+						text: "Earlier goal and uncertain evidence: https://example.org/source",
+					},
+				],
+				finishReason: "stop",
+				usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+				warnings: [],
+			}),
+			doStream: async () => ({
+				stream: simulateReadableStream({
+					chunks: [
+						{ type: "text-start" as const, id: "t" },
+						{
+							type: "text-delta" as const,
+							id: "t",
+							delta: "Continuing the conversation.",
+						},
+						{ type: "text-end" as const, id: "t" },
+						{
+							type: "finish" as const,
+							finishReason: "stop" as const,
+							usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+						},
+					],
+					initialDelayInMs: null,
+					chunkDelayInMs: null,
+				}),
+			}),
+		});
+		const before = vi.fn();
+		const app = createBackendStack({
+			basePath: "/api",
+			plugins: {
+				aiChat: aiChatBackendPlugin({
+					model,
+					access: "public",
+					systemPrompt: "Original rules",
+					compaction: { contextWindowTokens: 4096 },
+					hooks: { onBeforeChat: before },
+				}),
+			},
+			adapter: (db) => createMemoryAdapter(db)({}),
+		});
+		const send = (body: unknown) =>
+			app.handler(
+				new Request("http://localhost/api/chat", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify(body),
+				}),
+			);
+		const attachment = await send({
+			messages: [
+				{
+					id: "file",
+					role: "user",
+					parts: [
+						{
+							type: "file",
+							mediaType: "image/png",
+							url: "https://example.org/image.png",
+						},
+					],
+				},
+			],
+		});
+		expect(attachment.status).toBe(400);
+		expect(await attachment.text()).toContain("text-only");
+		expect(model.doGenerateCalls).toHaveLength(0);
+		expect(model.doStreamCalls).toHaveLength(0);
+		const response = await send({ messages: history });
+		expect(response.status).toBe(200);
+		const text = await response.text();
+		expect(text).toContain('"data-context-status"');
+		expect(text).toContain('"throughMessageId":"a1"');
+		expect(text).toContain("Continuing the conversation.");
+		expect(before).toHaveBeenCalledOnce();
+		expect(JSON.stringify(model.doStreamCalls[0]?.prompt)).toContain(
+			"Original rules",
+		);
+		expect(JSON.stringify(model.doStreamCalls[0]?.prompt)).not.toContain(
+			"research ".repeat(100),
+		);
+		const checkpointLine = text
+			.split("\n")
+			.find((line) => line.includes('"data-context-checkpoint"'))!;
+		const checkpoint = JSON.parse(checkpointLine.slice(6)).data;
+		const next = await send({
+			messages: history.slice(2),
+			contextSummary: checkpoint.summary,
+		});
+		await next.text();
+		expect(JSON.stringify(model.doStreamCalls.at(-1)?.prompt)).toContain(
+			"Earlier goal",
+		);
+		const oversized = await send({
+			messages: [message("large", "user", "research ".repeat(4000))],
+		});
+		expect(await oversized.text()).toContain("Shorten it and retry");
+		expect(model.doStreamCalls).toHaveLength(2);
+	});
+});