jev-layer 0.2.0 → 0.3.0

package/test/images.test.mjs

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { normalizeImageAssets } from "../src/images.mjs";
+import { OpenRouterDecisionsProvider, TypeSafeProvider } from "../src/providers/typesafe.mjs";
+import { routeRequest } from "../src/route.mjs";
+import { PNG as png } from "./image-fixture.mjs";
+
+const reference = "frame-6e1d0b7c";
+const image = { type: "image", format: "png", data_base64: png };
+const assets = { [reference]: image };
+const candidates = [{ id: "search", name: "Search", kind: "mcp", description: "Search files", permissions: ["read"], risk: "low" }];
+const request = { intent: "Inspect the image and choose a capability", actor_permissions: ["read"], capabilities: candidates, assets };
+const questions = { visible: { type: "noul", instructions: "Is the target visible?" }, target: { type: "box", instructions: "the target in `screenshot`" } };
+
+// Keep provider resolution deterministic without using developer credentials.
+for (const key of Object.keys(process.env)) {
+  if (/^(JEV_|TYPESAFE_|OPENROUTER_)/.test(key)) delete process.env[key];
+}
+
+test("image reference names cannot change the output object's prototype", () => {
+  const special = normalizeImageAssets(JSON.parse(`{"__proto__":${JSON.stringify(image)}}`));
+  assert.equal(Object.hasOwn(special, "__proto__"), true);
+  assert.equal(Object.getPrototypeOf(special), Object.prototype);
+});
+
+test("image trust boundary rejects malformed maps, references, formats and noncanonical base64", () => {
+  for (const input of [null, [], "file.png", { "": image }, { " ": image }, { ["é".repeat(513)]: image }]) {
+    assert.throws(() => normalizeImageAssets(input));
+  }
+  for (const invalid of [
+    { ...image, format: "webp" }, { ...image, format: "jpg" }, { ...image, type: "video" },
+    { ...image, part: "file" }, { ...image, url: "https://example.test/image.png" },
+    { ...image, data_base64: `data:image/png;base64,${png}` },
+    { ...image, data_base64: `${png}\n` }, { ...image, data_base64: "AB==" },
+    { ...image, data_base64: "!!!!" }, { ...image, data_base64: png.slice(0, -4) },
+  ]) assert.throws(() => normalizeImageAssets({ [reference]: invalid }));
+  const manyReferences = Object.fromEntries(Array.from({ length: 65 }, (_, i) => [`${i}-${"x".repeat(1018)}`, image]));
+  assert.throws(() => normalizeImageAssets(manyReferences), /references/);
+});
+
+test("image dimensions, animation and decoded byte limits are checked locally", () => {
+  for (const [width, height] of [[256, 256], [255, 400], [400, 1569]]) {
+    const bytes = Buffer.from(png, "base64");
+    bytes.writeUInt32BE(width, 16);
+    bytes.writeUInt32BE(height, 20);
+    assert.throws(() => normalizeImageAssets({ [reference]: { ...image, data_base64: bytes.toString("base64") } }), /dimensions/);
+  }
+  const bytes = Buffer.from(png, "base64");
+  const animation = Buffer.alloc(20);
+  animation.writeUInt32BE(8);
+  animation.write("acTL", 4);
+  const animated = Buffer.concat([bytes.subarray(0, 33), animation, bytes.subarray(33)]).toString("base64");
+  assert.throws(() => normalizeImageAssets({ [reference]: { ...image, data_base64: animated } }), /animated/);
+  const tooLarge = "A".repeat(4 * Math.ceil((16 * 1024 * 1024 + 1) / 3));
+  assert.throws(() => normalizeImageAssets({ [reference]: { ...image, data_base64: tooLarge } }), /16 MiB/);
+});
+
+for (const Provider of [TypeSafeProvider, OpenRouterDecisionsProvider]) {
+  test(`${Provider.name} rejects unreferenced images and oversized requests before HTTP`, async () => {
+    let calls = 0;
+    const provider = new Provider({ apiKey: "fixture-key", fetchImpl: async () => { calls += 1; return Response.json({ answers: {} }); } });
+    await assert.rejects(provider.evaluate({ state: { [reference]: "not an image reference" }, questions, assets }), /must be referenced/);
+    await assert.rejects(provider.evaluate({ state: "x".repeat(32 * 1024 * 1024), questions: {} }), /32 MiB/);
+    assert.equal(calls, 0);
+  });
+}
+
+for (const Provider of [TypeSafeProvider, OpenRouterDecisionsProvider]) {
+  test(`${Provider.name} image errors remain fail-open without leaking bytes`, async () => {
+    for (const settings of [
+      { apiKey: "", fetchImpl: () => { throw new Error("must not call HTTP"); } },
+      { apiKey: "fixture-key", fetchImpl: async () => new Response(png, { status: 400 }) },
+      { apiKey: "fixture-key", fetchImpl: async () => new Response(png) },
+      { apiKey: "fixture-key", fetchImpl: async () => { throw new Error(png); } },
+      { apiKey: "fixture-key", fetchImpl: async () => { throw new DOMException("fixture timeout", "TimeoutError"); } },
+    ]) {
+      const result = await routeRequest(request, { provider: new Provider(settings) });
+      assert.equal(result.status, "fallback");
+      assert.equal(result.fallback.type, "provider_error");
+      assert.equal(result.execution.enabled, false);
+      assert.equal(JSON.stringify(result).includes(png), false);
+    }
+  });
+}
+

package/test/providers.test.mjs

@@ -29,11 +29,11 @@ test("demo routes deterministically without a network call or credentials", asyn
   assert.equal(globalThis.fetch.mock.callCount(), 0);
 });
 
-for (const [provider, endpoint, model] of [
-  ["typesafe", "https://api.typesafe.ai/v1/systemone", "jev-latest"],
-  ["openrouter", "https://openrouter.ai/api/alpha/decisions", "typesafe/jev-1.13"],
+for (const [provider, endpoint] of [
+  ["typesafe", "https://api.typesafe.ai/v1/systemone"],
+  ["openrouter", "https://openrouter.ai/api/alpha/decisions"],
 ]) {
-  test(`${provider} routes with the documented endpoint, model, auth and Choice contract`, async () => {
+  test(`${provider} routes with the documented endpoint, auth and Choice contract`, async () => {
     let calls = 0;
     const decision = await routeRequest(request, {
       provider,
@@ -53,13 +53,12 @@ for (const [provider, endpoint, model] of [
             assert.equal(init.headers["X-Title"], "Jev fixture");
           }
           const body = JSON.parse(init.body);
-          assert.equal(body.model, model);
           assert.equal(body.state.intent, request.intent);
           assert.equal(body.questions.tool.type, "choice");
           assert.deepEqual(Object.keys(body.questions.tool.criteria), ["search", "clock"]);
           assert.equal(body.questions.tool.criteria.search.description, request.capabilities[0].description);
           assert.equal("messages" in body, false);
-          return Response.json({ model, answers: { tool: answer }, usage: { input_tokens: 10, output_tokens: 2 } });
+          return Response.json({ model: body.model, answers: { tool: answer }, usage: { input_tokens: 10, output_tokens: 2 } });
         },
       },
     });

package/test/route.test.mjs

@@ -72,3 +72,15 @@ test("honors explicit disablement with fail-open fallback", async () => {
     else process.env.JEV_LAYER_ENABLED = previous;
   }
 });
+
+test("visual replay cannot silently substitute text-only routing", async () => {
+  let calls = 0;
+  const decision = await routeRequest(request({
+    assets_omitted: true,
+    policy: { deterministic: true, deterministic_capability_id: "search" },
+  }), { provider: { name: "no-image-replay", async decide() { calls++; } } });
+  assert.equal(decision.status, "fallback");
+  assert.equal(decision.selected, null);
+  assert.match(decision.reason, /original images/);
+  assert.equal(calls, 0);
+});