pi-multimodal-proxy 1.6.0 → 1.10.1

package/extensions/__tests__/compaction.test.ts

@@ -0,0 +1,218 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	buildCompactionDigest,
+	collectVisibleFenceIds,
+	CUSTOM_TYPE_DESCRIPTION,
+	CUSTOM_TYPE_VIDEO_DESCRIPTION,
+	DIGEST_IMAGE_CHARS,
+	DIGEST_LEAN_IMAGE_CHARS,
+	DIGEST_MAX_IMAGES,
+	findDescriptions,
+	findVideoDescriptions,
+	truncateForDigest,
+	type VideoDescriptionEntry,
+} from "../internal.ts";
+
+// SessionEntry minimal shape — typed loose because peer dep types are not loaded in test
+type Entry = any;
+
+const customEntry = (customType: string, data: unknown): Entry => ({
+	type: "custom",
+	customType,
+	data,
+});
+
+const video = (hash: string, description = `video ${hash}`): VideoDescriptionEntry => ({
+	hash,
+	filename: `${hash}.mp4`,
+	mimeType: "video/mp4",
+	description,
+});
+
+describe("findVideoDescriptions", () => {
+	it("collects hash → entry from video description entries", () => {
+		const entries: Entry[] = [
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v1")),
+			customEntry(CUSTOM_TYPE_DESCRIPTION, { hash: "img", description: "not a video" }),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, { hash: "", description: "skip" }),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v2")),
+		];
+		const map = findVideoDescriptions(entries);
+		assert.equal(map.size, 2);
+		assert.equal(map.get("v1")?.filename, "v1.mp4");
+		assert.equal(map.get("v2")?.mimeType, "video/mp4");
+	});
+
+	it("keeps the most recent entry per hash", () => {
+		const entries: Entry[] = [
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v1", "old")),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v1", "new")),
+		];
+		assert.equal(findVideoDescriptions(entries).get("v1")?.description, "new");
+	});
+
+	it("moves a re-described hash to the end of the iteration order", () => {
+		const entries: Entry[] = [
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v1", "first")),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v2", "second")),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, video("v1", "updated")),
+		];
+		assert.deepEqual([...findVideoDescriptions(entries).keys()], ["v2", "v1"]);
+	});
+
+	it("backfills filename and mimeType on malformed entries instead of crashing later", () => {
+		const entries: Entry[] = [
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, { hash: "v1", description: "d" }),
+			customEntry(CUSTOM_TYPE_VIDEO_DESCRIPTION, { hash: "v2", description: "d", filename: 42, mimeType: null }),
+		];
+		const map = findVideoDescriptions(entries);
+		assert.equal(map.get("v1")?.filename, "unknown");
+		assert.equal(map.get("v1")?.mimeType, "application/octet-stream");
+		assert.equal(map.get("v2")?.filename, "unknown");
+		assert.equal(map.get("v2")?.mimeType, "application/octet-stream");
+		// The digest builder accepts the backfilled entries without throwing.
+		const digest = buildCompactionDigest([], [...map.values()]);
+		assert.ok(digest.includes('file="unknown"'));
+	});
+});
+
+describe("findDescriptions ordering", () => {
+	it("moves a re-described hash to the end of the iteration order", () => {
+		const entries: Entry[] = [
+			customEntry(CUSTOM_TYPE_DESCRIPTION, { hash: "a", description: "first" }),
+			customEntry(CUSTOM_TYPE_DESCRIPTION, { hash: "b", description: "second" }),
+			customEntry(CUSTOM_TYPE_DESCRIPTION, { hash: "a", description: "updated" }),
+		];
+		const map = findDescriptions(entries);
+		assert.deepEqual([...map.keys()], ["b", "a"]);
+		assert.equal(map.get("a"), "updated");
+	});
+});
+
+describe("truncateForDigest", () => {
+	it("returns short text unchanged", () => {
+		assert.equal(truncateForDigest("short text", 100), "short text");
+	});
+
+	it("trims surrounding whitespace", () => {
+		assert.equal(truncateForDigest("  padded  ", 100), "padded");
+	});
+
+	it("cuts long text at a word boundary and marks the truncation", () => {
+		// slice(0,20) is "alpha beta gamma del"; the boundary cut must drop "del".
+		const out = truncateForDigest("alpha beta gamma delta epsilon", 20);
+		assert.equal(out, "alpha beta gamma … [truncated]");
+	});
+
+	it("hard-cuts when there is no usable word boundary", () => {
+		const out = truncateForDigest("a".repeat(50), 20);
+		assert.equal(out, `${"a".repeat(20)} … [truncated]`);
+	});
+
+	it("never splits a surrogate pair on a hard cut", () => {
+		// "💥" is 2 UTF-16 code units; a cut at max=21 would land mid-pair.
+		const out = truncateForDigest(`${"x".repeat(20)}💥${"y".repeat(30)}`, 21);
+		assert.ok(!/[\uD800-\uDBFF]$/.test(out.replace(" … [truncated]", "")));
+		assert.ok(!out.includes("�"));
+		assert.equal(out, `${"x".repeat(20)} … [truncated]`);
+	});
+});
+
+describe("collectVisibleFenceIds", () => {
+	const h1 = "a".repeat(32);
+	const h2 = "b".repeat(32);
+	const h3 = "c".repeat(32);
+
+	it("collects ids from description, analysis, joint, and video fences", () => {
+		const text = [
+			`<vision_proxy_description image="${h1}" width="10"\n>body\n</vision_proxy_description>`,
+			`<vision_proxy_analysis image="${h2}#crop:1,2,3,4"\n>body\n</vision_proxy_analysis>`,
+			`dimensions='[{"image":"${h3}","width":5}]'`,
+			`<vision_proxy_video_description file="v.mp4" hash="${h1}" mime="video/mp4"\n>t\n</vision_proxy_video_description>`,
+		].join("\n");
+		const ids = collectVisibleFenceIds(text);
+		assert.deepEqual([...ids].sort(), [h1, h2, h3]);
+	});
+
+	it("ignores bare hashes and user-typed recall references", () => {
+		const ids = collectVisibleFenceIds(`zoom into image="${h1}" and also ${h2} please`);
+		assert.equal(ids.size, 0);
+	});
+
+	it("accumulates into a provided set", () => {
+		const out = new Set<string>();
+		collectVisibleFenceIds(`<vision_proxy_description image="${h1}"\n>x\n</vision_proxy_description>`, out);
+		collectVisibleFenceIds(`<vision_proxy_description image="${h2}"\n>x\n</vision_proxy_description>`, out);
+		assert.equal(out.size, 2);
+	});
+});
+
+describe("buildCompactionDigest", () => {
+	it("returns empty string when there is nothing to restore", () => {
+		assert.equal(buildCompactionDigest([], []), "");
+	});
+
+	it("restores image fences with id, meta, and untrusted warning", () => {
+		const digest = buildCompactionDigest(
+			[{ hash: "hash-a", description: "a red square", meta: { width: 10, height: 20, filename: "sq.png" } }],
+			[],
+		);
+		assert.ok(digest.includes("post-compaction recall"));
+		assert.ok(digest.includes('image="hash-a"'));
+		assert.ok(digest.includes('width="10"'));
+		assert.ok(digest.includes('filename="sq.png"'));
+		assert.ok(digest.includes("a red square"));
+		assert.ok(digest.includes("UNTRUSTED"));
+	});
+
+	it("includes video fences", () => {
+		const digest = buildCompactionDigest([], [video("v9", "a talking head")]);
+		assert.ok(digest.includes('hash="v9"'));
+		assert.ok(digest.includes('file="v9.mp4"'));
+		assert.ok(digest.includes("a talking head"));
+		assert.ok(digest.includes("1 video/audio file"));
+	});
+
+	it("mentions analyze_image recall only when the tool is enabled", () => {
+		const imgs = [{ hash: "h", description: "d" }];
+		assert.ok(buildCompactionDigest(imgs, [], { toolEnabled: true }).includes("analyze_image"));
+		assert.ok(!buildCompactionDigest(imgs, [], { toolEnabled: false }).includes("analyze_image"));
+	});
+
+	it("keeps only the most recent images when over the cap", () => {
+		const imgs = Array.from({ length: DIGEST_MAX_IMAGES + 3 }, (_, i) => ({
+			hash: `h${i}`,
+			description: `d${i}`,
+		}));
+		const digest = buildCompactionDigest(imgs, []);
+		assert.ok(!digest.includes('image="h0"'), "oldest images dropped");
+		assert.ok(!digest.includes('image="h2"'));
+		assert.ok(digest.includes('image="h3"'));
+		assert.ok(digest.includes(`image="h${DIGEST_MAX_IMAGES + 2}"`));
+	});
+
+	it("applies tighter budgets in lean mode", () => {
+		const long = "word ".repeat(400);
+		const [full] = buildCompactionDigest([{ hash: "h", description: long }], [])
+			.split("\n\n")
+			.slice(1);
+		const [lean] = buildCompactionDigest([{ hash: "h", description: long }], [], { lean: true })
+			.split("\n\n")
+			.slice(1);
+		assert.ok(full!.length > lean!.length);
+		assert.ok(lean!.length < DIGEST_LEAN_IMAGE_CHARS + 200);
+		assert.ok(full!.length < DIGEST_IMAGE_CHARS + 200);
+	});
+
+	it("counts both media kinds in the header", () => {
+		const digest = buildCompactionDigest(
+			[
+				{ hash: "a", description: "d1" },
+				{ hash: "b", description: "d2" },
+			],
+			[video("v1"), video("v2")],
+		);
+		assert.ok(digest.includes("2 images and 2 video/audio files"));
+	});
+});

package/extensions/__tests__/integration.test.ts

@@ -1,5 +1,5 @@
 /**
- * Integration tests for pi-vision-proxy.
+ * Integration tests for pi-multimodal-proxy.
  *
  * These tests mock Pi's extension interfaces to test the full wiring:
  * fence output format, consent flow, tool validation, context stripping,
@@ -22,8 +22,6 @@ import {
 	bufferToPiAiImage,
 	resolveCropEntry,
 	hashImageData,
-	_imageMeta,
-	storeImageMeta,
 	extractDimensions,
 	computePHash,
 	hammingDistance,