nolo-cli 0.1.40 → 0.1.42

package/chat/messages/fetchAndCacheMessages.ts

@@ -0,0 +1,119 @@
+import { Message } from "./types";
+import { fetchMessages as fetchLocalMessages } from "./fetchMessages";
+import { fetchConvMsgs } from "./fetchConvMsgs";
+import { swallowNonAbortError } from "../../app/utils/async";
+import { createKey } from "../../database/keys";
+import { DataType } from "../../create/types";
+import { isTombstoneRecord, shouldReplaceWithNextRecord } from "../../database/tombstones";
+
+type MessageRecord = Message & { deletedAt?: string };
+
+interface FetchAndCacheOptions {
+    db: any; // Local LevelDB instance
+    dialogId: string;
+    dialogKey?: string;
+    limit?: number;
+    beforeKey?: string;
+    token?: string | null;
+    remoteServers?: string[];
+    signal?: AbortSignal;
+}
+
+export const fetchAndCacheMessages = async ({
+    db,
+    dialogId,
+    dialogKey,
+    limit = 50,
+    beforeKey,
+    token,
+    remoteServers = [],
+    signal,
+}: FetchAndCacheOptions): Promise<Message[]> => {
+    // 1. 本地查询
+    const localPromise = fetchLocalMessages(db, dialogId, {
+        limit,
+        beforeKey,
+        throwOnError: false,
+        includeDeleted: true,
+    }).catch(() => [] as MessageRecord[]);
+
+    // 2. 远程查询
+    const remotePromise = (async () => {
+        if (!token || remoteServers.length === 0) return [] as MessageRecord[];
+
+        const results = await Promise.all(
+            remoteServers.map((server) =>
+                swallowNonAbortError(
+                    fetchConvMsgs(
+                        server,
+                        token,
+                        { dialogId, dialogKey, limit, beforeKey },
+                        { signal }
+                    ),
+                    [] as MessageRecord[],
+                    undefined
+                )
+            )
+        );
+        return results.flat() as MessageRecord[];
+    })();
+
+    const [localMsgs, remoteMsgs] = await Promise.all([
+        localPromise,
+        remotePromise,
+    ]);
+
+    const uniqueMap = new Map<string, MessageRecord>();
+
+    // 先放入本地消息
+    localMsgs.forEach((m) => uniqueMap.set(m.id, m));
+
+    const changedMessagesToCache = new Map<string, MessageRecord>();
+
+    // 4. 合并远程消息，并标记需要缓存的新消息
+    remoteMsgs.forEach((m) => {
+        if (!m || !m.id) return;
+
+        const existing = uniqueMap.get(m.id);
+        if (!existing || shouldReplaceWithNextRecord(m, existing)) {
+            uniqueMap.set(m.id, m);
+            changedMessagesToCache.set(m.id, m);
+        }
+    });
+
+    // 5. 将缺失的消息回写到本地 DB
+    if (changedMessagesToCache.size > 0) {
+        try {
+            const ops = Array.from(changedMessagesToCache.values()).map((msg) => {
+                let key = msg.dbKey || (msg as any)._key;
+
+                if (!key) {
+                    key = createKey(DataType.DIALOG, dialogId, "msg", msg.id);
+                }
+
+                return {
+                    type: "put",
+                    key,
+                    value: {
+                        ...msg,
+                        dbKey: key,
+                        type: DataType.MSG,
+                    },
+                };
+            });
+
+            await db.batch(ops);
+        } catch (_error) {
+            // Silently ignore cache write errors
+        }
+    }
+
+    // 6. 排序并返回
+    return Array.from(uniqueMap.values())
+        .filter((message) => !isTombstoneRecord(message))
+        .sort((a, b) => {
+            const tA = new Date((a as any).createdAt || 0).getTime();
+            const tB = new Date((b as any).createdAt || 0).getTime();
+            return tB - tA; // 降序 (Newest First)
+        });
+};

package/chat/messages/fetchConvMsgs.ts

@@ -0,0 +1,51 @@
+const FETCH_TIMEOUT = 5000;
+
+export const fetchConvMsgs = async (
+  server,
+  token,
+  { dialogId, dialogKey, limit, beforeKey },
+  options = {}
+) => {
+  const { signal: externalSignal } = options;
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+  const onExternalAbort = () => controller.abort();
+  externalSignal?.addEventListener("abort", onExternalAbort);
+
+  try {
+    const response = await fetch(`${server}/rpc/getConvMsgs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        dialogId,
+        ...(dialogKey && { dialogKey }),
+        limit,
+        ...(beforeKey && { beforeKey }),
+      }),
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+
+    if (!response.ok) {
+      console.error(`fetchConvMsgs: Failed ${response.status} from ${server}`);
+      return [];
+    }
+
+    const data = await response.json();
+    return Array.isArray(data) ? data : [];
+  } catch (error) {
+    clearTimeout(timeoutId);
+    externalSignal?.removeEventListener("abort", onExternalAbort);
+    // Only re-throw when external signal was aborted (user navigated away)
+    if (externalSignal?.aborted) {
+      throw error;
+    }
+    console.error(`fetchConvMsgs: Error fetching from ${server}:`, error);
+    return [];
+  }
+};

package/chat/messages/fileUrl.ts

@@ -0,0 +1,13 @@
+import {
+  buildDatabaseFileContentUrl,
+  isLocalDatabaseFileContentUrl,
+} from "../../database/fileUrl";
+
+export const buildMessageFileContentUrl = (
+  serverOrigin: string | undefined | null,
+  fileId: string | undefined | null
+): string | null => buildDatabaseFileContentUrl(serverOrigin, fileId);
+
+export const isLocalFileContentUrl = (
+  url: string | null | undefined
+): boolean => isLocalDatabaseFileContentUrl(url);

package/chat/messages/imagePayloadPersistence.ts

@@ -0,0 +1,22 @@
+type ImagePayloadPart = Record<string, any>;
+
+export const stripDurableImageInlinePayload = <T extends ImagePayloadPart>(
+  part: T,
+): T => {
+  if (!part || typeof part !== "object") return part;
+
+  const { original_data_url: _originalDataUrl, ...withoutOriginalDataUrl } =
+    part;
+
+  if (
+    withoutOriginalDataUrl.type !== "image_url" ||
+    !withoutOriginalDataUrl.google_native ||
+    typeof withoutOriginalDataUrl.google_native !== "object"
+  ) {
+    return withoutOriginalDataUrl as T;
+  }
+
+  const { google_native: _googleNative, ...durablePart } =
+    withoutOriginalDataUrl;
+  return durablePart as T;
+};

package/chat/messages/messageAgent.ts

@@ -0,0 +1,8 @@
+import type { Message } from "./types";
+
+export function resolveMessageAgentKey(
+  message: Partial<Message> | null | undefined
+): string | undefined {
+  if (!message) return undefined;
+  return message.agentKey || message.cybotKey;
+}

package/chat/messages/messageContent.ts

@@ -0,0 +1,203 @@
+// 文件路径: packages/chat/messages/messageContent.ts
+
+/*
+ * ==================================================================
+ *  /chat/messages/messageContent.ts
+ *  - 负责处理 AI 流式内容 & 图片上传
+ * ==================================================================
+ */
+
+import type { RootState } from "../../app/store";
+import { upload } from "../../database/dbSlice";
+import { getRuntimeServerContext } from "../../database/runtimeServerContext";
+import { dataURLtoFile, waitForFileReady } from "../../app/utils/imageUtils";
+import { buildMessageFileContentUrl } from "./fileUrl";
+
+import { ContentType } from "../../app/types";
+import { addContentAction } from "../../create/space/content/addContentAction";
+import { stripDurableImageInlinePayload } from "./imagePayloadPersistence";
+
+/** 判断 URL 是否为 data:image 开头的 dataURL */
+const isDataUrlImage = (url: unknown): url is string =>
+  typeof url === "string" && url.startsWith("data:image");
+
+/**
+ * 将生成的 dataURL 图片上传为文件，并返回最终 URL。
+ * 失败时返回 null，避免把大 base64 图片持久化进 message。
+ */
+const uploadGeneratedImageDataUrl = async (
+  url: string,
+  dialogId: string,
+  messageId: string,
+  index: number,
+  dispatch: any,
+  getState: () => RootState,
+  options?: { spaceId?: string; agentName?: string }
+): Promise<string | null> => {
+  const fileName = `generated-image-${dialogId}-${messageId}-${index}.png`;
+  const file = dataURLtoFile(url, fileName);
+
+  if (!file) {
+    console.warn(
+      "[messageContent] dataURLtoFile failed, drop generated image inline payload"
+    );
+    return null;
+  }
+
+  const customKey = `generated-image-${dialogId}-${messageId}-${index}`;
+
+  let metadata: any;
+  try {
+    metadata = await dispatch(upload({ file, customKey }) as any).unwrap();
+  } catch (err) {
+    console.warn(
+      "[messageContent] upload generated image failed, drop inline payload:",
+      err
+    );
+    return null;
+  }
+
+  const state = getState() as RootState;
+  const { currentServer } = getRuntimeServerContext(state);
+  const fileId = (metadata?.dbKey || metadata?.id) as string | undefined;
+
+  if (!currentServer || !fileId) {
+    console.warn(
+      "[messageContent] missing currentServer or fileId, drop inline payload",
+      { currentServer, fileId }
+    );
+    return null;
+  }
+
+  // 如果提供了 spaceId，尝试保存到空间内容
+  if (options?.spaceId) {
+    try {
+      const agentPrefix = options.agentName ? `[${options.agentName}] ` : "";
+      const title = `${agentPrefix}Generated Image ${index + 1}`;
+
+      await addContentAction({
+        spaceId: options.spaceId,
+        contentKey: fileId,
+        title,
+        type: ContentType.IMAGE,
+      }, { dispatch, getState });
+
+      console.log(`[messageContent] Saved generated image to space: ${options.spaceId}`);
+    } catch (err) {
+      console.error("[messageContent] Failed to save generated image to space:", err);
+    }
+  }
+
+  const imageUrl = buildMessageFileContentUrl(currentServer, fileId);
+  if (!imageUrl) {
+    return null;
+  }
+  const ready = await waitForFileReady(imageUrl);
+
+  if (!ready) {
+    console.warn(
+      "[messageContent] uploaded generated image not ready, drop inline payload:",
+      imageUrl
+    );
+    return null;
+  }
+
+  return imageUrl;
+};
+
+/**
+ * 遍历 assistant 的 contentBuffer：
+ * - 对于 type === "image_url" 且 url 是 dataURL 的项：
+ *   - 上传为文件
+ *   - 把 url 替换成正式的文件 URL
+ * - 其他内容保持不变
+ */
+export const normalizeAssistantContentBuffer = async (
+  contentBuffer: any[],
+  dialogId: string,
+  messageId: string,
+  dispatch: any,
+  getState: () => RootState,
+  options?: { spaceId?: string; agentName?: string }
+): Promise<any[]> => {
+  if (!Array.isArray(contentBuffer) || contentBuffer.length === 0) {
+    return contentBuffer;
+  }
+
+  const updated = await Promise.all(
+    contentBuffer.map(async (part, index) => {
+      if (
+        !part ||
+        part.type !== "image_url" ||
+        !part.image_url ||
+        !isDataUrlImage(part.image_url.url)
+      ) {
+        return part;
+      }
+
+      const newUrl = await uploadGeneratedImageDataUrl(
+        part.image_url.url,
+        dialogId,
+        messageId,
+        index,
+        dispatch,
+        getState,
+        options
+      );
+
+      if (!newUrl) {
+        return {
+          type: "text",
+          text: "[图片保存失败，请重试生成图片]",
+        };
+      }
+
+      return stripDurableImageInlinePayload({
+        ...part,
+        image_url: {
+          ...part.image_url,
+          url: newUrl,
+        },
+      });
+    })
+  );
+
+  return updated;
+};
+
+/**
+ * 将 Message.content 归一化为纯文本:
+ * - string → 直接使用
+ * - OpenAI 风格数组 → 拼接 text 片段，image_url 替换为占位符
+ * - 其他 → null
+ *
+ * 共享函数：标题生成 / 摘要生成 / 上下文序列化均可复用
+ */
+export const serializeMessageContent = (
+  content: any,
+  imagePlaceholder = "[图片]"
+): string | null => {
+  if (typeof content === "string") {
+    return content.trim() || null;
+  }
+
+  if (Array.isArray(content)) {
+    const fragments: string[] = [];
+
+    for (const part of content) {
+      if (!part || typeof part !== "object") continue;
+
+      if (part.type === "text" && typeof part.text === "string") {
+        const text = part.text.trim();
+        if (text) fragments.push(text);
+      } else if (part.type === "image_url") {
+        fragments.push(imagePlaceholder);
+      }
+    }
+
+    const joined = fragments.join("\n").trim();
+    return joined || null;
+  }
+
+  return null;
+};

package/chat/messages/messageContract.ts

@@ -0,0 +1,88 @@
+import type { MessageContentPart } from "./types";
+
+type MessageLike = {
+  role?: string;
+  content?: string | MessageContentPart[] | null;
+};
+
+export function separateThinkContent(contentBuffer: MessageContentPart[]) {
+  let thinkContent = "";
+  let normalContent = "";
+
+  const combinedText = contentBuffer
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text)
+    .join("");
+
+  const thinkMatches = combinedText.match(/<think\b[^>]*>(.*?)<\/think>/gis);
+
+  if (thinkMatches) {
+    thinkContent = thinkMatches
+      .map((m) => m.replace(/<think\b[^>]*>|<\/think>/gi, ""))
+      .join("\n\n");
+
+    normalContent = combinedText
+      .replace(/<think\b[^>]*>.*?<\/think>/gis, "")
+      .trim();
+  } else {
+    normalContent = combinedText;
+  }
+
+  return { thinkContent, normalContent };
+}
+
+export function countImageParts(
+  content: string | MessageContentPart[] | null | undefined,
+): number {
+  if (!Array.isArray(content)) return 0;
+  return content.filter((part) => part?.type === "image_url").length;
+}
+
+export function summarizeMessagesForDebug(
+  messages: Array<MessageLike> | null | undefined,
+) {
+  const safeMessages = Array.isArray(messages) ? messages : [];
+  return {
+    count: safeMessages.length,
+    roles: safeMessages.map((message) => message?.role ?? "unknown"),
+    imageMessageCount: safeMessages.filter(
+      (message) => countImageParts(message?.content ?? null) > 0,
+    ).length,
+  };
+}
+
+export function finalizeAssistantMessageContent(
+  normalizedContentBuffer: MessageContentPart[],
+  reasoningBuffer = "",
+) {
+  const { thinkContent: tagThink, normalContent } =
+    separateThinkContent(normalizedContentBuffer);
+
+  const thinkContent = `${tagThink}${reasoningBuffer}`.trim();
+  const hasNonTextParts = normalizedContentBuffer.some(
+    (part) => part && part.type && part.type !== "text",
+  );
+
+  return {
+    thinkContent,
+    textContent: normalContent || "",
+    visibleContent: hasNonTextParts
+      ? normalizedContentBuffer
+      : normalContent || "",
+    hasNonTextParts,
+    imagePartCount: countImageParts(normalizedContentBuffer),
+  };
+}
+
+export function appendSaveFailureToContent(
+  content: string | MessageContentPart[] | null | undefined,
+): string | MessageContentPart[] {
+  const failureText = "[Failed to save message]";
+  if (Array.isArray(content)) {
+    return [...content, { type: "text", text: failureText }];
+  }
+  if (typeof content === "string" && content.length > 0) {
+    return `${content}\n${failureText}`;
+  }
+  return failureText;
+}