@btst/stack 4.4.0 → 4.5.1

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

@@ -56,6 +56,85 @@ describe("public context compaction", () => {
 		expect(summarize).toHaveBeenCalledOnce();
 	});
 
+	it("counts image content separately from inline bytes and keeps tool output as text", () => {
+		const inline = {
+			role: "user",
+			parts: [
+				{
+					type: "file",
+					mediaType: "image/png",
+					url: "data:image/png;base64," + "A".repeat(100_000),
+				},
+			],
+		};
+		const remote = {
+			role: "user",
+			parts: [
+				{
+					type: "file",
+					mediaType: "image/png",
+					url: "https://example.org/image.png",
+				},
+			],
+		};
+		expect(estimateContextTokens([inline])).toBe(
+			estimateContextTokens([remote]),
+		);
+		expect(estimateContextTokens([inline])).toBeGreaterThanOrEqual(4096);
+		const toolOutput = {
+			role: "tool",
+			content: [
+				{ type: "tool-result", output: { type: "json", value: inline } },
+			],
+		};
+		expect(estimateContextTokens([toolOutput])).toBeGreaterThan(30_000);
+	});
+
+	it("sends older images as vision input when summarizing instead of serialized bytes", async () => {
+		const png =
+			"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jr1sAAAAASUVORK5CYII=";
+		const original = [
+			message("u1", "user", "Remember the number in this image"),
+		];
+		original[0]!.parts.push({ type: "file", mediaType: "image/png", url: png });
+		const model = new MockLanguageModelV2({
+			doGenerate: async ({ prompt }) => ({
+				content: [
+					{
+						type: "text",
+						text: JSON.stringify(prompt).includes('"type":"file"')
+							? "The image shows verification number 917."
+							: "The user wants to remember the image number.",
+					},
+				],
+				finishReason: "stop",
+				usage: { inputTokens: 100, outputTokens: 20, totalTokens: 120 },
+				warnings: [],
+			}),
+		});
+		const before = structuredClone(original);
+		const summary = await createSummarizer(
+			model,
+			16_384,
+		)({ messages: original });
+		expect(summary).toContain("917");
+		expect(
+			model.doGenerateCalls.some((call) =>
+				call.prompt.some(
+					(message) =>
+						message.role === "user" &&
+						message.content.some(
+							(part) => part.type === "file" && part.mediaType === "image/png",
+						),
+				),
+			),
+		).toBe(true);
+		expect(JSON.stringify(model.doGenerateCalls)).not.toContain(
+			"data:image/png;base64",
+		);
+		expect(original).toEqual(before);
+	});
+
 	it("reuses a checkpoint only while all summarized messages are unchanged", () => {
 		const checkpoint = captureContextCheckpoint(history, "summary", "a1");
 		expect(contextRequest(history, checkpoint)).toEqual({
@@ -219,25 +298,6 @@ describe("public context compaction", () => {
 					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();