dsh-vision-fallback 0.5.0

package/test/vision-fallback.test.mjs

@@ -0,0 +1,443 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import {
+  CONFIG_ROUTE,
+  ReplacementCoordinator,
+  VisionFallbackController,
+  apply,
+  buildVisionPrompt,
+  installCapabilityOverride,
+  rewriteMessages,
+  withImageCapability
+} from "../lib/index.js";
+
+const config = {
+  enabled: true,
+  model: "vision-model",
+  baseURL: "https://vision.example/v1",
+  apiKeyRef: "VISION_KEY",
+  maxTokens: 1024,
+  timeoutMs: 1000,
+  maxBytes: 1024 * 1024,
+  includeRecentContext: true,
+  contextMessages: 6,
+  contextMaxChars: 6000,
+  prompt: "分析图片并关注用户问题。",
+  tagResult: true
+};
+
+const attachment = {
+  attachmentId: "sha256:test",
+  mediaType: "image/png",
+  bytes: 3,
+  width: 1,
+  height: 1,
+  name: "error.png"
+};
+
+function userMessage(id, content) {
+  return { id, role: "user", source: { kind: "user" }, content };
+}
+
+function assistantMessage(id, text) {
+  return {
+    id,
+    role: "assistant",
+    source: { kind: "model", provider: "deepseek-official", model: "deepseek-v4-flash" },
+    content: [{ type: "text", text }]
+  };
+}
+
+function createServiceContext() {
+  return {
+    get(service) {
+      if (service === "credentials") {
+        return { resolve: async () => ({ value: "test-key", source: "test" }) };
+      }
+      if (service === "attachments") {
+        return { readImage: async (ref) => ({ ref, data: new Uint8Array([1, 2, 3]) }) };
+      }
+      return undefined;
+    }
+  };
+}
+
+test("视觉提示词包含当前问题和最近上下文", () => {
+  const messages = [
+    userMessage("u1", [{ type: "text", text: "这是服务器配置页面。" }]),
+    assistantMessage("a1", "请发送报错截图。"),
+    userMessage("u2", [{ type: "text", text: "哪里配置错了？" }, { type: "image", attachment }])
+  ];
+  const prompt = buildVisionPrompt(messages, attachment, 1, 1, config);
+  assert.match(prompt, /哪里配置错了/);
+  assert.match(prompt, /请发送报错截图/);
+  assert.match(prompt, /error\.png/);
+});
+
+test("重写图片时保留消息身份和原文字", async () => {
+  const original = userMessage("u1", [
+    { type: "text", text: "请分析错误" },
+    { type: "image", attachment }
+  ]);
+  const [rewritten] = await rewriteMessages([original], async () => "视觉观察结果");
+  assert.equal(rewritten.id, original.id);
+  assert.equal(rewritten.source, original.source);
+  assert.equal(rewritten.content[0].text, "请分析错误");
+  assert.equal(rewritten.content[1].text, "视觉观察结果");
+});
+
+test("启用时仅覆盖图片能力元数据", () => {
+  const base = {
+    provider: "deepseek-official",
+    id: "deepseek-v4-flash",
+    name: "DeepSeek-V4-Flash",
+    inputModalities: ["text"]
+  };
+  assert.deepEqual(withImageCapability(base, config).inputModalities, ["text", "image"]);
+  assert.equal(withImageCapability(base, { ...config, enabled: false }), base);
+});
+
+test("固定视觉模型把图片转换为主模型观察", async () => {
+  const visionRequests = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (_url, options) => {
+    visionRequests.push(JSON.parse(options.body));
+    return {
+      ok: true,
+      json: async () => ({ choices: [{ message: { content: "发现配置项拼写错误" } }] })
+    };
+  };
+  const controller = new VisionFallbackController(createServiceContext(), () => config);
+  const current = userMessage("u2", [
+    { type: "text", text: "图片里是什么？" },
+    { type: "image", attachment }
+  ]);
+  const context = [assistantMessage("a1", "请发截图"), current];
+
+  try {
+    const [rewritten] = await controller.preprocess([current], context);
+    assert.equal(visionRequests[0].model, "vision-model");
+    assert.match(visionRequests[0].messages[1].content[0].text, /图片里是什么/);
+    assert.match(visionRequests[0].messages[1].content[0].text, /请发截图/);
+    assert.match(rewritten.content[1].text, /发现配置项拼写错误/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("surface replacement 保留原图界面并只替换模型视图", async () => {
+  const errors = [];
+  const coordinator = new ReplacementCoordinator({
+    error(value) {
+      errors.push(value);
+    }
+  });
+  const appends = [];
+  const original = userMessage("u1", [{ type: "image", attachment }]);
+  const rewritten = userMessage("u1", [{ type: "text", text: "隐藏视觉观察" }]);
+  let surface = [original];
+  const originalDeriveMessages = () => surface;
+  const session = {
+    deriveMessages: originalDeriveMessages,
+    append(type, data, options) {
+      appends.push({ type, data, options });
+      surface = [data];
+      return { seq: 13, type, data, ...options };
+    }
+  };
+
+  coordinator.stage(session, [original], [rewritten]);
+  coordinator.onSessionEvent(session, { seq: 12, type: "user/message", surfaceOp: "append", data: original });
+  assert.equal(session.deriveMessages()[0], rewritten);
+  await new Promise((resolve) => queueMicrotask(resolve));
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(appends, [{
+    type: "user/message",
+    data: rewritten,
+    options: {
+      surfaceOp: { op: "replace", start: 12, end: 12 },
+      sourceEventSeqs: [12]
+    }
+  }]);
+  assert.equal(session.deriveMessages()[0], rewritten);
+  coordinator.dispose();
+  assert.equal(session.deriveMessages, originalDeriveMessages);
+});
+
+test("surface replacement 事件不会再次触发替换", async () => {
+  const coordinator = new ReplacementCoordinator({ error() {} });
+  const original = userMessage("u1", [{ type: "image", attachment }]);
+  const rewritten = userMessage("u1", [{ type: "text", text: "隐藏视觉观察" }]);
+  const appends = [];
+  const session = {
+    deriveMessages: () => [original],
+    append(type, data, options) {
+      appends.push({ type, data, options });
+      coordinator.onSessionEvent(session, {
+        seq: 13,
+        type,
+        surfaceOp: options.surfaceOp,
+        data
+      });
+    }
+  };
+
+  coordinator.stage(session, [original], [rewritten]);
+  coordinator.onSessionEvent(session, {
+    seq: 12,
+    type: "user/message",
+    surfaceOp: "append",
+    data: original
+  });
+  await new Promise((resolve) => queueMicrotask(resolve));
+  await new Promise((resolve) => queueMicrotask(resolve));
+
+  assert.equal(appends.length, 1);
+  assert.deepEqual(appends[0].options.surfaceOp, { op: "replace", start: 12, end: 12 });
+});
+
+test("图片能力覆盖可随开关变化并能恢复", async () => {
+  let current = config;
+  const original = async (provider, model) => ({
+    provider,
+    id: model,
+    name: model,
+    inputModalities: ["text"]
+  });
+  const ctx = { llm: { resolveModelInfo: original } };
+  const restore = installCapabilityOverride(ctx, () => current);
+
+  assert.deepEqual((await ctx.llm.resolveModelInfo("deepseek-official", "deepseek-v4-flash")).inputModalities, ["text", "image"]);
+  current = { ...config, enabled: false };
+  assert.deepEqual((await ctx.llm.resolveModelInfo("deepseek-official", "deepseek-v4-flash")).inputModalities, ["text"]);
+  restore();
+  assert.equal(ctx.llm.resolveModelInfo, original);
+});
+
+test("插件注册静默预处理钩子而不注册新模型 adapter", () => {
+  const hooks = new Map();
+  let cleanup;
+  let registeredSettings;
+  let registeredRoute;
+  const settingsEffects = [];
+  const webEffects = [];
+  const replacements = [];
+  const settings = {
+    register(namespace, schema, options) {
+      registeredSettings = { namespace, schema, options };
+      return {
+        get() {
+          return options.base;
+        },
+        watch() {}
+      };
+    },
+    async replace(namespace, value) {
+      replacements.push({ namespace, value });
+    }
+  };
+  const ctx = {
+    llm: {
+      resolveModelInfo: async (provider, model) => ({ provider, id: model, name: model, inputModalities: ["text"] })
+    },
+    logger: { error() {} },
+    effect(factory) {
+      cleanup = factory();
+    },
+    on(name, handler) {
+      hooks.set(name, handler);
+      return () => hooks.delete(name);
+    },
+    inject(dependencies, callback) {
+      if (dependencies[0] === "settings") {
+        assert.deepEqual(dependencies, ["settings"]);
+        callback({
+          settings,
+          effect(factory) {
+            settingsEffects.push(factory());
+          }
+        });
+        return;
+      }
+      assert.deepEqual(dependencies, ["webServer"]);
+      callback({
+        webServer: {
+          register(route) {
+            registeredRoute = route;
+            return () => {};
+          }
+        },
+        effect(factory) {
+          webEffects.push(factory());
+        }
+      });
+    }
+  };
+
+  apply(ctx, config);
+  assert.equal(typeof hooks.get("agent/pre-step"), "function");
+  assert.equal(typeof hooks.get("session/event"), "function");
+  assert.equal("registerAdapter" in ctx.llm, false);
+  assert.equal("registerConfigurableProviders" in ctx.llm, false);
+  assert.equal(typeof cleanup, "function");
+  assert.equal(registeredSettings.namespace, "vision-fallback");
+  assert.equal(registeredSettings.options.base, config);
+  assert.equal(settingsEffects.length, 2);
+  assert.equal(webEffects.length, 1);
+  assert.equal(registeredRoute.kind, "exact");
+  assert.equal(registeredRoute.path, CONFIG_ROUTE);
+  assert.equal(replacements.length, 0);
+});
+
+test("插件私有配置路由允许本机读取和保存", async () => {
+  let route;
+  let stored = config;
+  const ctx = {
+    inject(dependencies, callback) {
+      assert.deepEqual(dependencies, ["webServer"]);
+      callback({
+        webServer: {
+          register(value) {
+            route = value;
+            return () => {};
+          }
+        },
+        effect(factory) {
+          factory();
+        }
+      });
+    }
+  };
+  const settings = {
+    async replace(namespace, value) {
+      assert.equal(namespace, "vision-fallback");
+      stored = value;
+    }
+  };
+  const { installConfigRoute } = await import("../lib/index.js");
+  installConfigRoute(ctx, () => stored, () => settings);
+
+  const createRequest = (method, body) => ({
+    method,
+    headers: {
+      host: "127.0.0.1:3080",
+      ...(body === undefined ? {} : { "content-type": "application/json" })
+    },
+    socket: { remoteAddress: "127.0.0.1" },
+    async *[Symbol.asyncIterator]() {
+      if (body !== undefined) yield Buffer.from(JSON.stringify(body));
+    }
+  });
+  const createResponse = () => {
+    const result = { headers: {} };
+    return {
+      result,
+      setHeader(name, value) {
+        result.headers[name.toLowerCase()] = value;
+      },
+      writeHead(status, headers) {
+        result.status = status;
+        Object.assign(result.headers, headers);
+      },
+      end(body) {
+        result.body = JSON.parse(body);
+      }
+    };
+  };
+
+  const getResponse = createResponse();
+  await route.handler(createRequest("GET"), getResponse);
+  assert.equal(getResponse.result.status, 200);
+  assert.equal(getResponse.result.body.ok, true);
+  assert.equal(getResponse.result.body.value.model, "vision-model");
+
+  const replacement = { ...config, model: "mimo-v2.5" };
+  const postResponse = createResponse();
+  await route.handler(createRequest("POST", replacement), postResponse);
+  assert.equal(postResponse.result.status, 200);
+  assert.equal(postResponse.result.body.ok, true);
+  assert.equal(stored.model, "mimo-v2.5");
+});
+
+test("浏览器端只显示静默视觉配置", async () => {
+  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+  const clientSource = await readFile(new URL("../lib/client.js", import.meta.url), "utf8");
+  assert.equal(packageJson.exports["./client"], "./lib/client.js");
+  assert.equal(packageJson.dsh.client.platform, "web");
+  assert.doesNotMatch(clientSource, /targetProvider|targetModel|主模型提供方|工作模式/);
+  assert.doesNotMatch(clientSource, /datalist|vf-vision-models/);
+  assert.match(clientSource, /开启后不会新增模型分组/);
+  assert.match(clientSource, /固定视觉模型/);
+  assert.match(clientSource, /mimo-v2\.5/);
+  assert.match(clientSource, /手动输入其他模型/);
+  assert.match(clientSource, /\/plugins\/dsh-vision-fallback\/config/);
+  assert.doesNotMatch(clientSource, /settingsScope/);
+
+  let definition;
+  const previousWindow = globalThis.window;
+  const previousFetch = globalThis.fetch;
+  const configRequests = [];
+  globalThis.window = {
+    __ModuleLoader__: {
+      load(value) {
+        definition = value;
+      }
+    }
+  };
+  globalThis.fetch = async (url, options) => {
+    configRequests.push({ url, options });
+    return {
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true, value: config })
+    };
+  };
+
+  try {
+    await import(`../lib/client.js?test=${Date.now()}`);
+    const client = definition.factory((id) => {
+      if (id === "react") return {};
+      throw new Error(`unexpected client dependency: ${id}`);
+    });
+    assert.deepEqual(client.inject, ["slots", "connection"]);
+
+    let registration;
+    client.apply({
+      get(service) {
+        assert.equal(service, "connection");
+        return { api: {} };
+      },
+      effect() {},
+      slots: {
+        inject(name, mount) {
+          assert.equal(name, "settings.section");
+          mount();
+        },
+        register(options, component) {
+          registration = { options, component };
+          return () => {};
+        }
+      }
+    });
+
+    assert.equal(registration.options.id, "vision-fallback");
+    assert.equal(registration.options.label(), "视觉增强");
+    const injected = registration.options.inject();
+    assert.equal(typeof injected.scope.getSnapshot, "function");
+    assert.equal(typeof injected.scope.replace, "function");
+    assert.deepEqual(injected.api, {});
+    assert.equal(typeof registration.component, "function");
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(configRequests.length, 1);
+    assert.equal(configRequests[0].url, CONFIG_ROUTE);
+    assert.equal(configRequests[0].options.method, "GET");
+    assert.equal(injected.scope.getSnapshot().status, "ready");
+    assert.equal(injected.scope.getSnapshot().value.model, "vision-model");
+  } finally {
+    if (previousWindow === undefined) delete globalThis.window;
+    else globalThis.window = previousWindow;
+    globalThis.fetch = previousFetch;
+  }
+});