nolo-cli 0.1.29 → 0.1.31

package/chat/dialog/objectAssistantRegistry.ts

@@ -120,8 +120,8 @@ export const buildBuiltinObjectAssistantAgent = (
     model: FIREWORKS_KIMI_LATEST_MODEL,
     apiSource: "platform" as const,
     useServerProxy: true,
-    inputPrice: 7.6,
-    outputPrice: 32,
+    inputPrice: 0.95 * 8,
+    outputPrice: 4 * 8,
     createdAt: now,
     updatedAt: now,
     dialogCount: 0,

package/chat/dialog/useCreateDialog.ts

@@ -42,7 +42,7 @@ export const useCreateDialog = (): UseCreateDialogResult => {
       });
       setIsSuccess(true);
     } catch (error) {
-      // 错误处理
+      throw error;
     } finally {
       setIsLoading(false);
     }

package/chat/hooks/useChatInput.ts

@@ -1,4 +1,4 @@
-import { useState, useCallback } from "react";
+import { useState, useCallback, useEffect, useRef } from "react";
 import { nanoid } from "nanoid";
 import { readFileAsDataURL } from "../../app/utils/fileReaders";
 
@@ -25,6 +25,29 @@ export const useChatInput = (options: UseChatInputOptions = {}) => {
     const [text, setText] = useState(initialText);
     const [imageFiles, setImageFiles] = useState<Map<string, File>>(new Map());
     const [imgPreviews, setImgPreviews] = useState<PendingImagePreview[]>([]);
+    const objectUrlByIdRef = useRef<Map<string, string>>(new Map());
+
+    const revokePreviewUrl = useCallback((id: string) => {
+        const url = objectUrlByIdRef.current.get(id);
+        if (!url) return;
+
+        if (typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+            URL.revokeObjectURL(url);
+        }
+        objectUrlByIdRef.current.delete(id);
+    }, []);
+
+    const revokeAllPreviewUrls = useCallback(() => {
+        for (const id of objectUrlByIdRef.current.keys()) {
+            revokePreviewUrl(id);
+        }
+    }, [revokePreviewUrl]);
+
+    useEffect(() => {
+        return () => {
+            revokeAllPreviewUrls();
+        };
+    }, [revokeAllPreviewUrls]);
 
     const handleTextChange = useCallback(
         (newText: string) => {
@@ -54,13 +77,19 @@ export const useChatInput = (options: UseChatInputOptions = {}) => {
             allowedFiles.forEach((file) => {
                 const id = nanoid();
 
-                readFileAsDataURL(file)
-                    .then((url) => {
-                        setImgPreviews((prev) => [...prev, { id, url }]);
-                    })
-                    .catch((err) => {
-                        console.warn("[useChatInput] readFileAsDataURL failed:", err);
-                    });
+                if (typeof URL !== "undefined" && typeof URL.createObjectURL === "function") {
+                    const url = URL.createObjectURL(file);
+                    objectUrlByIdRef.current.set(id, url);
+                    setImgPreviews((prev) => [...prev, { id, url }]);
+                } else {
+                    readFileAsDataURL(file)
+                        .then((url) => {
+                            setImgPreviews((prev) => [...prev, { id, url }]);
+                        })
+                        .catch((err) => {
+                            console.warn("[useChatInput] readFileAsDataURL failed:", err);
+                        });
+                }
 
                 setImageFiles((prev) => {
                     const next = new Map(prev);
@@ -73,19 +102,21 @@ export const useChatInput = (options: UseChatInputOptions = {}) => {
     );
 
     const removeImage = useCallback((id: string) => {
+        revokePreviewUrl(id);
         setImgPreviews((prev) => prev.filter((img) => img.id !== id));
         setImageFiles((prev) => {
             const next = new Map(prev);
             next.delete(id);
             return next;
         });
-    }, []);
+    }, [revokePreviewUrl]);
 
     const clear = useCallback(() => {
+        revokeAllPreviewUrls();
         setText("");
         setImgPreviews([]);
         setImageFiles(new Map());
-    }, []);
+    }, [revokeAllPreviewUrls]);
 
     return {
         text,

package/chat/messages/messageSlice.ts

@@ -788,6 +788,8 @@ export const messageSlice = createSliceWithThunks({
             ? agentConfig.name.trim()
             : "";
         const agentName = rawName || undefined;
+        const { imageGenerationState: _transientImageGenerationState, ...persistedMessageMetadata } =
+          payload.messageMetadata ?? {};
 
         const finalMessage: Message = {
           id: messageId,
@@ -799,7 +801,7 @@ export const messageSlice = createSliceWithThunks({
           cybotKey: agentConfig.dbKey,
           usage: finalUsageData,
           isStreaming: false,
-          ...(payload.messageMetadata ?? {}),
+          ...persistedMessageMetadata,
           ...(agentName ? { agentName } : {}),
           ...(toolCalls && toolCalls.length > 0
             ? { tool_calls: toolCalls }
@@ -916,6 +918,7 @@ export const messageSlice = createSliceWithThunks({
             id: action.payload.id,
             changes: {
               isStreaming: false,
+              imageGenerationState: undefined,
               content: action.payload.content,
               thinkContent: action.payload.thinkContent,
               usage: action.payload.usage,
@@ -980,6 +983,7 @@ export const messageSlice = createSliceWithThunks({
               id: messageId,
               changes: {
                 isStreaming: false,
+                imageGenerationState: undefined,
                 content: appendSaveFailureToContent(
                   dialogState.msgs.entities[messageId]?.content
                 ),

package/chat/messages/pendingAttachmentParts.ts

@@ -75,7 +75,9 @@ export const pendingAttachmentsToMessageParts = (
   files: PendingAttachmentLike[],
   args: { currentServer?: string | null }
 ): PendingAttachmentMessagePart[] =>
-  files.flatMap((file) => pendingAttachmentToMessageParts(file, args));
+  deduplicatePendingAttachments(files).flatMap((file) =>
+    pendingAttachmentToMessageParts(file, args)
+  );
 
 export const resolvePendingAttachmentToMessageParts = async (
   file: PendingAttachmentLike,
@@ -111,7 +113,31 @@ export const resolvePendingAttachmentsToMessageParts = async (
   }
 ): Promise<PendingAttachmentMessagePart[]> => {
   const nested = await Promise.all(
-    files.map((file) => resolvePendingAttachmentToMessageParts(file, args))
+    deduplicatePendingAttachments(files).map((file) =>
+      resolvePendingAttachmentToMessageParts(file, args)
+    )
   );
   return nested.flat();
 };
+
+const pendingAttachmentIdentity = (file: PendingAttachmentLike): string => {
+  return (
+    normalizeText(file.pageKey) ||
+    normalizeText(file.sourceDialogKey) ||
+    normalizeText(file.dialogKey)
+  );
+};
+
+export const deduplicatePendingAttachments = (
+  files: PendingAttachmentLike[]
+): PendingAttachmentLike[] => {
+  const seen = new Set<string>();
+  const result: PendingAttachmentLike[] = [];
+  for (const file of files) {
+    const identity = pendingAttachmentIdentity(file);
+    if (identity && seen.has(identity)) continue;
+    if (identity) seen.add(identity);
+    result.push(file);
+  }
+  return result;
+};

package/chat/messages/sendFirstMessage.ts

@@ -4,7 +4,7 @@ import type { AgentRuntimeOptions } from "../../ai/agent/types";
 import { handleSendMessage } from "../dialog/dialogSlice";
 import { upload } from "../../database/dbSlice";
 import { getRuntimeServerContext } from "../../database/runtimeServerContext";
-import { waitForFileReady, compressImage, dataURLtoFile } from "../../app/utils/imageUtils";
+import { waitForFileReady, compressImageFile } from "../../app/utils/imageUtils";
 import { readFileAsDataURL } from "../../app/utils/fileReaders";
 import type { RootState } from "../../app/store";
 import { buildMessageFileContentUrl, isLocalFileContentUrl } from "./fileUrl";
@@ -41,6 +41,36 @@ const logQuickChatPerfStage = (
     });
 };
 
+const IMAGE_PREP_CONCURRENCY = 2;
+
+const mapWithConcurrency = async <T, R>(
+    items: T[],
+    concurrency: number,
+    mapper: (item: T, index: number) => Promise<R>
+): Promise<R[]> => {
+    if (items.length === 0) return [];
+
+    const results = new Array<R>(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, items.length);
+
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const currentIndex = nextIndex++;
+            if (currentIndex >= items.length) return;
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    });
+
+    await Promise.all(workers);
+    return results;
+};
+
+const buildInlineImagePart = async (file: File): Promise<MessagePart> => ({
+    type: "image_url",
+    image_url: { url: await readFileAsDataURL(file) },
+});
+
 /**
  * 发送一条首条消息：
  * - 支持文字 + 图片 + 文档混合
@@ -84,86 +114,53 @@ export const sendFirstMessage =
             // 当前文档逻辑是通过 “pendingFiles + addReferenceKeysAction + createPage”等实现的，
             // 如需首页入口支持文档首条消息，请把那部分逻辑抽成复用函数后在这里调用。
 
-            // 2. 处理图片 files：基本复制 MessageInputContainer 中 compress+upload 的逻辑
-            const uploadedImgs: MessagePart[] = [];
-
-            for (const file of imageFiles) {
-                // 2.1 先得到本地 dataURL，用于压缩与 fallback
-                const dataUrl = await readFileAsDataURL(file).catch(() => null);
-                if (!dataUrl) continue;
-
-                let compressedDataUrl = dataUrl;
-                let uploadFile: File | null = file;
-
-                try {
-                    compressedDataUrl = await compressImage(dataUrl);
-                    const filename = file.name || `chat-image-${Date.now()}.png`;
-                    const maybeFile = dataURLtoFile(compressedDataUrl, filename);
-                    if (maybeFile) {
-                        uploadFile = maybeFile;
+            // 2. 处理图片 files：优先直传压缩后的 File，只有 fallback 时才转 data URL
+            const uploadedImgs = await mapWithConcurrency(
+                imageFiles,
+                IMAGE_PREP_CONCURRENCY,
+                async (file): Promise<MessagePart> => {
+                    const uploadFile = await compressImageFile(file);
+
+                    try {
+                        const metadata = await dispatch(
+                            upload({
+                                file: uploadFile,
+                                customKey: `chat-image-${Date.now()}`,
+                            }) as any
+                        ).unwrap();
+                        const fileId = metadata?.id as string | undefined;
+
+                        if (!fileId || !currentServer) {
+                            return buildInlineImagePart(uploadFile);
+                        }
+
+                        const imageUrl = buildMessageFileContentUrl(currentServer, fileId);
+                        if (!imageUrl) {
+                            return buildInlineImagePart(uploadFile);
+                        }
+
+                        if (isLocalFileContentUrl(imageUrl)) {
+                            return buildInlineImagePart(uploadFile);
+                        }
+
+                        const ready = await waitForFileReady(imageUrl);
+                        if (!ready) {
+                            return buildInlineImagePart(uploadFile);
+                        }
+
+                        return {
+                            type: "image_url",
+                            image_url: { url: imageUrl },
+                        };
+                    } catch (error) {
+                        console.warn(
+                            "[sendFirstMessage] image upload failed, falling back to inline data URL",
+                            error
+                        );
+                        return buildInlineImagePart(uploadFile);
                     }
-                } catch {
-                    // 压缩失败就用原图
                 }
-
-                if (!uploadFile) {
-                    uploadedImgs.push({
-                        type: "image_url",
-                        image_url: { url: compressedDataUrl },
-                    });
-                    continue;
-                }
-
-                const metadata = await dispatch(
-                    upload({
-                        file: uploadFile,
-                        customKey: `chat-image-${Date.now()}`,
-                    }) as any
-                ).unwrap();
-                const fileId = metadata?.id as string | undefined;
-
-                if (!fileId || !currentServer) {
-                    uploadedImgs.push({
-                        type: "image_url",
-                        image_url: { url: compressedDataUrl },
-                    });
-                    continue;
-                }
-
-                const imageUrl = buildMessageFileContentUrl(currentServer, fileId);
-                if (!imageUrl) {
-                    uploadedImgs.push({
-                        type: "image_url",
-                        image_url: { url: compressedDataUrl },
-                    });
-                    continue;
-                }
-
-                const isLocalhost = isLocalFileContentUrl(imageUrl);
-
-                // 如果是 localhost，AI 无法访问，改用 base64
-                if (isLocalhost) {
-                    uploadedImgs.push({
-                        type: "image_url",
-                        image_url: { url: compressedDataUrl },
-                    });
-                    continue;
-                }
-
-                const ready = await waitForFileReady(imageUrl);
-                if (!ready) {
-                    uploadedImgs.push({
-                        type: "image_url",
-                        image_url: { url: compressedDataUrl },
-                    });
-                    continue;
-                }
-
-                uploadedImgs.push({
-                    type: "image_url",
-                    image_url: { url: imageUrl },
-                });
-            }
+            );
 
             const finalParts: MessagePart[] = [
                 ...parts,

package/chat/messages/types.ts

@@ -46,6 +46,14 @@ export interface CompletionUsage {
 
 export type Content = string | MessageContentPart[];
 
+export interface ImageGenerationState {
+  kind: "image_generation";
+  stage: "submitted" | "generating" | "saving";
+  startedAt: number;
+  waitHint?: string;
+  profileLabel?: string;
+}
+
 // ========== 消息级 UI 选项（Agent 菜单 / 快速回复 等） ==========
 
 export type UiOptionSource = "agent_menu" | "llm" | "system" | "tool";
@@ -142,6 +150,7 @@ export interface Message {
   agentName?: string;
 
   isStreaming?: boolean;
+  imageGenerationState?: ImageGenerationState;
   userId?: string;
   usage?: any;
 

package/chat/messages/web/streamingMarkdownModel.ts

@@ -0,0 +1,41 @@
+import { markdownToSlate } from "../../../create/editor/transforms/markdownToSlate";
+
+type StreamingMarkdownModel =
+  | { kind: "plain-text"; content: string }
+  | { kind: "structured"; nodes: any[] };
+
+function isPlainTextLeaf(node: any): boolean {
+  return (
+    typeof node?.text === "string" &&
+    Object.keys(node).every((key) => key === "text")
+  );
+}
+
+function isPlainTextParagraph(node: any): boolean {
+  return (
+    node?.type === "paragraph" &&
+    Array.isArray(node.children) &&
+    node.children.every(isPlainTextLeaf)
+  );
+}
+
+export function buildStreamingMarkdownModel(content: string): StreamingMarkdownModel {
+  if (!content) {
+    return { kind: "plain-text", content };
+  }
+
+  try {
+    const nodes = markdownToSlate(content) || [];
+    if (nodes.length === 1 && isPlainTextParagraph(nodes[0])) {
+      return { kind: "plain-text", content };
+    }
+
+    if (nodes.length > 0) {
+      return { kind: "structured", nodes };
+    }
+  } catch {
+    // Fall through to plain-text rendering when markdown parsing fails.
+  }
+
+  return { kind: "plain-text", content };
+}

package/chat/messages/web/useStreamingReveal.ts

@@ -0,0 +1,91 @@
+import { useEffect, useRef, useState } from "react";
+
+const STREAMING_SOFT_REVEAL_THRESHOLD = 8;
+const STREAMING_SOFT_REVEAL_LEAD_MIN = 12;
+const STREAMING_SOFT_REVEAL_LEAD_MAX = 24;
+const STREAMING_SOFT_REVEAL_LEAD_RATIO = 0.4;
+const STREAMING_SOFT_REVEAL_SETTLE_DELAY_MS = 36;
+
+export function splitVisibleCharacters(content: string): string[] {
+  const Segmenter = Intl.Segmenter;
+  if (typeof Segmenter === "function") {
+    const segmenter = new Segmenter(undefined, { granularity: "grapheme" });
+    return Array.from(segmenter.segment(content), (part) => part.segment);
+  }
+  return Array.from(content);
+}
+
+function getSoftRevealCharacterCount(currentCount: number, targetCount: number): number {
+  const appendedCount = targetCount - currentCount;
+  if (appendedCount <= STREAMING_SOFT_REVEAL_THRESHOLD) {
+    return targetCount;
+  }
+
+  const leadCount = Math.min(
+    STREAMING_SOFT_REVEAL_LEAD_MAX,
+    Math.max(
+      STREAMING_SOFT_REVEAL_LEAD_MIN,
+      Math.ceil(appendedCount * STREAMING_SOFT_REVEAL_LEAD_RATIO)
+    )
+  );
+
+  return Math.min(targetCount, currentCount + leadCount);
+}
+
+export function useStreamingReveal(content: string): string {
+  const [visibleContent, setVisibleContent] = useState(content);
+  const visibleContentRef = useRef(content);
+  const revealTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    visibleContentRef.current = visibleContent;
+  }, [visibleContent]);
+
+  useEffect(() => {
+    if (revealTimerRef.current) {
+      clearTimeout(revealTimerRef.current);
+      revealTimerRef.current = null;
+    }
+
+    const currentVisible = visibleContentRef.current;
+    if (currentVisible === content) return;
+
+    if (currentVisible && !content.startsWith(currentVisible)) {
+      visibleContentRef.current = content;
+      setVisibleContent(content);
+      return;
+    }
+
+    const targetCharacters = splitVisibleCharacters(content);
+    const visibleCharacters = splitVisibleCharacters(currentVisible);
+    const nextCount = getSoftRevealCharacterCount(
+      visibleCharacters.length,
+      targetCharacters.length
+    );
+
+    if (nextCount >= targetCharacters.length) {
+      visibleContentRef.current = content;
+      setVisibleContent(content);
+      return;
+    }
+
+    const partialContent = targetCharacters.slice(0, nextCount).join("");
+    visibleContentRef.current = partialContent;
+    setVisibleContent(partialContent);
+
+    revealTimerRef.current = setTimeout(() => {
+      revealTimerRef.current = null;
+      visibleContentRef.current = content;
+      setVisibleContent(content);
+    }, STREAMING_SOFT_REVEAL_SETTLE_DELAY_MS);
+
+    return () => {
+      if (revealTimerRef.current) {
+        clearTimeout(revealTimerRef.current);
+        revealTimerRef.current = null;
+      }
+    };
+  }, [content]);
+
+  return visibleContent;
+}

package/chat/web/messageInputAgentUi.ts

@@ -21,12 +21,36 @@ export interface ImageUiConfig {
   supportedAspectRatios: string[];
   supportedImageSizes: ("1K" | "2K" | "4K")[];
   pricePerImage?: number;
+  waitHint?: string;
+  defaultImageProfileKey?: ImageProfileOption["key"];
+  imageProfiles?: ImageProfileOption[];
   pricingModel?: Pick<
     Model,
     "pricePerImage" | "imageTokenPricePerMillion" | "imageOutputTokenEstimateBySize"
   >;
 }
 
+export interface ImageProfileOption {
+  key: "speed" | "quality";
+  label: string;
+  imageModelOverride: string;
+  waitHint?: string;
+  pricePerImage?: number;
+  pricingModel?: Pick<
+    Model,
+    "pricePerImage" | "imageTokenPricePerMillion" | "imageOutputTokenEstimateBySize"
+  >;
+}
+
+const formatImageWaitHint = (
+  range?: Model["imageGenerationWaitTimeSeconds"]
+) => {
+  if (!range || typeof range.min !== "number" || typeof range.max !== "number") {
+    return undefined;
+  }
+  return `通常需要 ${range.min}-${range.max} 秒`;
+};
+
 export function normalizeFavoriteAgentSummary(
   agentKey: string,
   agent: Pick<Agent, "name"> | null | undefined
@@ -95,6 +119,65 @@ function resolveAgentModelIdentity(agent: Partial<Agent>) {
   return { providerKey, modelConfig };
 }
 
+function toPricingModel(
+  modelConfig: Model | null | undefined
+): ImageUiConfig["pricingModel"] | undefined {
+  if (!modelConfig) return undefined;
+  return {
+    pricePerImage: modelConfig.pricePerImage,
+    imageTokenPricePerMillion: modelConfig.imageTokenPricePerMillion,
+    imageOutputTokenEstimateBySize:
+      modelConfig.imageOutputTokenEstimateBySize,
+  };
+}
+
+function resolveImageProfiles(args: {
+  providerKey: string;
+  modelConfig: Model | null;
+}): {
+  imageProfiles: ImageProfileOption[];
+  defaultImageProfileKey?: ImageProfileOption["key"];
+} {
+  const { providerKey, modelConfig } = args;
+  if (!modelConfig?.imageGenerationProfiles?.length) {
+    return { imageProfiles: [] };
+  }
+
+  const imageProfiles = modelConfig.imageGenerationProfiles.flatMap((profile) => {
+    let profileModelConfig: Model | null = null;
+    try {
+      profileModelConfig = getModelConfig(
+        providerKey as Provider,
+        profile.imageModel
+      );
+    } catch {
+      profileModelConfig = null;
+    }
+
+    const pricingModel = toPricingModel(profileModelConfig);
+    return [
+      {
+        key: profile.key,
+        label: profile.label,
+        imageModelOverride: profile.imageModel,
+        waitHint:
+          formatImageWaitHint(profile.waitTimeSeconds) ??
+          formatImageWaitHint(profileModelConfig?.imageGenerationWaitTimeSeconds),
+        pricingModel,
+        pricePerImage:
+          getApproxPricePerImage(pricingModel, undefined) ?? undefined,
+      },
+    ];
+  });
+
+  return {
+    imageProfiles,
+    defaultImageProfileKey: modelConfig.imageGenerationProfiles.find(
+      (profile) => profile.imageModel === modelConfig.name
+    )?.key,
+  };
+}
+
 export function resolveMessageInputAgentUi(input: {
   agent: Partial<Agent>;
   userId: string | null;
@@ -148,6 +231,9 @@ export function resolveMessageInputAgentUi(input: {
         supportsImageConfig: false,
         supportedAspectRatios: [],
         supportedImageSizes: [],
+        waitHint: undefined,
+        defaultImageProfileKey: undefined,
+        imageProfiles: [],
         pricingModel: undefined,
       },
     };
@@ -166,12 +252,11 @@ export function resolveMessageInputAgentUi(input: {
     (modelConfig.supportedImageSizes as ("1K" | "2K" | "4K")[]) ??
     (imageMode === "continuous" ? ["1K", "2K"] : ["1K", "2K", "4K"]);
 
-  const pricingModel = {
-    pricePerImage: modelConfig.pricePerImage,
-    imageTokenPricePerMillion: modelConfig.imageTokenPricePerMillion,
-    imageOutputTokenEstimateBySize:
-      modelConfig.imageOutputTokenEstimateBySize,
-  };
+  const pricingModel = toPricingModel(modelConfig);
+  const { imageProfiles, defaultImageProfileKey } = resolveImageProfiles({
+    providerKey,
+    modelConfig,
+  });
 
   return {
     switchModelQueryUserId,
@@ -181,6 +266,9 @@ export function resolveMessageInputAgentUi(input: {
       supportsImageConfig,
       supportedAspectRatios,
       supportedImageSizes,
+      waitHint: formatImageWaitHint(modelConfig.imageGenerationWaitTimeSeconds),
+      defaultImageProfileKey,
+      imageProfiles,
       pricePerImage:
         getApproxPricePerImage(pricingModel, undefined) ?? undefined,
       pricingModel,