nolo-cli 0.1.39 → 0.1.41

package/ai/tools/readXhsProfileTool.ts

@@ -0,0 +1,627 @@
+/**
+ * read_xhs_profile Tool
+ *
+ * Read-only tool for collecting XHS (Xiaohongshu) profile data:
+ * profile info, public notes, note details, and top-level comments.
+ *
+ * Desktop-first: uses Playwright persistent context for login state reuse.
+ * No write actions (no like/comment/follow/collect/post/delete).
+ * Cookies and xsecToken are never exposed in output.
+ * Conservative by default: reads the initially loaded profile state only.
+ * Extra scrolling, detail enrichment, and comments require explicit user intent.
+ * The tool clamps extended collection unless extendedCollectionConsent is true.
+ */
+
+import { createXhsFailure } from "../../integrations/xhs-reader/types";
+import type {
+  XhsReadResult,
+  XhsProfileCollection,
+  XhsCollectionStatus,
+} from "../../integrations/xhs-reader/types";
+import { parseXhsProfileUrl } from "../../integrations/xhs-reader/url";
+import { getRequestConfig, ToolApiError } from "./toolApiClient";
+
+export const readXhsProfileFunctionSchema = {
+  name: "read_xhs_profile",
+  description:
+    "读取小红书用户主页的公开信息。默认只读取页面初始加载出的资料和笔记列表，不自动翻页、不默认抓评论或批量详情。只有当用户明确要求更多笔记、评论或互动明细时，才应显式设置对应参数。默认通过桌面本地 Playwright 持久 profile 读取，不要求用户粘贴 cookie。",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description:
+          "小红书用户主页 URL，例如 https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556。",
+      },
+      maxScrollPages: {
+        type: "number",
+        description:
+          "最大滚动翻页数。默认 0，即只读取页面初始加载状态；只有用户明确要求更多笔记且 extendedCollectionConsent=true 时才设置为 1 或更高。",
+        default: 0,
+      },
+      includeComments: {
+        type: "boolean",
+        description:
+          "是否收集笔记的顶层评论。默认 false；只有用户明确要求评论且 extendedCollectionConsent=true 时才设为 true。",
+        default: false,
+      },
+      maxCommentPagesPerNote: {
+        type: "number",
+        description:
+          "每篇笔记最多收集几页评论（仅当 includeComments=true 时生效）。默认 1。",
+        default: 1,
+      },
+      minLikesForDetail: {
+        type: "number",
+        description:
+          "仅收集点赞数 >= 此值的笔记详情（可选）。只有 extendedCollectionConsent=true 时生效。",
+      },
+      minCommentsForCollect: {
+        type: "number",
+        description:
+          "仅收集评论数 >= 此值的笔记的评论（可选，仅当 includeComments=true 且 extendedCollectionConsent=true 时生效）。",
+      },
+      extendedCollectionConsent: {
+        type: "boolean",
+        description:
+          "扩展采集确认开关。只有用户在本轮明确要求更多笔记、翻页、评论或互动明细时才可设为 true；否则必须省略或为 false。",
+        default: false,
+      },
+      collectionMode: {
+        type: "string",
+        enum: ["conservative", "assisted"],
+        description:
+          "采集模式。默认 conservative；assisted 需要 extendedCollectionConsent=true。",
+        default: "conservative",
+      },
+      assistedAction: {
+        type: "string",
+        enum: ["snapshot", "read_more_notes", "read_comments"],
+        description:
+          "assisted 模式下的具体动作：snapshot 只读快照，read_more_notes 翻页读更多笔记，read_comments 读评论。",
+        default: "snapshot",
+      },
+      maxAssistedSteps: {
+        type: "number",
+        description:
+          "assisted 模式最大步数（1..3）。默认 1，用于约束滚动页数或评论翻页数。",
+        default: 1,
+        minimum: 1,
+        maximum: 3,
+      },
+      profileDir: {
+        type: "string",
+        description:
+          "桌面端本地 Playwright 持久 profile 目录，用于复用小红书登录态。不要传入用户日常 Chrome profile。默认使用专用缓存目录。",
+      },
+      headless: {
+        type: "boolean",
+        description:
+          "是否用 headless 模式启动浏览器。首次登录小红书时需设为 false 并配合 keepOpen。",
+        default: true,
+      },
+      keepOpen: {
+        type: "boolean",
+        description:
+          "调试时是否保持浏览器上下文打开（方便手动登录）。默认 false。",
+        default: false,
+      },
+    },
+    required: ["url"],
+  },
+};
+
+type ReadXhsProfileToolContext = {
+  reader?: (
+    options: ReadXhsProfileArgs,
+  ) => Promise<XhsReadResult<XhsProfileCollection>>;
+};
+
+export interface ReadXhsProfileArgs {
+  url: string;
+  maxScrollPages?: number;
+  includeComments?: boolean;
+  maxCommentPagesPerNote?: number;
+  minLikesForDetail?: number;
+  minCommentsForCollect?: number;
+  extendedCollectionConsent?: boolean;
+  profileDir?: string;
+  headless?: boolean;
+  keepOpen?: boolean;
+  collectionMode?: "conservative" | "assisted";
+  assistedAction?: "snapshot" | "read_more_notes" | "read_comments";
+  maxAssistedSteps?: number;
+}
+
+export function normalizeXhsProfileReadArgs(
+  args: ReadXhsProfileArgs,
+): ReadXhsProfileArgs {
+  const consent = args.extendedCollectionConsent === true;
+
+  if (!consent) {
+    // No consent → force conservative behavior
+    return {
+      ...args,
+      maxScrollPages: 0,
+      includeComments: false,
+      maxCommentPagesPerNote: 1,
+      minLikesForDetail: undefined,
+      minCommentsForCollect: undefined,
+      extendedCollectionConsent: false,
+      collectionMode: "conservative",
+      assistedAction: "snapshot",
+      maxAssistedSteps: 1,
+    };
+  }
+
+  // Consent granted → determine mode
+  const mode = args.collectionMode === "assisted" ? "assisted" : "conservative";
+  const action = args.assistedAction ?? "snapshot";
+  const steps = clamp(args.maxAssistedSteps ?? 1, 1, 3);
+
+  if (mode === "conservative") {
+    // Consent alone is not enough for extended collection. The model must
+    // explicitly select assisted mode so status labels match actual behavior.
+    return {
+      ...args,
+      maxScrollPages: 0,
+      includeComments: false,
+      maxCommentPagesPerNote: 1,
+      minLikesForDetail: undefined,
+      minCommentsForCollect: undefined,
+      extendedCollectionConsent: true,
+      collectionMode: "conservative",
+      assistedAction: "snapshot",
+      maxAssistedSteps: steps,
+    };
+  }
+
+  // Assisted mode with consent: clamp based on action
+  let maxScrollPages = args.maxScrollPages;
+  let includeComments = args.includeComments;
+  let maxCommentPagesPerNote = args.maxCommentPagesPerNote;
+
+  if (action === "read_more_notes") {
+    maxScrollPages = clamp(maxScrollPages ?? steps, 1, steps);
+    includeComments = false;
+  } else if (action === "read_comments") {
+    includeComments = true;
+    maxCommentPagesPerNote = clamp(maxCommentPagesPerNote ?? steps, 1, steps);
+    maxScrollPages = 0;
+  } else {
+    // snapshot: no scrolling, no comments
+    maxScrollPages = 0;
+    includeComments = false;
+    maxCommentPagesPerNote = 1;
+  }
+
+  return {
+    ...args,
+    maxScrollPages,
+    includeComments,
+    maxCommentPagesPerNote,
+    minLikesForDetail: args.minLikesForDetail,
+    minCommentsForCollect: args.minCommentsForCollect,
+    extendedCollectionConsent: true,
+    collectionMode: mode,
+    assistedAction: action,
+    maxAssistedSteps: steps,
+  };
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+function assertXhsProfileUrl(url: string) {
+  // Reuse parseXhsProfileUrl for validation
+  try {
+    parseXhsProfileUrl(url);
+  } catch {
+    throw new Error(
+      "read_xhs_profile 需要一个有效的小红书用户主页 URL（xiaohongshu.com/user/profile/<24位hexID>）。",
+    );
+  }
+}
+
+async function callLocalReadXhsProfileApi(
+  thunkApi: any,
+  body: object,
+): Promise<XhsReadResult<XhsProfileCollection>> {
+  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-xhs-profile`, {
+    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_xhs_profile API 请求失败，状态码: ${response.status}`,
+      {
+        status: response.status,
+        code: data?.error?.code,
+        details: data,
+      },
+    );
+  }
+  return data as XhsReadResult<XhsProfileCollection>;
+}
+
+async function callDesktopReadXhsProfileApi(
+  thunkApi: any,
+  body: object,
+): Promise<XhsReadResult<XhsProfileCollection>> {
+  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-xhs-profile`,
+    {
+      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_xhs_profile API 请求失败，状态码: ${response.status}`,
+      {
+        status: response.status,
+        code: data?.error?.code,
+        details: data,
+      },
+    );
+  }
+  return data as XhsReadResult<XhsProfileCollection>;
+}
+
+async function readWithDefaultBridge(
+  args: ReadXhsProfileArgs,
+  thunkApi?: any,
+): Promise<XhsReadResult<XhsProfileCollection>> {
+  if (process.env.PLATFORM === "web") {
+    if (thunkApi?.getState) {
+      return callLocalReadXhsProfileApi(thunkApi, args);
+    }
+
+    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+      try {
+        const res = await fetch("/api/read-xhs-profile", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(args),
+        });
+        const data = await res.json().catch(() => null);
+        if (res.ok && data) {
+          return data as XhsReadResult<XhsProfileCollection>;
+        }
+        return createXhsFailure({
+          code: "network_error",
+          message: `desktop read_xhs_profile endpoint failed: HTTP ${res.status}`,
+        });
+      } catch (error) {
+        return createXhsFailure({
+          code: "network_error",
+          message:
+            error instanceof Error
+              ? error.message
+              : "desktop read_xhs_profile endpoint request failed",
+        });
+      }
+    }
+
+    return createXhsFailure({
+      code: "network_error",
+      message:
+        "read_xhs_profile 需要通过服务器或桌面本地 bridge 执行，不能在普通浏览器 bundle 内直接启动 Playwright。",
+    });
+  }
+
+  if (process.env.NOLO_DESKTOP === "1" && thunkApi?.getState) {
+    return callDesktopReadXhsProfileApi(thunkApi, args);
+  }
+
+  // Server-side: use bridge directly
+  const importBridge = new Function("specifier", "return import(specifier)") as <
+    T = any,
+  >(
+    specifier: string,
+  ) => Promise<T>;
+  const { readXhsProfileWithBridge } = await importBridge<{
+    readXhsProfileWithBridge: (
+      options: ReadXhsProfileArgs,
+    ) => Promise<XhsReadResult<XhsProfileCollection>>;
+  }>("../../integrations/xhs-reader/bridge/readXhsProfileWithBridge.ts");
+  return readXhsProfileWithBridge(args);
+}
+
+function formatDisplay(result: XhsReadResult<XhsProfileCollection>) {
+  if (!result.ok) {
+    const hints: string[] = [];
+    if (result.code === "login_required") {
+      hints.push(
+        "需要先登录小红书。请在桌面端用 headless=false + keepOpen=true 运行一次，手动完成登录后再次调用即可。",
+      );
+    } else if (result.code === "blocked") {
+      hints.push(
+        "页面被验证码或安全检查拦截。请稍后重试或在桌面端手动处理验证后重试。",
+      );
+    } else if (result.code === "empty_profile_state") {
+      hints.push(
+        "页面加载但未获取到笔记数据。建议：确认该用户有公开笔记；用本地持久 profile 重试；增加 timeoutMs。",
+      );
+    }
+    return [
+      `读取小红书用户主页失败：${result.message}`,
+      `失败代码：${result.code}`,
+      "",
+      "可能的解决步骤：",
+      "- 确认 URL 是有效的小红书用户主页链接",
+      "- 如果是登录问题，请用 headless=false + keepOpen=true 手动登录一次",
+      "- 如果是服务端(headless)环境，确保有有效的已登录 profile 目录",
+      "- 检查 Playwright chromium 是否已安装",
+      ...hints,
+    ]
+      .filter(Boolean)
+      .join("\n");
+  }
+
+  const { profile, notes, noteDetails, analysis } = result.data;
+
+  const parts: string[] = [];
+
+  // Profile summary
+  parts.push(`小红书用户: ${profile.nickname || "未命名"}`);
+  if (profile.redId) parts.push(`小红书号: ${profile.redId}`);
+  if (profile.ipLocation) parts.push(`IP 属地: ${profile.ipLocation}`);
+  if (profile.desc) parts.push(`简介: ${profile.desc}`);
+
+  // Interaction counts
+  const ic = profile.interactionCounts;
+  if (ic) {
+    const counts: string[] = [];
+    if (ic.follows != null) counts.push(`关注 ${ic.follows}`);
+    if (ic.fans != null) counts.push(`粉丝 ${ic.fans}`);
+    if (ic.likesAndCollects != null)
+      counts.push(`获赞与收藏 ${ic.likesAndCollects}`);
+    if (counts.length > 0) parts.push(`互动: ${counts.join(" / ")}`);
+  }
+
+  parts.push("");
+
+  // Notes summary
+  parts.push(`笔记数量: ${analysis.totalNotes}`);
+  if (noteDetails.length > 0) {
+    parts.push(`已获取详情: ${noteDetails.length} 篇`);
+  }
+
+  // Top notes
+  if (analysis.highestLikedNote) {
+    const n = analysis.highestLikedNote;
+    parts.push(
+      `最高点赞: ${n.title ?? n.noteId}（${n.count} 赞）`,
+    );
+  }
+  if (analysis.highestCommentedNote) {
+    const n = analysis.highestCommentedNote;
+    parts.push(
+      `最高评论: ${n.title ?? n.noteId}（${n.count} 评论）`,
+    );
+  }
+  if (analysis.highestCollectedNote) {
+    const n = analysis.highestCollectedNote;
+    parts.push(
+      `最高收藏: ${n.title ?? n.noteId}（${n.count} 收藏）`,
+    );
+  }
+  if (analysis.highestSharedNote) {
+    const n = analysis.highestSharedNote;
+    parts.push(
+      `最高分享: ${n.title ?? n.noteId}（${n.count} 分享）`,
+    );
+  }
+
+  // Comment buckets
+  if (analysis.commentBuckets.length > 0) {
+    parts.push("");
+    parts.push("评论主题分布:");
+    for (const bucket of analysis.commentBuckets) {
+      parts.push(`  - ${bucket.label}: ${bucket.count} 条`);
+    }
+  }
+
+  // Diagnostic info (when profile succeeded but notes collection had issues)
+  if (result.data.diagnostic) {
+    const diag = result.data.diagnostic;
+    parts.push("");
+    parts.push(`⚠ 采集诊断：${diag.code}`);
+    parts.push(`  ${diag.message}`);
+    if (diag.loginDetected) parts.push("  检测到登录提示");
+  }
+
+  // Collection status display
+  if (result.data.collectionStatus) {
+    const cs = result.data.collectionStatus;
+    parts.push("");
+    const modeLabel = cs.mode === "assisted" ? "辅助采集" : "保守模式";
+    const actionLabels: Record<string, string> = {
+      snapshot: "快照",
+      read_more_notes: "读取更多笔记",
+      read_comments: "读取评论",
+    };
+    parts.push(`采集模式: ${modeLabel}`);
+    parts.push(`采集动作: ${actionLabels[cs.action] ?? cs.action}`);
+    if (cs.mode === "assisted") {
+      parts.push(
+        `步数: ${cs.assistedStepCount}/${cs.limits.maxAssistedSteps}`,
+      );
+    }
+    if (cs.nextSuggestedAction) {
+      parts.push(
+        `建议: ${cs.nextSuggestedAction.label} - ${cs.nextSuggestedAction.reason}`,
+      );
+    }
+  }
+
+  return parts.join("\n");
+}
+
+export async function readXhsProfileFunc(
+  args: ReadXhsProfileArgs,
+  thunkApi: any,
+  context: ReadXhsProfileToolContext = {},
+): Promise<{
+  rawData: XhsReadResult<XhsProfileCollection>;
+  displayData: string;
+}> {
+  const url = String(args?.url ?? "").trim();
+  assertXhsProfileUrl(url);
+
+  const readerArgs: ReadXhsProfileArgs = normalizeXhsProfileReadArgs({
+    url,
+    maxScrollPages: args.maxScrollPages,
+    includeComments: args.includeComments,
+    maxCommentPagesPerNote: args.maxCommentPagesPerNote,
+    minLikesForDetail: args.minLikesForDetail,
+    minCommentsForCollect: args.minCommentsForCollect,
+    extendedCollectionConsent: args.extendedCollectionConsent,
+    profileDir: args.profileDir?.trim() || undefined,
+    headless: args.headless,
+    keepOpen: args.keepOpen,
+    collectionMode: args.collectionMode,
+    assistedAction: args.assistedAction,
+    maxAssistedSteps: args.maxAssistedSteps,
+  });
+
+  const rawData =
+    (await context.reader?.(readerArgs)) ??
+    (await readWithDefaultBridge(readerArgs, thunkApi));
+
+  // Build and attach collectionStatus
+  if (rawData.ok) {
+    rawData.data.collectionStatus = buildCollectionStatus(
+      readerArgs,
+      rawData.data,
+    );
+  }
+
+  return {
+    rawData,
+    displayData: formatDisplay(rawData),
+  };
+}
+
+function buildCollectionStatus(
+  args: ReadXhsProfileArgs,
+  data: XhsProfileCollection,
+): XhsCollectionStatus {
+  const mode = args.collectionMode ?? "conservative";
+  const action = args.assistedAction ?? "snapshot";
+  const consent = args.extendedCollectionConsent === true;
+  const steps = args.maxAssistedSteps ?? 1;
+
+  const status: XhsCollectionStatus = {
+    mode,
+    action,
+    extendedCollectionConsent: consent,
+    assistedStepCount: consent && mode === "assisted" ? steps : 0,
+    limits: {
+      maxAssistedSteps: steps,
+      maxScrollPages: args.maxScrollPages ?? 0,
+      maxCommentPagesPerNote: args.maxCommentPagesPerNote ?? 1,
+      includeComments: args.includeComments ?? false,
+    },
+  };
+
+  // Determine next suggested action
+  status.nextSuggestedAction = computeNextSuggestedAction(args, data);
+
+  return status;
+}
+
+function computeNextSuggestedAction(
+  args: ReadXhsProfileArgs,
+  data: XhsProfileCollection,
+): XhsCollectionStatus["nextSuggestedAction"] {
+  const { diagnostic, notes, analysis, commentsByNote } = data;
+  const action = args.assistedAction ?? "snapshot";
+
+  // Login wall or empty state → suggest manual login
+  if (diagnostic?.loginDetected || diagnostic?.code === "login_required") {
+    return {
+      action: "manual_login",
+      label: "手动登录",
+      reason: "检测到登录提示，请先手动登录小红书",
+    };
+  }
+
+  // Few notes and was a snapshot → suggest reading more notes
+  if (notes.length < 5 && action === "snapshot") {
+    return {
+      action: "read_more_notes",
+      label: "读取更多笔记",
+      reason: `当前仅读取 ${notes.length} 篇笔记，可尝试翻页获取更多`,
+    };
+  }
+
+  // Notes with high comment counts but no comments collected
+  const hasHighCommentNotes = notes.some((n) => {
+    // Check noteDetails for comment counts
+    const detail = data.noteDetails.find((d) => d.noteId === n.noteId);
+    return detail && detail.metrics.commentCount > 5;
+  });
+  const hasComments = Object.keys(commentsByNote).length > 0;
+
+  if (
+    (action === "snapshot" || action === "read_more_notes") &&
+    hasHighCommentNotes &&
+    !hasComments
+  ) {
+    return {
+      action: "read_comments",
+      label: "读取评论",
+      reason: "部分笔记评论较多，可以读取评论内容",
+    };
+  }
+
+  // Analysis exists and has data → suggest saving to table
+  if (analysis.totalNotes > 0 && (action === "read_comments" || action === "read_more_notes")) {
+    return {
+      action: "save_to_table",
+      label: "保存到表格",
+      reason: "已采集到数据，可保存到表格以便分析",
+    };
+  }
+
+  return undefined;
+}

package/ai/tools/rememberMemoryTool.ts

@@ -0,0 +1,84 @@
+import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
+import { callToolApi } from "./toolApiClient";
+import type { RememberMemoryScope } from "../memory/remember";
+import type { MemoryKind } from "../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}记忆。`,
+  };
+}