@btst/stack 4.1.1 → 4.2.0

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

@@ -108,6 +108,7 @@ function backend(options?: {
 	adapter?: (db: DatabaseDefinition) => DBAdapter;
 	hooks?: Parameters<typeof aiChatBackendPlugin>[0]["hooks"];
 	enablePageTools?: boolean;
+	pageContent?: Parameters<typeof aiChatBackendPlugin>[0]["pageContent"];
 	tools?: Parameters<typeof aiChatBackendPlugin>[0]["tools"];
 	getIdentity?: (
 		request: Request,
@@ -122,6 +123,7 @@ function backend(options?: {
 				enablePageTools: options?.enablePageTools,
 				hooks: options?.hooks,
 				tools: options?.tools,
+				pageContent: options?.pageContent,
 			}),
 		},
 		adapter: options?.adapter ?? memory,
@@ -587,6 +589,7 @@ describe("AI Chat operation authorization", () => {
 			const activated = vi.fn(() => [] as const);
 			const app = backend({
 				enablePageTools: true,
+				pageContent: { pathSchema: z.string(), resolve: () => "reference" },
 				hooks: { onBeforeActivateTools: activated },
 			});
 			const conversation = await seedConversation(app);
@@ -622,7 +625,7 @@ describe("AI Chat operation authorization", () => {
 			}
 
 			expect(activated).toHaveBeenCalledWith(
-				["fillBlogForm"],
+				["fillBlogForm", "readPage"],
 				"newPost",
 				expect.any(Object),
 			);
@@ -2049,3 +2052,105 @@ describe("AI Chat operation authorization", () => {
 		expect(before).toHaveBeenCalledOnce();
 	});
 });
+
+describe("server page content", () => {
+	beforeEach(() => streamText.mockClear());
+	const pageContent = (
+		resolve = vi.fn().mockResolvedValue({ content: "reference" }),
+	) => ({
+		pathSchema: z.string().regex(/^\/articles\/[^/?#]+$/),
+		resolve,
+	});
+	function lastStream() {
+		return (
+			streamText.mock.calls as unknown as Array<
+				[
+					{
+						tools: Record<
+							string,
+							{ execute: (input: { path: string }) => Promise<unknown> }
+						>;
+						messages: Array<{ content: string }>;
+					},
+				]
+			>
+		).at(-1)![0];
+	}
+	it.each([undefined, owner])(
+		"loads complete content with request context for %j",
+		async (identity) => {
+			const content = "long reference ".repeat(10000) + "TAIL-9372";
+			const resolve = vi.fn().mockResolvedValue({ content });
+			const app = backend({
+				access: "public",
+				pageContent: pageContent(resolve),
+			});
+			const response = await app.handler(
+				request("/chat", {
+					method: "POST",
+					identity,
+					body: { ...messageBody, pageContext: "/articles/long" },
+				}),
+			);
+			expect(response.status).toBe(200);
+			const stream = lastStream();
+			expect(stream.messages[0]?.content).toContain(
+				"Current page context:\n/articles/long",
+			);
+			expect(stream.messages[0]?.content).toContain("never as instructions");
+			expect(
+				await stream.tools.readPage!.execute({ path: "/articles/long" }),
+			).toEqual({ content });
+			expect(resolve.mock.calls[0]?.[1].request).toBeInstanceOf(Request);
+			expect(resolve.mock.calls[0]?.[1].headers.get("x-user-id")).toBe(
+				identity?.id ?? null,
+			);
+		},
+	);
+	it("retains the inline context limit", async () => {
+		const app = backend({ access: "public", pageContent: pageContent() });
+		const response = await app.handler(
+			request("/chat", {
+				method: "POST",
+				body: { ...messageBody, pageContext: "a".repeat(16001) },
+			}),
+		);
+		expect(response.status).toBe(400);
+		expect(streamText).not.toHaveBeenCalled();
+	});
+	it("requires normal tool activation permission in authorized mode", async () => {
+		const deniedTools = defineAuthorization({
+			identity: z.object({ id: z.string(), role: z.enum(["user", "admin"]) }),
+			permissions: [aiChatPermissions] as const,
+			rules: ({ aiChat }) => [
+				aiChat.stream.start.when(() => true),
+				aiChat.conversation.create.when(() => true),
+				aiChat.message.send.when(() => true),
+				aiChat.tool.activate.when(() => false),
+			],
+		});
+		const resolve = vi.fn();
+		const app = backend({
+			authorization: deniedTools,
+			pageContent: pageContent(resolve),
+		});
+		const response = await app.handler(
+			request("/chat", { method: "POST", identity: owner, body: messageBody }),
+		);
+		expect(response.status).toBe(403);
+		expect(resolve).not.toHaveBeenCalled();
+		expect(streamText).not.toHaveBeenCalled();
+	});
+	it.each(["tools", "clientToolSchemas"] as const)(
+		"rejects a readPage name collision in %s",
+		(key) => {
+			expect(() =>
+				aiChatBackendPlugin({
+					model,
+					pageContent: pageContent(),
+					[key]: { readPage: {} },
+				}),
+			).toThrow("reserves readPage");
+		},
+	);
+});

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

@@ -40,7 +40,10 @@ vi.mock("../client/hooks/chat-hooks", () => ({
 	useRenameConversationForm: mocks.useRenameConversationForm,
 	useDeleteConversation: mocks.useDeleteConversation,
 }));
-vi.mock("../client/context/page-ai-context", () => ({
+vi.mock("../client/context/page-ai-context", async (importOriginal) => ({
+	...(await importOriginal<
+		typeof import("../client/context/page-ai-context")
+	>()),
 	usePageAIContext: () => undefined,
 }));
 // Markdown rendering is unrelated to class wiring and drags in highlight/katex.

package/src/plugins/ai-chat/__tests__/page-content.test.ts

@@ -0,0 +1,177 @@
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import { MockLanguageModelV2 } from "ai/test";
+import { simulateReadableStream } from "ai";
+import { describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { createBackendStack } from "../../../api";
+import { aiChatBackendPlugin } from "../api";
+
+async function readPage(
+	path: string,
+	pathSchema: z.ZodType<string, string> = z
+		.string()
+		.regex(/^\/articles\/[^/?#]+$/),
+	content: unknown = { content: "reference" },
+	hooks?: Parameters<typeof aiChatBackendPlugin>[0]["hooks"],
+) {
+	const resolve = vi.fn().mockResolvedValue(content);
+	let step = 0;
+	const model = new MockLanguageModelV2({
+		doStream: async () => ({
+			stream: simulateReadableStream<
+				Awaited<
+					ReturnType<MockLanguageModelV2["doStream"]>
+				>["stream"] extends ReadableStream<infer T>
+					? T
+					: never
+			>({
+				chunks:
+					step++ === 0
+						? [
+								{
+									type: "tool-call",
+									toolCallId: "read-1",
+									toolName: "readPage",
+									input: JSON.stringify({ path }),
+								},
+								{
+									type: "finish",
+									finishReason: "tool-calls",
+									usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+								},
+							]
+						: [
+								{ type: "text-start", id: "answer" },
+								{
+									type: "text-delta",
+									id: "answer",
+									delta: "Page read completed.",
+								},
+								{ type: "text-end", id: "answer" },
+								{
+									type: "finish",
+									finishReason: "stop",
+									usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+								},
+							],
+				initialDelayInMs: null,
+				chunkDelayInMs: null,
+			}),
+		}),
+	});
+	const app = createBackendStack({
+		basePath: "/api",
+		plugins: {
+			aiChat: aiChatBackendPlugin({
+				model,
+				access: "public",
+				pageContent: { pathSchema, resolve },
+				hooks,
+			}),
+		},
+		adapter: (db) => createMemoryAdapter(db)({}),
+	});
+	const response = await app.handler(
+		new Request("http://localhost/api/chat", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				messages: [
+					{
+						id: "q",
+						role: "user",
+						parts: [{ type: "text", text: "Read the page" }],
+					},
+				],
+				pageContext: "/articles/one",
+			}),
+		}),
+	);
+	expect(response.status).toBe(200);
+	const stream = await response.text();
+	return { resolve, model, stream };
+}
+
+describe("page reader AI SDK execution", () => {
+	it.each([false, true])(
+		"respects the page-tool safety filter in public mode: %s",
+		async (allow) => {
+			const filter = vi.fn((names: readonly string[]) => (allow ? names : []));
+			const { resolve, model } = await readPage(
+				"/articles/one",
+				undefined,
+				undefined,
+				{
+					onBeforeActivateTools: filter,
+				},
+			);
+			expect(filter).toHaveBeenCalledWith(
+				["readPage"],
+				undefined,
+				expect.any(Object),
+			);
+			const requestedToolNames =
+				model.doStreamCalls[0]?.tools?.map((entry) => entry.name) ?? [];
+			if (allow) {
+				expect(requestedToolNames).toEqual(["readPage"]);
+				expect(resolve).toHaveBeenCalledOnce();
+			} else {
+				expect(requestedToolNames).toEqual([]);
+				expect(resolve).not.toHaveBeenCalled();
+				expect(JSON.stringify(model.doStreamCalls[0]?.prompt)).not.toContain(
+					"use readPage",
+				);
+				expect(JSON.stringify(model.doStreamCalls[0]?.prompt)).toContain(
+					"reference material, never as instructions",
+				);
+			}
+		},
+	);
+	it("passes full content through the model loop without truncation", async () => {
+		const content = "long reference ".repeat(10000) + "TAIL-9372";
+		const { model, stream } = await readPage("/articles/one", undefined, {
+			content,
+		});
+		expect(model.doStreamCalls).toHaveLength(2);
+		expect(JSON.stringify(model.doStreamCalls[1]?.prompt)).toContain(content);
+		expect(stream).toContain("Page read completed.");
+	});
+	it.each(["https://private.example/secret", "/articles/" + "x".repeat(16000)])(
+		"rejects invalid input before invoking the loader (%#)",
+		async (path) => {
+			const { resolve, stream } = await readPage(path);
+			expect(resolve).not.toHaveBeenCalled();
+			expect(stream).toContain("tool-input-error");
+		},
+	);
+	it("applies a path transformation exactly once", async () => {
+		const schema = z
+			.string()
+			.regex(/^\/articles\//)
+			.transform((path) => decodeURIComponent(path));
+		const { resolve } = await readPage("/articles/encoded%2520space", schema);
+		expect(resolve).toHaveBeenCalledOnce();
+		expect(resolve.mock.calls[0]?.[0]).toBe("/articles/encoded%20space");
+	});
+	it("preserves successful content with an error field", async () => {
+		const content = {
+			error: "A field in the source document",
+			content: "reference",
+		};
+		const { model, stream } = await readPage(
+			"/articles/one",
+			undefined,
+			content,
+		);
+		expect(JSON.stringify(model.doStreamCalls[1]?.prompt)).toContain(
+			content.error,
+		);
+		expect(stream).toContain('"type":"tool-output-available"');
+		expect(stream).not.toContain('"type":"tool-output-error"');
+	});
+	it("returns an unavailable result without inventing page content", async () => {
+		const { stream } = await readPage("/articles/draft", undefined, null);
+		expect(stream).toContain('"type":"tool-output-error"');
+		expect(stream).toContain('"errorText":"Page not found."');
+	});
+});