nolo-cli 0.1.13 → 0.1.14

package/ai/tools/readXPostTool.ts

@@ -0,0 +1,233 @@
+import { createXReadFailure } from "../../integrations/x-reader/types";
+import type { XPost, XReadResult } from "../../integrations/x-reader/types";
+import { getRequestConfig, ToolApiError } from "./toolApiClient";
+
+export const readXPostFunctionSchema = {
+  name: "read_x_post",
+  description:
+    "读取 X/Twitter status 链接的可见帖子正文、作者和结构化数据。适合用户给出 x.com/twitter.com 帖子链接并要求查看、总结、解释或抽取信息的场景。默认通过桌面本地 Chrome/CDP bridge 读取，不要求用户粘贴 cookie 或 token。",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description:
+          "要读取的 X/Twitter status URL，例如 https://x.com/user/status/123。",
+      },
+      keepOpen: {
+        type: "boolean",
+        description: "调试时是否保留临时 Chrome bridge。默认 false。",
+        default: false,
+      },
+      profileDir: {
+        type: "string",
+        description:
+          "桌面端本地 Chrome 专用 profile 目录。用于让用户在本机登录一次 X 后复用本地账号状态；不要传入用户日常 Chrome profile。",
+      },
+      headless: {
+        type: "boolean",
+        description:
+          "是否用 headless 模式启动本地 Chrome。需要用户首次登录本地 X profile 时设为 false 并配合 keepOpen。",
+        default: true,
+      },
+    },
+    required: ["url"],
+  },
+};
+
+type ReadXPostToolContext = {
+  reader?: (
+    url: string,
+    args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
+  ) => Promise<XReadResult<XPost>>;
+};
+
+async function callLocalReadXPostApi(
+  thunkApi: any,
+  body: object,
+): Promise<XReadResult<XPost>> {
+  const { currentServer, token } = getRequestConfig(thunkApi);
+  const browserOrigin = (globalThis as any).window?.location?.origin;
+  const baseUrl = typeof browserOrigin === "string" && browserOrigin
+    ? browserOrigin
+    : currentServer.replace(/\/+$/, "");
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  const response = await fetch(`${baseUrl}/api/read-x-post`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let data: any = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = null;
+  }
+  if (!response.ok) {
+    throw new ToolApiError(
+      data?.error?.message ?? `read_x_post API 请求失败，状态码: ${response.status}`,
+      {
+        status: response.status,
+        code: data?.error?.code,
+        details: data,
+      },
+    );
+  }
+  return data as XReadResult<XPost>;
+}
+
+async function callDesktopReadXPostApi(
+  thunkApi: any,
+  body: object,
+): Promise<XReadResult<XPost>> {
+  const { token } = getRequestConfig(thunkApi);
+  const port = Number(process.env.NOLO_DESKTOP_SERVER_PORT ?? 3233);
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  const response = await fetch(`http://127.0.0.1:${port}/api/read-x-post`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let data: any = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = null;
+  }
+  if (!response.ok) {
+    throw new ToolApiError(
+      data?.error?.message ?? `desktop read_x_post API 请求失败，状态码: ${response.status}`,
+      {
+        status: response.status,
+        code: data?.error?.code,
+        details: data,
+      },
+    );
+  }
+  return data as XReadResult<XPost>;
+}
+
+async function readWithDefaultBridge(
+  url: string,
+  args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
+  thunkApi?: any,
+): Promise<XReadResult<XPost>> {
+  if (process.env.PLATFORM === "web") {
+    if (thunkApi?.getState) {
+      return callLocalReadXPostApi(thunkApi, { url, ...args });
+    }
+
+    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+      try {
+        const res = await fetch("/api/read-x-post", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ url, ...args }),
+        });
+        const data = await res.json().catch(() => null);
+        if (res.ok && data) {
+          return data as XReadResult<XPost>;
+        }
+        return createXReadFailure({
+          code: "network_error",
+          message: `desktop read_x_post endpoint failed: HTTP ${res.status}`,
+          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
+          backend: "desktop_local_browser",
+        });
+      } catch (error) {
+        return createXReadFailure({
+          code: "network_error",
+          message:
+            error instanceof Error
+              ? error.message
+              : "desktop read_x_post endpoint request failed",
+          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
+          backend: "desktop_local_browser",
+        });
+      }
+    }
+
+    return createXReadFailure({
+      code: "not_connected",
+      message: "read_x_post 需要通过服务器或桌面本地 bridge 执行，不能在普通浏览器 bundle 内直接启动 Chrome/CDP。",
+      nextStep: "请使用服务器 agent run 或桌面端本地 bridge 路径执行该工具。",
+      backend: "desktop_local_browser",
+    });
+  }
+
+  if (process.env.NOLO_DESKTOP === "1" && thunkApi?.getState) {
+    return callDesktopReadXPostApi(thunkApi, { url, ...args });
+  }
+
+  const importBridge = new Function("specifier", "return import(specifier)") as <
+    T = any,
+  >(
+    specifier: string,
+  ) => Promise<T>;
+  const bridgeModuleUrl = new URL(
+    "../../integrations/x-reader/bridge/readXPostWithBridge.ts",
+    import.meta.url,
+  ).href;
+  const { readXPostWithBridge } = await importBridge<{
+    readXPostWithBridge: (
+      url: string,
+      args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
+    ) => Promise<XReadResult<XPost>>;
+  }>(bridgeModuleUrl);
+  return readXPostWithBridge(url, args);
+}
+
+function assertXStatusUrl(url: string) {
+  if (!/^https?:\/\/(x|twitter)\.com\/[^/]+\/status\/\d+/i.test(url)) {
+    throw new Error("read_x_post 需要一个有效的 X/Twitter status URL。");
+  }
+}
+
+function formatDisplay(result: XReadResult<XPost>) {
+  if (!result.ok) {
+    return [
+      `读取 X 帖子失败：${result.message}`,
+      `失败代码：${result.code}`,
+      result.nextStep ? `下一步：${result.nextStep}` : "",
+      `后端：${result.backend}`,
+    ]
+      .filter(Boolean)
+      .join("\n");
+  }
+
+  const post = result.data;
+  return [
+    `已读取 X 帖子：@${post.author.handle}${post.author.displayName ? `（${post.author.displayName}）` : ""}`,
+    `URL: ${post.url}`,
+    `后端：${result.backend}`,
+    "",
+    post.text,
+  ].join("\n");
+}
+
+export async function readXPostFunc(
+  args: { url: string; keepOpen?: boolean; profileDir?: string; headless?: boolean },
+  thunkApi: any,
+  context: ReadXPostToolContext = {},
+): Promise<{ rawData: XReadResult<XPost>; displayData: string }> {
+  const url = String(args?.url ?? "").trim();
+  assertXStatusUrl(url);
+
+  const keepOpen = Boolean(args?.keepOpen);
+  const profileDir = String(args?.profileDir ?? "").trim() || undefined;
+  const headless = args?.headless;
+  const rawData =
+    (await context.reader?.(url, { keepOpen, profileDir, headless })) ??
+    (await readWithDefaultBridge(url, { keepOpen, profileDir, headless }, thunkApi));
+
+  return {
+    rawData,
+    displayData: formatDisplay(rawData),
+  };
+}

package/ai/tools/rememberMemoryTool.ts

@@ -0,0 +1,84 @@
+import { selectCurrentSpaceId } from "create/space/spaceSlice";
+import { callToolApi } from "./toolApiClient";
+import type { RememberMemoryScope } from "ai/memory/remember";
+import type { MemoryKind } from "ai/memory/types";
+
+export interface RememberMemoryToolArgs {
+  content: string;
+  scope?: RememberMemoryScope;
+  kind?: MemoryKind;
+}
+
+export const rememberMemoryFunctionSchema = {
+  name: "rememberMemory",
+  description: [
+    "当你判断某条用户偏好、纠正、决策习惯或当前 Space 共识值得被长期记住时，调用本工具写入一条 memory。",
+    "默认先记原始事件，不要把一次性临时要求、当前任务进度或明显短期信息写进去。",
+    "只有重复出现的可执行流程/排障步骤才传 kind=procedural；一般偏好和事实保持默认 episodic。",
+    "只有当当前 dialog 明确绑定了一个 Space，且这条内容确实属于共享协作共识时，才应该传 scope=space。",
+    "优先写成一句简洁、未来仍可理解的话；如无必要，不要频繁调用。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      content: {
+        type: "string",
+        description:
+          "要记住的内容。请写成一句未来仍然可理解的简洁描述，例如“这个用户在复杂问题里更喜欢先看结论”。",
+      },
+      scope: {
+        type: "string",
+        enum: ["auto", "user", "space"],
+        description:
+          "记忆范围。默认 auto：优先记到当前用户；若没有用户上下文再退到当前 space。只有当前 dialog 明确绑定了 space，且你明确想写共享协作记忆时才传 space；否则保持 auto。",
+      },
+      kind: {
+        type: "string",
+        enum: ["episodic", "semantic", "procedural"],
+        description:
+          "记忆类型。默认 episodic。只有重复出现的可执行流程、排障步骤或稳定 runbook 才使用 procedural。",
+      },
+    },
+    required: ["content"],
+  } as const,
+};
+
+export async function rememberMemoryFunc(
+  args: RememberMemoryToolArgs,
+  thunkApi: any
+): Promise<{ rawData: unknown; displayData: string }> {
+  const state = thunkApi.getState();
+  const spaceId = selectCurrentSpaceId(state) || undefined;
+  const content = String(args.content ?? "").trim();
+  const scope = args.scope ?? "auto";
+  const kind = args.kind ?? "episodic";
+
+  if (!content) {
+    throw new Error("rememberMemory 需要非空 content。");
+  }
+
+  const result = await callToolApi<{
+    success: boolean;
+    content: string;
+    requestedScope: RememberMemoryScope;
+    resolvedScopes: Array<{ ownerType: string; ownerId: string }>;
+  }>(
+    thunkApi,
+    "/api/memory/remember",
+    {
+      content,
+      scope,
+      kind,
+      spaceId,
+    },
+    { withAuth: true }
+  );
+
+  const scopeLabel =
+    result.resolvedScopes?.[0]?.ownerType === "space" ? "当前空间" : "当前用户";
+
+  return {
+    rawData: result,
+    displayData: `已记住这条${scopeLabel}记忆。`,
+  };
+}

package/ai/tools/remotionVideoTool.ts

@@ -0,0 +1,151 @@
+import { ContentType } from "app/types";
+import { addContentAction } from "create/space/content/addContentAction";
+import { selectCurrentSpaceId } from "create/space/spaceSlice";
+import { buildDatabaseFileContentUrl } from "database/fileUrl";
+import { fileKey } from "database/keys";
+import { selectCurrentServer } from "app/settings/settingSlice";
+import { selectUserId } from "auth/authSlice";
+import { callToolApi } from "./toolApiClient";
+
+type RemotionRenderVideoArgs = {
+  template?: "mobile-product" | "landscape-product" | "nolo-mobile-product" | "nolo-landscape-product";
+  brand?: string;
+  hook?: string;
+  headline?: string;
+  subline?: string;
+  prompt?: string;
+  cta?: string;
+  outputName?: string;
+};
+
+export const remotionRenderVideoFunctionSchema = {
+  name: "remotionRenderVideo",
+  description: [
+    "使用平台内 Remotion 模板渲染产品视频，并保存为可复用 MP4 文件。",
+    "",
+    "适用场景：",
+    "- 用户要生成手机传播视频、产品介绍视频、欢迎页短片、Agent/AI 工作流演示视频。",
+    "- 需要把文案、标题、输入框示例等参数化后产出 MP4。",
+    "",
+    "当前模板：",
+    "- mobile-product: 9:16 竖版，适合手机传播。",
+    "- landscape-product: 16:9 横版，适合官网/演示页。",
+    "- 兼容旧别名 nolo-mobile-product / nolo-landscape-product。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      template: {
+        type: "string",
+        enum: ["mobile-product", "landscape-product", "nolo-mobile-product", "nolo-landscape-product"],
+        description: "视频模板。默认 mobile-product。",
+      },
+      brand: {
+        type: "string",
+        description: "品牌名，例如 Nolo.Chat、你的产品名、店铺名或活动名。",
+      },
+      hook: {
+        type: "string",
+        description: "竖版视频首屏钩子标题，例如“把一句想法，推进成结果”。",
+      },
+      headline: {
+        type: "string",
+        description: "横版视频主标题；竖版缺少 hook 时也会作为 hook 使用。",
+      },
+      subline: {
+        type: "string",
+        description: "横版视频副标题。",
+      },
+      prompt: {
+        type: "string",
+        description: "手机输入框里逐字打出的示例需求。",
+      },
+      cta: {
+        type: "string",
+        description: "结尾行动号召，例如“开始体验”。",
+      },
+      outputName: {
+        type: "string",
+        description: "输出文件名，建议以 .mp4 结尾。",
+      },
+    },
+  },
+};
+
+export const remotionRenderVideoFunc = async (
+  args: RemotionRenderVideoArgs,
+  thunkApi: any
+): Promise<{ rawData: any; displayData: string; llmContext?: string }> => {
+  const result: any = await callToolApi(
+    thunkApi,
+    "/api/remotion/render",
+    {
+      template: args.template || "mobile-product",
+      brand: args.brand,
+      hook: args.hook,
+      headline: args.headline,
+      subline: args.subline,
+      prompt: args.prompt,
+      cta: args.cta,
+      outputName: args.outputName,
+    },
+    { withAuth: true }
+  );
+
+  const state = thunkApi.getState();
+  const userId = selectUserId(state);
+  const spaceId = selectCurrentSpaceId(state);
+  const currentServer = selectCurrentServer(state);
+  const fileId = result?.fileId;
+  const metadata = result?.metadata || {};
+  const fileDbKey = userId && fileId ? fileKey.single(userId, fileId) : "";
+  const url = buildDatabaseFileContentUrl(currentServer, fileDbKey || fileId);
+
+  if (spaceId && fileDbKey) {
+    try {
+      await addContentAction(
+        {
+          spaceId,
+          contentKey: fileDbKey,
+          title: metadata.originalName || "Remotion video.mp4",
+          type: ContentType.FILE,
+          fileCategory: "video",
+        } as any,
+        { dispatch: thunkApi.dispatch, getState: thunkApi.getState }
+      );
+    } catch (error) {
+      console.warn("[remotionRenderVideoFunc] Failed to add video to space:", error);
+    }
+  }
+
+  const displayLines = [
+    result?.text || "已使用 Remotion 生成视频。",
+    fileId ? `- fileId: ${fileId}` : "",
+    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
+    url ? `- url: ${url}` : "",
+    metadata?.size ? `- size: ${metadata.size} bytes` : "",
+    result?.template ? `- template: ${result.template}` : "",
+  ].filter(Boolean);
+
+  const llmContext = [
+    "The Remotion video tool produced a reusable video file.",
+    "Reuse these exact references when mentioning or embedding the video:",
+    fileId ? `- fileId: ${fileId}` : "",
+    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
+    url ? `- url: ${url}` : "",
+    metadata?.originalName ? `- name: ${metadata.originalName}` : "",
+    result?.template ? `- template: ${result.template}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return {
+    rawData: {
+      ...result,
+      fileDbKey,
+      url,
+    },
+    displayData: displayLines.join("\n"),
+    llmContext,
+  };
+};

package/ai/tools/searchDialogMessagesTool.ts

@@ -0,0 +1,222 @@
+import { extractCustomId } from "core/prefix";
+import { selectRuntimeSnapshot } from "app/stateViews/runtime";
+import {
+  buildDialogMessageSearchResults,
+  clampDialogSearchNumber,
+  formatDialogMessageSearchDisplay,
+  normalizeDialogSearchText,
+  type DialogMessageSearchRecord,
+} from "./dialogMessageSearch";
+
+type SearchDialogMessagesArgs = {
+  dialogKey: string;
+  query: string;
+  limit?: number;
+  scanLimit?: number;
+  contextMessages?: number;
+  role?: "user" | "assistant" | "tool" | "system";
+  includeTools?: boolean;
+};
+
+const MAX_LIMIT = 10;
+const MAX_CONTEXT_MESSAGES = 3;
+const MAX_CONTENT_CHARS = 1800;
+const CONTEXT_CONTENT_CHARS = 600;
+const SERVER_SCAN_LIMIT = 500;
+
+const getMessageSortValue = (message: DialogMessageSearchRecord) => {
+  const createdAt = message.createdAt;
+  if (typeof createdAt === "number") return createdAt;
+  if (typeof createdAt === "string") {
+    const parsed = Date.parse(createdAt);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const id = normalizeDialogSearchText(message.id);
+  return id ? id : normalizeDialogSearchText(message.dbKey);
+};
+
+async function collectDialogMessages(db: any, dialogId: string): Promise<DialogMessageSearchRecord[]> {
+  if (!db?.iterator) return [];
+  const prefix = `dialog-${dialogId}-msg-`;
+  let iterator = db.iterator({
+    gte: prefix,
+    lte: `${prefix}\uffff`,
+  });
+  if (iterator && typeof iterator.then === "function") {
+    iterator = await iterator;
+  }
+
+  const messages: DialogMessageSearchRecord[] = [];
+  for await (const [key, value] of iterator) {
+    if (!value || typeof value !== "object") continue;
+    messages.push({
+      ...(value as DialogMessageSearchRecord),
+      dbKey: (value as DialogMessageSearchRecord).dbKey || String(key),
+    });
+  }
+
+  return messages.sort((a, b) => {
+    const left = getMessageSortValue(a);
+    const right = getMessageSortValue(b);
+    if (typeof left === "number" && typeof right === "number") return left - right;
+    return String(left).localeCompare(String(right));
+  });
+}
+
+async function fetchDialogMessagesFromServer(args: {
+  serverBase: string;
+  token?: string;
+  dialogId: string;
+  limit: number;
+}): Promise<DialogMessageSearchRecord[]> {
+  const serverBase = args.serverBase.replace(/\/+$/, "");
+  if (!serverBase || !args.token) return [];
+
+  const response = await fetch(`${serverBase}/rpc/getConvMsgs`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ dialogId: args.dialogId, limit: args.limit }),
+  });
+  if (!response.ok) return [];
+
+  const newestFirst = await response.json();
+  if (!Array.isArray(newestFirst)) return [];
+  return [...newestFirst].reverse().map((message) => ({
+    ...(message as DialogMessageSearchRecord),
+    dbKey: (message as DialogMessageSearchRecord).dbKey,
+  }));
+}
+
+async function collectBestAvailableDialogMessages(
+  db: any,
+  dialogId: string,
+  thunkApi: any,
+  scanLimit: number,
+): Promise<DialogMessageSearchRecord[]> {
+  const localMessages = await collectDialogMessages(db, dialogId);
+  const state = thunkApi?.getState?.();
+  const runtime = state ? selectRuntimeSnapshot(state) : null;
+  const serverBases = Array.from(new Set([
+    runtime?.localRuntimeOrigin,
+    runtime?.currentServer,
+    ...(Array.isArray(runtime?.syncServers) ? runtime.syncServers : []),
+  ].filter((base): base is string => typeof base === "string" && base.trim().length > 0)));
+
+  let bestMessages = localMessages;
+  for (const serverBase of serverBases) {
+    const serverMessages = await fetchDialogMessagesFromServer({
+      serverBase,
+      token: runtime?.currentToken,
+      dialogId,
+      limit: scanLimit,
+    }).catch(() => []);
+    if (serverMessages.length > bestMessages.length) {
+      bestMessages = serverMessages;
+    }
+  }
+
+  return bestMessages;
+}
+
+export const searchDialogMessagesFunctionSchema = {
+  name: "searchDialogMessages",
+  description: [
+    "Search original messages inside a specific dialog by exact or fuzzy text.",
+    "Use this when a user asks for an exact old message, original wording, who said what, why a decision was made, early-history detail, failed attempts, files or tool evidence, or comparison with prior work from an attached conversation.",
+    "Prefer this over answering from a lossy dialog summary when the user needs evidence, provenance, or a specific prior detail.",
+    "Returns matching message ids, roles, clipped original content, and nearby context without loading the full dialog into the model context.",
+  ].join(" "),
+  parameters: {
+    type: "object",
+    properties: {
+      dialogKey: {
+        type: "string",
+        description: "Dialog dbKey, for example dialog-userId-01ABC...",
+      },
+      query: {
+        type: "string",
+        description: "Text to search for in original message content.",
+      },
+      limit: {
+        type: "number",
+        description: `Maximum matches to return. Capped at ${MAX_LIMIT}.`,
+      },
+      scanLimit: {
+        type: "number",
+        description: `Maximum messages to scan when fetching from a server. Capped at ${SERVER_SCAN_LIMIT}.`,
+      },
+      contextMessages: {
+        type: "number",
+        description: `Number of neighboring messages before/after each match. Capped at ${MAX_CONTEXT_MESSAGES}.`,
+      },
+      role: {
+        type: "string",
+        enum: ["user", "assistant", "tool", "system"],
+        description: "Optional role filter.",
+      },
+      includeTools: {
+        type: "boolean",
+        description: "Whether tool messages may match. Defaults to true.",
+      },
+    },
+    required: ["dialogKey", "query"],
+  },
+};
+
+export async function searchDialogMessagesFunc(
+  args: SearchDialogMessagesArgs,
+  _thunkApi: any,
+  context?: { db?: any }
+) {
+  const dialogKey = normalizeDialogSearchText(args?.dialogKey);
+  const query = normalizeDialogSearchText(args?.query);
+  if (!dialogKey.startsWith("dialog-")) {
+    throw new Error("searchDialogMessages requires a dialog-* dbKey.");
+  }
+  if (!query) {
+    throw new Error("searchDialogMessages requires a non-empty query.");
+  }
+
+  const db = context?.db ?? _thunkApi?.extra?.db;
+  if (!db) {
+    throw new Error("searchDialogMessages cannot access the local message database.");
+  }
+
+  const dialogId = extractCustomId(dialogKey) || dialogKey.split("-").at(-1) || "";
+  const scanLimit = clampDialogSearchNumber(
+    args.scanLimit,
+    SERVER_SCAN_LIMIT,
+    1,
+    SERVER_SCAN_LIMIT,
+  );
+  const messages = await collectBestAvailableDialogMessages(db, dialogId, _thunkApi, scanLimit);
+  const limit = clampDialogSearchNumber(args.limit, 5, 1, MAX_LIMIT);
+  const contextMessages = clampDialogSearchNumber(args.contextMessages, 1, 0, MAX_CONTEXT_MESSAGES);
+
+  const results = buildDialogMessageSearchResults({
+    messages,
+    query,
+    limit,
+    contextMessages,
+    role: args.role,
+    includeTools: args.includeTools,
+    contentClipChars: MAX_CONTENT_CHARS,
+    contextClipChars: CONTEXT_CONTENT_CHARS,
+  });
+
+  const displayData = formatDialogMessageSearchDisplay({ dialogKey, query, results });
+
+  return {
+    rawData: {
+      success: true,
+      dialogKey,
+      query,
+      scannedMessages: messages.length,
+      matches: results,
+    },
+    displayData,
+  };
+}