merge: integrate master-nj RAG updates

frontend-web/src/core/agents/types.ts

@@ -61,9 +61,11 @@ export interface Agent {
   /** 会商席位「技能识别强化」开关。作为会商席位运行时，是否把本智能体配置的技能
    * (名称 + SKILL.md 路径 + 必须先 read_file 的硬指令) 拼进本轮任务以补偿弱模型。
    * 与业务链条同名开关取 OR。null/false = 关 (默认)。 */
-  seat_skill_directive?: boolean | null;
-  /** DeerFlow LLMWiki mapping ids this agent allows conversations to select. */
-  llmwiki_knowledge_base_ids?: string[] | null;
+  seat_skill_directive?: boolean | null;
+  /** 岗位职责。会商智能体配置面板展示在常用问题上方。空/缺省 = 未填写。 */
+  job_responsibilities?: string | null;
+  /** DeerFlow LLMWiki mapping ids this agent allows conversations to select. */
+  llmwiki_knowledge_base_ids?: string[] | null;
   tags?: Tag[];
   featured_order?: number | null;
   /** Whether the current user has favorited (收藏) this agent. */
@@ -98,8 +100,10 @@ export interface CreateAgentRequest {
   common_questions?: AgentQuestion[] | null;
   template_name?: string | null;
   /** 会商席位「技能识别强化」开关；缺省/false = 关。 */
-  seat_skill_directive?: boolean | null;
-  llmwiki_knowledge_base_ids?: string[] | null;
+  seat_skill_directive?: boolean | null;
+  /** 岗位职责；缺省/空 = 未填写。 */
+  job_responsibilities?: string | null;
+  llmwiki_knowledge_base_ids?: string[] | null;
 }
 
 export interface UpdateAgentRequest {
@@ -116,6 +120,8 @@ export interface UpdateAgentRequest {
   /** 入库模板名；传空字符串表示清除。 */
   template_name?: string | null;
   /** 会商席位「技能识别强化」开关；缺省/false = 关。 */
-  seat_skill_directive?: boolean | null;
-  llmwiki_knowledge_base_ids?: string[] | null;
-}
+  seat_skill_directive?: boolean | null;
+  /** 岗位职责；传空字符串表示清除。 */
+  job_responsibilities?: string | null;
+  llmwiki_knowledge_base_ids?: string[] | null;
+}

frontend-web/src/core/artifacts/hooks.ts

@@ -6,6 +6,7 @@ import { useThread } from "@/components/workspace/messages/context";
 import { isImageFile } from "../utils/files";
 
 import { loadArtifactContent, loadArtifactContentFromToolCall } from "./loader";
+import { isArtifactApiPath } from "./streaming-write-preview";
 import { updateArtifactContent } from "./api";
 
 function isWriteFileStreamingUrl(filepath: string): boolean {
@@ -101,7 +102,7 @@ export function useArtifactContent({
     queryFn: () => {
       return loadArtifactContent({ filepath, threadId, isMock, publicShareCode });
     },
-    enabled,
+    enabled: Boolean(enabled) && !useWriteFileStreaming && isArtifactApiPath(filepath),
     refetchInterval: thread.isLoading ? 1000 : false,
     // Cache artifact content for 5 minutes to avoid repeated fetches (especially for .skill ZIP extraction)
     staleTime: 5 * 60 * 1000,

frontend-web/src/core/artifacts/streaming-write-preview.test.ts

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  isArtifactApiPath,
+  isProvisionalStreamingArtifactPath,
+  provisionalWriteFilePath,
+} from "./streaming-write-preview";
+
+test("provisionalWriteFilePath uses html only for html documents", () => {
+  assert.equal(provisionalWriteFilePath("# title"), "未命名文件.md");
+  assert.equal(provisionalWriteFilePath("<!DOCTYPE html><html>"), "未命名文件.html");
+  assert.equal(provisionalWriteFilePath("<html lang='zh'>"), "未命名文件.html");
+});
+
+test("isProvisionalStreamingArtifactPath matches the streaming placeholder names", () => {
+  assert.equal(isProvisionalStreamingArtifactPath("未命名文件.md"), true);
+  assert.equal(isProvisionalStreamingArtifactPath("/未命名文件.html"), true);
+  assert.equal(isProvisionalStreamingArtifactPath("mnt/user-data/outputs/report.md"), false);
+});
+
+test("isArtifactApiPath rejects write-file URLs and placeholder names", () => {
+  assert.equal(isArtifactApiPath("未命名文件.md"), false);
+  assert.equal(
+    isArtifactApiPath(
+      "write-file:未命名文件.md?message_id=m1&tool_call_id=t1&language=markdown",
+    ),
+    false,
+  );
+  assert.equal(isArtifactApiPath("mnt/user-data/outputs/report.md"), true);
+  assert.equal(isArtifactApiPath("/mnt/user-data/outputs/report.md"), true);
+});

frontend-web/src/core/artifacts/streaming-write-preview.ts

@@ -23,6 +23,11 @@ export function hasCompleteArtifactExtension(path: string): boolean {
   return /\.[a-z0-9]{2,12}$/i.test(filename);
 }
 
+export const PROVISIONAL_WRITE_FILE_NAMES = new Set([
+  "未命名文件.md",
+  "未命名文件.html",
+]);
+
 export function provisionalWriteFilePath(content: string): string {
   const head = content.slice(0, 256).trimStart().toLowerCase();
   if (head.startsWith("<!doctype html") || head.startsWith("<html")) {
@@ -31,6 +36,29 @@ export function provisionalWriteFilePath(content: string): string {
   return "未命名文件.md";
 }
 
+export function isProvisionalStreamingArtifactPath(path: string): boolean {
+  const pathname =
+    normalizeStreamingArtifactPath(path).split(/[?#]/, 1)[0] ?? "";
+  const filename = pathname.split("/").filter(Boolean).at(-1) ?? "";
+  return PROVISIONAL_WRITE_FILE_NAMES.has(filename);
+}
+
+/** Paths the artifacts HTTP API can actually serve (sandbox virtual paths). */
+export function isArtifactApiPath(path: string): boolean {
+  if (!path || path.startsWith("write-file:")) {
+    return false;
+  }
+  if (isProvisionalStreamingArtifactPath(path)) {
+    return false;
+  }
+  const normalized = path.replace(/^\/+/, "").replace(/\\/g, "/");
+  return (
+    normalized === "mnt/user-data" ||
+    normalized.startsWith("mnt/user-data/") ||
+    normalized.startsWith("mnt/skills/")
+  );
+}
+
 export function languageOfStreamingArtifact(
   path: string,
 ): StreamingArtifactLanguage | null {

frontend-web/src/core/document-rewrite/context.tsx

@@ -6,6 +6,7 @@ import type {
   DocumentRewriteStage,
 } from "@/open-canvas/hooks/useDocumentRewrite";
 import type { DocumentRewriteSummary } from "@/open-canvas/api/rewrite";
+import { createClientId } from "@/lib/client-id";
 
 export type DocumentRewritePresentation = {
   id: string;
@@ -19,11 +20,17 @@ export type DocumentRewritePresentation = {
   instruction: string;
   style: string;
   modelName: string | null;
+  generateImages: boolean;
+  maxGeneratedImages: number;
+  generatedImageCount: number;
+  illustrationTarget: string;
   stage: DocumentRewriteStage;
   originalCharCount: number;
   writtenCharCount: number;
   /** Short model-generated plan, streamed while it understands the request. */
   requirementsPlan: string;
+  /** Ephemeral thought trace. Never included in the Markdown draft or persisted job state. */
+  thinkingText: string;
   warnings: string[];
   summary: DocumentRewriteSummary | null;
   /** Kept in-memory for the line-level compare dialog; backend job hydration refills it. */
@@ -42,9 +49,14 @@ type CreatePresentationInput = Omit<
   DocumentRewritePresentation,
   | "id"
   | "stage"
+  | "generateImages"
+  | "maxGeneratedImages"
+  | "generatedImageCount"
+  | "illustrationTarget"
   | "originalCharCount"
   | "writtenCharCount"
   | "requirementsPlan"
+  | "thinkingText"
   | "warnings"
   | "summary"
   | "originalContent"
@@ -59,6 +71,8 @@ type CreatePresentationInput = Omit<
   originalContent?: string;
   rewrittenContent?: string | null;
   requirementsPlan?: string;
+  generateImages?: boolean;
+  maxGeneratedImages?: number;
 };
 
 type DocumentRewritePresentationContextValue = {
@@ -74,10 +88,7 @@ const DocumentRewritePresentationContext =
   createContext<DocumentRewritePresentationContextValue | null>(null);
 
 function createId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return "drw-ui-" + crypto.randomUUID();
-  }
-  return "drw-ui-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2);
+  return createClientId("drw-ui");
 }
 
 export function DocumentRewritePresentationProvider({
@@ -96,9 +107,14 @@ export function DocumentRewritePresentationProvider({
         ...input,
         id,
         stage: "snapshot",
+        generateImages: input.generateImages === true,
+        maxGeneratedImages: Math.min(Math.max(input.maxGeneratedImages ?? 2, 1), 4),
+        generatedImageCount: 0,
+        illustrationTarget: "",
         originalCharCount: 0,
         writtenCharCount: 0,
         requirementsPlan: input.requirementsPlan ?? "",
+        thinkingText: "",
         warnings: [],
         summary: null,
         originalContent: input.originalContent ?? "",

frontend-web/src/core/page-layout/compact-menu-overrides.test.ts

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { applyCompactMenuOverrides, isDefaultCompactMenuType, normalizeCompactMenuType } from "./compact-menu-overrides";
+import type { MenuItem } from "./sidebar-menu";
+
+const I = (() => null) as unknown as MenuItem["icon"];
+
+test("normalizeCompactMenuType defaults to A", () => {
+  assert.equal(normalizeCompactMenuType(undefined), "A");
+  assert.equal(normalizeCompactMenuType(""), "A");
+  assert.equal(normalizeCompactMenuType("default"), "A");
+  assert.equal(normalizeCompactMenuType("b"), "B");
+  assert.equal(normalizeCompactMenuType("2"), "B");
+  assert.equal(normalizeCompactMenuType("alt"), "B");
+  assert.equal(isDefaultCompactMenuType(undefined), true);
+  assert.equal(isDefaultCompactMenuType(""), true);
+  assert.equal(isDefaultCompactMenuType("B"), false);
+});
+
+test("applyCompactMenuOverrides splits sidebar vs settings", () => {
+  const items: MenuItem[] = [
+    { id: "a", label: "对话", icon: I, path: "/a" },
+    { id: "b", label: "智能体", icon: I, path: "/b" },
+  ];
+  const applied = applyCompactMenuOverrides(items, [
+    { nodeId: "b", placement: "settings", sortOrder: 0, label: "智能体设置" },
+  ]);
+  assert.deepEqual(
+    applied.sidebarItems.map((item) => item.id),
+    ["a"],
+  );
+  assert.equal(applied.settingsItems[0]?.id, "b");
+  assert.equal(applied.settingsItems[0]?.label, "智能体设置");
+});

frontend-web/src/core/page-layout/compact-menu-overrides.ts

@@ -1,7 +1,41 @@
 import type { MenuItem } from "./sidebar-menu";
+import { readRuntimeEnv } from "@/env";
 
 export type CompactMenuPlacement = "sidebar" | "settings";
 
+export const COMPACT_MENU_TYPES = ["A", "B"] as const;
+export type CompactMenuType = (typeof COMPACT_MENU_TYPES)[number];
+export const DEFAULT_COMPACT_MENU_TYPE: CompactMenuType = "A";
+
+const TYPE_ALIASES: Record<string, CompactMenuType> = {
+  A: "A",
+  "1": "A",
+  DEFAULT: "A",
+  B: "B",
+  "2": "B",
+  ALT: "B",
+};
+
+export function normalizeCompactMenuType(value?: string | null): CompactMenuType {
+  const raw = (value ?? "").trim().toUpperCase();
+  return TYPE_ALIASES[raw] ?? DEFAULT_COMPACT_MENU_TYPE;
+}
+
+export function isDefaultCompactMenuType(value?: string | null): boolean {
+  return normalizeCompactMenuType(value) === DEFAULT_COMPACT_MENU_TYPE;
+}
+
+/** Compact-menu variant for this website, from runtime-config.js.
+ * Missing / empty config is type A, which loads the original compact menu. */
+export function getRuntimeCompactMenuType(): CompactMenuType {
+  return normalizeCompactMenuType(readRuntimeEnv("VITE_COMPACT_MENU_TYPE"));
+}
+
+export const COMPACT_MENU_TYPE_LABELS: Record<CompactMenuType, string> = {
+  A: "类型 A",
+  B: "类型 B",
+};
+
 export interface CompactMenuOverride {
   nodeId: string;
   placement: CompactMenuPlacement;

frontend-web/src/core/sentiment-agent/use-sentiment-agent-chat.ts

@@ -2,6 +2,7 @@ import type { Message } from "@langchain/langgraph-sdk";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { runSentimentAgent, toAgUiMessages } from "./api";
+import { createClientId } from "@/lib/client-id";
 
 const STORAGE_PREFIX = "workspace.sentiment-agent.";
 
@@ -53,9 +54,9 @@ export function useSentimentAgentChat(threadId: string) {
       const question = query.trim();
       if (!question) return;
 
-      const assistantId = `sentiment-ai-${crypto.randomUUID()}`;
+      const assistantId = createClientId("sentiment-ai");
       const userMessage: Message = {
-        id: `sentiment-human-${crypto.randomUUID()}`,
+        id: createClientId("sentiment-human"),
         type: "human",
         content: [{ type: "text", text: question }],
         additional_kwargs: {
@@ -115,7 +116,7 @@ export function useSentimentAgentChat(threadId: string) {
       try {
         await runSentimentAgent({
           threadId,
-          runId: `run-${crypto.randomUUID()}`,
+          runId: createClientId("run"),
           messages: history,
           signal: controller.signal,
           handlers: {

frontend-web/src/core/skill-display/inline-citations.test.ts

@@ -82,3 +82,14 @@ test("accepts spaced and full-width square brackets", () => {
   assert.equal(out.includes(citation(1)), true);
   assert.equal(out.includes(citation(2)), true);
 });
+
+test("can skip the trailing source summary", () => {
+  const withSummary = applyInlineCitations("没有编号。", makeSources(2));
+  assert.equal(withSummary.includes("参考来源"), true);
+
+  const withoutSummary = applyInlineCitations("没有编号。", makeSources(2), {
+    appendSummary: false,
+  });
+  assert.equal(withoutSummary, "没有编号。");
+  assert.equal(withoutSummary.includes("#reference-"), false);
+});

frontend-web/src/core/skill-display/runtime.ts

@@ -509,6 +509,7 @@ export function normalizeDefaultDisplaySources(payload: unknown): DisplaySourceI
 export function applyInlineCitations(
   content: string,
   sources: RuntimeDisplaySource[],
+  options?: { appendSummary?: boolean },
 ): string {
   if (!content || sources.length === 0) {
     return content;
@@ -563,6 +564,9 @@ export function applyInlineCitations(
   if (replaced || hasCitationMarkdown(next)) {
     return next;
   }
+  if (options?.appendSummary === false) {
+    return next;
+  }
   return appendCitationSummary(next, referenceSources);
 }
 

frontend-web/src/core/streamdown/inline-think.ts

@@ -0,0 +1,90 @@
+/**
+ * Some OpenAI-compatible reasoning models write ``<think>...</think>`` into
+ * the ordinary text stream rather than a dedicated reasoning field.  Markdown
+ * sandboxes must never render those fragments as document content.  Callers
+ * can separately render the returned thinking part in a labelled UI trace.
+ *
+ * The filter is stateful because either tag can be split across arbitrary SSE
+ * deltas.  Hold only a possible tag suffix, so confirmed Markdown continues
+ * to appear with the normal token-streaming cadence.
+ */
+export class InlineThinkTagFilter {
+  private static readonly OPEN_TAG = "<think>";
+  private static readonly CLOSE_TAG = "</think>";
+
+  private insideThink = false;
+  private pending = "";
+
+  private possibleTagPrefixSize(content: string, tag: string) {
+    const lowered = content.toLowerCase();
+    for (let size = Math.min(content.length, tag.length - 1); size > 0; size -= 1) {
+      if (lowered.slice(-size) === tag.slice(0, size)) return size;
+    }
+    return 0;
+  }
+
+  pushParts(chunk: string): { text: string; thinking: string } {
+    if (!chunk) return { text: "", thinking: "" };
+
+    let remaining = this.pending + chunk;
+    this.pending = "";
+    let visible = "";
+    let thinking = "";
+
+    while (remaining) {
+      const tag = this.insideThink
+        ? InlineThinkTagFilter.CLOSE_TAG
+        : InlineThinkTagFilter.OPEN_TAG;
+      const tagIndex = remaining.toLowerCase().indexOf(tag);
+      if (tagIndex >= 0) {
+        if (this.insideThink) thinking += remaining.slice(0, tagIndex);
+        else visible += remaining.slice(0, tagIndex);
+        remaining = remaining.slice(tagIndex + tag.length);
+        this.insideThink = !this.insideThink;
+        continue;
+      }
+
+      const suffixSize = this.possibleTagPrefixSize(remaining, tag);
+      const confirmed = suffixSize ? remaining.slice(0, -suffixSize) : remaining;
+      if (this.insideThink) thinking += confirmed;
+      else visible += confirmed;
+      this.pending = suffixSize ? remaining.slice(-suffixSize) : "";
+      break;
+    }
+
+    return { text: visible, thinking };
+  }
+
+  push(chunk: string) {
+    return this.pushParts(chunk).text;
+  }
+
+  /** Flush a completed stream into its visible/thinking channels. */
+  finishParts(): { text: string; thinking: string } {
+    if (this.insideThink) {
+      const thinking = this.pending;
+      this.insideThink = false;
+      this.pending = "";
+      return { text: "", thinking };
+    }
+    const tail = this.pending;
+    this.pending = "";
+    return { text: tail, thinking: "" };
+  }
+
+  finish() {
+    return this.finishParts().text;
+  }
+
+  /** Replace a rendered checkpoint while retaining the correct tag state. */
+  replace(content: string) {
+    this.insideThink = false;
+    this.pending = "";
+    return this.push(content);
+  }
+}
+
+export function stripInlineThinkTags(content: string) {
+  const filter = new InlineThinkTagFilter();
+  return filter.push(content) + filter.finish();
+}

frontend-web/src/core/threads/thread-access-error.ts

@@ -62,6 +62,37 @@ export function isThreadNotAccessibleError(message: string): boolean {
   );
 }
 
+export function isAbortLikeError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  const message = getStreamErrorMessage(error).toLowerCase();
+  return (
+    message.includes("aborterror") ||
+    message.includes("the operation was aborted") ||
+    message.includes("bodystreambuffer")
+  );
+}
+
+export function isTransientStreamTransportError(message: string): boolean {
+  const lowered = message.toLowerCase();
+  return (
+    /failed to fetch/i.test(message) ||
+    lowered.includes("networkerror") ||
+    lowered.includes("network error") ||
+    lowered.includes("load failed") ||
+    lowered.includes("err_connection") ||
+    lowered.includes("err_incomplete") ||
+    lowered.includes("err_network") ||
+    lowered.includes("econnreset") ||
+    lowered.includes("econnaborted") ||
+    /fetch failed/i.test(message)
+  );
+}
+
 /** Build a label for the *current* logged-in identity (email → user_id → 未知). */
 export function buildCurrentUserLabel(): string {
   const auth = getStoredAuth();

frontend-web/src/core/threads/use-multi-round-rag.ts

@@ -2,6 +2,7 @@ import type { Message } from "@langchain/langgraph-sdk";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { readRuntimeEnv } from "@/env";
+import { createClientId } from "@/lib/client-id";
 
 const STORAGE_PREFIX = "workspace.multi-round-rag.";
 
@@ -13,6 +14,9 @@ export type MultiRoundRagRetrieval = {
   time?: string;
   recUuid?: string;
   url?: string;
+  /** Original tool payload, retained so a future renderer can add more fields
+   * without losing data received from the multi-round service. */
+  raw?: Record<string, unknown>;
 };
 
 export type MultiRoundRagRound = {
@@ -74,7 +78,7 @@ function writeStoredMessages(threadId: string, messages: Message[]) {
 }
 
 function createId(prefix: string) {
-  return `${prefix}-${crypto.randomUUID()}`;
+  return createClientId(prefix);
 }
 
 function isAbortError(error: unknown) {
@@ -87,8 +91,11 @@ function asRecord(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
-function asString(value: unknown): string {
-  return typeof value === "string" ? value : "";
+/** Values in the deployed tools are occasionally numeric IDs, not strings. */
+function asText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return "";
 }
 
 function parseJson(value: unknown): unknown {
@@ -103,8 +110,11 @@ function parseJson(value: unknown): unknown {
 function parseEventLine(line: string): MultiRoundEvent | null {
   const trimmed = line.trim();
   if (!trimmed.startsWith("data:")) return null;
+  const payload = trimmed.slice("data:".length).trim();
+  if (!payload || payload === "[DONE]") return { event: "done" };
   try {
-    return JSON.parse(trimmed.slice("data:".length).trim()) as MultiRoundEvent;
+    const parsed = parseJson(payload);
+    return asRecord(parsed) as MultiRoundEvent | null;
   } catch {
     return null;
   }
@@ -141,10 +151,10 @@ function addThinkingRound(trace: MultiRoundRagTrace, thought: string) {
   if (current.title === "正在准备检索" && !current.thought && !current.query) {
     current.title = "思考过程";
     current.thought = thought;
-    return;
+    return current;
   }
   current.isSearching = false;
-  trace.rounds.push({
+  const next = {
     id: createId("multi-rag-round"),
     title: "思考过程",
     thought,
@@ -152,7 +162,9 @@ function addThinkingRound(trace: MultiRoundRagTrace, thought: string) {
     query: "",
     isSearching: true,
     retrievals: [],
-  });
+  };
+  trace.rounds.push(next);
+  return next;
 }
 
 function appendRoundBody(trace: MultiRoundRagTrace, body: string) {
@@ -162,49 +174,94 @@ function appendRoundBody(trace: MultiRoundRagTrace, body: string) {
   current.body = `${current.body ?? ""}${body}`;
 }
 
-function mapRetrievals(value: unknown): MultiRoundRagRetrieval[] {
-  const root = asRecord(parseJson(value));
-  const list =
-    (Array.isArray(root?.results) && root.results) ||
-    (Array.isArray(root?.organic) && root.organic) ||
-    [];
-  return list.flatMap((item, index) => {
+function firstArray(values: unknown[]): unknown[] {
+  for (const value of values) {
+    const parsed = parseJson(value);
+    if (Array.isArray(parsed)) return parsed;
+  }
+  return [];
+}
+
+function toRecordList(value: unknown): Record<string, unknown>[] {
+  const parsed = parseJson(value);
+  const root = asRecord(parsed);
+  const list = Array.isArray(parsed)
+    ? parsed
+    : firstArray([
+        root?.results,
+        root?.organic,
+        root?.data,
+        root?.items,
+        root?.list,
+        root?.documents,
+      ]);
+  return list.flatMap((item) => {
+    if (typeof item === "string") return [{ content: item }];
     const record = asRecord(item);
-    if (!record) return [];
-    const recUuid = asString(record.recUuid ?? record.rec_uuid);
-    const url = asString(record.url ?? record.link ?? record.href);
+    return record ? [record] : [];
+  });
+}
+
+/**
+ * GeneralQA's service fans out to several business search tools.  Normalising
+ * all of their result shapes here prevents a successful tool call from being
+ * silently absent just because it did not use `results` or `organic`.
+ */
+function mapRetrievals(value: unknown): MultiRoundRagRetrieval[] {
+  const list = toRecordList(value);
+  return list.flatMap((item, index) => {
+    const recUuid = asText(item.recUuid ?? item.rec_uuid ?? item.uuid);
+    const url = asText(item.url ?? item.link ?? item.href);
+    const title = asText(
+      item.title ?? item.m_title ?? item.taskName ?? item.user_name ?? item.name ?? item.user_id,
+    );
+    const content = asText(
+      item.content ??
+        item.m_content ??
+        item.m_conent ??
+        item.snippet ??
+        item.text ??
+        item.overview ??
+        item.page_content ??
+        item.description ??
+        item.summary,
+    );
     return [
       {
-        id: asString(record.id) || recUuid || undefined,
-        title: asString(record.title) || `检索资料 ${index + 1}`,
-        content: asString(record.content ?? record.snippet ?? record.text),
-        source: asString(record.source ?? record.source1 ?? url) || undefined,
-        time: asString(record.publish_time ?? record.m_publish ?? record.date) || undefined,
+        id: asText(item.id) || recUuid || undefined,
+        title: title || `检索资料 ${index + 1}`,
+        content: content || (url && !title ? url : ""),
+        source: asText(item.source ?? item.source1 ?? item.m_source ?? item.platform) || undefined,
+        time: asText(item.publish_time ?? item.m_publish ?? item.m_publicsh ?? item.date ?? item.time) || undefined,
         recUuid: recUuid || undefined,
         url: /^https?:\/\//i.test(url) ? url : undefined,
+        raw: item,
       },
     ];
   });
 }
 
 function mapReferences(value: unknown): MultiRoundRagSource[] {
-  const record = asRecord(value);
-  const list = Array.isArray(record?.references) ? record.references : [];
+  const parsed = parseJson(value);
+  const record = asRecord(parsed);
+  const list = Array.isArray(parsed)
+    ? parsed
+    : firstArray([record?.references, record?.results, record?.sources, record?.documents]);
   return list.flatMap((item, index) => {
     const source = asRecord(item);
     if (!source) return [];
-    const content = asString(source.content ?? source.snippet);
-    const rawUrl = asString(source.url ?? source.link ?? source.href);
-    const recUuid = asString(source.recUuid ?? source.rec_uuid ?? source.uuid);
+    const content = asText(source.content ?? source.m_content ?? source.m_conent ?? source.snippet ?? source.text);
+    const rawUrl = asText(source.url ?? source.link ?? source.href);
+    const recUuid = asText(source.recUuid ?? source.rec_uuid ?? source.uuid);
     return [
       {
-        id: asString(source.id) || recUuid || undefined,
-        title: asString(source.title) || `参考资料 ${index + 1}`,
-        type: asString(source.type) || "参考资料",
-        snippet: asString(source.snippet) || content,
+        id: asText(source.id) || recUuid || undefined,
+        title: asText(source.title ?? source.m_title ?? source.taskName ?? source.user_name) || `参考资料 ${index + 1}`,
+        type: asText(source.type) || "参考资料",
+        snippet: asText(source.snippet) || content,
         content,
-        source: asString(source.source ?? source.source1) || undefined,
-        time: asString(source.time ?? source.m_publish ?? source.publish_time) || undefined,
+        source: asText(source.source ?? source.source1 ?? source.m_source ?? source.platform) || undefined,
+        time: asText(source.time ?? source.m_publish ?? source.m_publicsh ?? source.publish_time ?? source.date) || undefined,
         url: /^https?:\/\//i.test(rawUrl) ? rawUrl : undefined,
         raw: source,
       },
@@ -222,6 +279,71 @@ function cloneTrace(trace: MultiRoundRagTrace): MultiRoundRagTrace {
   };
 }
 
+function toolTitle(toolName: string): string {
+  switch (toolName) {
+    case "local_search":
+      return "本地知识检索";
+    case "tavily_search":
+      return "联网检索";
+    case "google_search":
+    case "getTaskLikeTop":
+      return "思考过程";
+    case "search_user_profile":
+      return "靶标平台画像库";
+    case "get_taiwan_news":
+    case "search_keyword_taiwan_news":
+      return "台湾热点新闻";
+    case "get_world_news":
+      return "世界热点新闻";
+    case "get_root_messaage_comment":
+      return "获取该消息的全部评论";
+    case "search_user_behavior":
+      return "查询该用户的历史行为";
+    case "get_america_news":
+      return "美国热点新闻";
+    case "get_time_data":
+      return "态势新闻搜索";
+    case "get_textid_content":
+      return "获取新闻详细内容";
+    default:
+      return toolName || "检索过程";
+  }
+}
+
+function isSearchTool(toolName: string): boolean {
+  return [
+    "local_search",
+    "tavily_search",
+    "google_search",
+    "getTaskLikeTop",
+    "search_user_profile",
+    "get_taiwan_news",
+    "search_keyword_taiwan_news",
+    "get_world_news",
+    "get_root_messaage_comment",
+    "search_user_behavior",
+    "get_america_news",
+    "get_time_data",
+  ].includes(toolName);
+}
+
+function queryFromToolInput(input: Record<string, unknown>, result: unknown): string {
+  const resultRecord = asRecord(parseJson(result));
+  const direct = asText(input.q ?? input.query ?? input.keyword ?? input.user_fig);
+  if (direct) return direct;
+  if (input.s || input.e) {
+    return [asText(input.s), asText(input.e)].filter(Boolean).join(" - ");
+  }
+  return asText(resultRecord?.query ?? resultRecord?.q);
+}
+
+function textFromEventData(value: unknown): string {
+  const parsed = parseJson(value);
+  if (typeof parsed === "string") return parsed;
+  const record = asRecord(parsed);
+  return asText(record?.text ?? record?.content ?? record?.message ?? record?.answer ?? record?.output);
+}
+
 function isSingleRoundRagMessage(message: Message) {
   return message.additional_kwargs?.single_round_rag === true;
 }
@@ -370,92 +492,204 @@ export function useMultiRoundRagMessages(threadId: string) {
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
+        let activeThoughtRound: MultiRoundRagRound | null = null;
+        let activeThoughtTailIsAnswer = false;
+        let answerFromShowText = false;
+
+        const appendAnswer = (text: string, allowCompleteSnapshot = false) => {
+          if (!text) return;
+          // Some gateways emit one complete `message` after a `show_text`
+          // answer. Restrict snapshot detection to that case and to a
+          // meaningful length: adjacent streaming chunks can legitimately
+          // contain the same character, and must never be discarded.
+          if (
+            allowCompleteSnapshot &&
+            trace.answer.length >= 16 &&
+            text.startsWith(trace.answer)
+          ) {
+            trace.answer = text;
+            return;
+          }
+          trace.answer += text;
+        };
+
+        const consumeShowText = (text: string, tailIsAnswer = false) => {
+          if (!text) return;
+          if (activeThoughtRound) {
+            const endIndex = text.indexOf("</think>");
+            if (endIndex < 0) {
+              activeThoughtRound.thought += text;
+              return;
+            }
+            activeThoughtRound.thought += text.slice(0, endIndex);
+            const roundBody = text.slice(endIndex + "</think>".length).trim();
+            if (roundBody) {
+              if (activeThoughtTailIsAnswer) {
+                appendAnswer(roundBody);
+                answerFromShowText = false;
+                trace.isComplete = true;
+              } else {
+                appendRoundBody(trace, roundBody);
+              }
+            }
+            activeThoughtRound = null;
+            activeThoughtTailIsAnswer = false;
+            return;
+          }
+
+          const thinkStart = text.indexOf("<think>");
+          if (thinkStart < 0) {
+            const current = latestRound(trace);
+            current.isSearching = false;
+            appendAnswer(text);
+            answerFromShowText = true;
+            trace.isComplete = true;
+            return;
+          }
+
+          const prefix = text.slice(0, thinkStart).trim();
+          if (prefix) appendRoundBody(trace, prefix);
+
+          // A full <think>…</think> envelope is normally delivered as one
+          // tool call.  Keep the unfinished variant open as well: production
+          // proxies are allowed to split an SSE frame at any byte boundary.
+          const thinkEnd = text.indexOf("</think>", thinkStart + "<think>".length);
+          const thought = text
+            .slice(thinkStart + "<think>".length, thinkEnd < 0 ? undefined : thinkEnd)
+            .trim();
+          const thoughtRound = addThinkingRound(trace, thought);
+          if (thinkEnd < 0) {
+            activeThoughtRound = thoughtRound;
+            activeThoughtTailIsAnswer = tailIsAnswer;
+            return;
+          }
+          const roundBody = text.slice(thinkEnd + "</think>".length).trim();
+          if (roundBody) {
+            if (tailIsAnswer) {
+              appendAnswer(roundBody);
+              answerFromShowText = false;
+              trace.isComplete = true;
+            } else {
+              appendRoundBody(trace, roundBody);
+            }
+          }
+        };
+
+        const consumeToolCall = (payload: unknown) => {
+          const parsedPayload = parseJson(payload);
+          const tools = Array.isArray(parsedPayload) ? parsedPayload : [parsedPayload];
+          for (const toolValue of tools) {
+            const tool = asRecord(toolValue);
+            if (!tool) continue;
+            const toolName = asText(tool.tool_name ?? tool.name);
+            const input = asRecord(parseJson(tool.tool_input ?? tool.input ?? tool.arguments)) ?? {};
+            const current = latestRound(trace);
+
+            if (toolName === "show_text") {
+              consumeShowText(asText(input.text ?? input.content));
+              continue;
+            }
+
+            if (toolName === "get_textid_content") {
+              current.title = toolTitle(toolName);
+              const article = asRecord(parseJson(input.result));
+              const body = asText(article?.content ?? article?.text ?? input.content ?? input.result);
+              if (body) appendRoundBody(trace, body);
+              current.isSearching = false;
+              continue;
+            }
+
+            const hasResult = input.result !== undefined;
+            const query = queryFromToolInput(input, input.result);
+            if (isSearchTool(toolName) || hasResult) {
+              current.title = toolTitle(toolName);
+              current.query = query || current.query;
+              if (!hasResult && isSearchTool(toolName)) {
+                // GeneralQA can receive a model text event before the search
+                // tool announces its query.  The query starts a new visible
+                // loading phase, so restore the round/trace state here and
+                // keep the query badge spinning until its result arrives.
+                current.isSearching = true;
+                trace.isComplete = false;
+              } else if (hasResult) {
+                const retrievals = mapRetrievals(input.result);
+                // An empty search response is still a completed response; it
+                // must replace a previous list instead of leaving stale cards.
+                current.retrievals = retrievals;
+                if (retrievals.length === 0) {
+                  const fallbackBody = textFromEventData(input.result);
+                  if (fallbackBody && fallbackBody !== current.query) {
+                    appendRoundBody(trace, fallbackBody);
+                  }
+                }
+                current.isSearching = false;
+              }
+            }
+          }
+        };
+
+        const finishTrace = () => {
+          trace.isComplete = true;
+          activeThoughtRound = null;
+          activeThoughtTailIsAnswer = false;
+          for (const round of trace.rounds) round.isSearching = false;
+        };
+
+        const consumeEvent = (event: MultiRoundEvent) => {
+          const eventType = asText(event.event);
+          const data = event.data;
+          if (eventType === "tool_call") {
+            consumeToolCall(data);
+          } else if (eventType === "message") {
+            const text = textFromEventData(data);
+            if (text) {
+              if (activeThoughtRound || /<\/?think>/i.test(text)) {
+                // Most deployments put thoughts in `show_text`, but this
+                // fallback also preserves a compatible gateway that emits
+                // `<think>` in normal message chunks.
+                consumeShowText(text, true);
+              } else {
+                latestRound(trace).isSearching = false;
+                appendAnswer(text, answerFromShowText);
+                answerFromShowText = false;
+                trace.isComplete = true;
+              }
+            }
+          } else if (eventType === "references") {
+            sources = mapReferences(data);
+          } else if (eventType === "error") {
+            const message = textFromEventData(data) || "多轮 RAG 服务返回错误。";
+            setError(message);
+            if (!trace.answer) trace.answer = message;
+            finishTrace();
+          } else if (eventType === "done") {
+            // A few compatible gateway versions include the whole final
+            // answer in `done`; render it when no `message` chunk was sent.
+            const finalText = textFromEventData(data);
+            if (finalText && !trace.answer) appendAnswer(finalText);
+            finishTrace();
+          }
+          refreshAssistant();
+        };
+
+        const consumeLines = (flush = false) => {
+          const lines = buffer.split(/\r?\n/);
+          buffer = flush ? "" : (lines.pop() ?? "");
+          for (const line of lines) {
+            const event = parseEventLine(line);
+            if (event) consumeEvent(event);
+          }
+        };
+
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
           buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split(/\r?\n/);
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            const event = parseEventLine(line);
-            if (!event) continue;
-            const eventType = asString(event.event);
-            const data = event.data;
-            if (eventType === "tool_call") {
-              const tool = asRecord(data);
-              const toolName = asString(tool?.tool_name);
-              const input = asRecord(tool?.tool_input) ?? {};
-              const current = latestRound(trace);
-              if (toolName === "show_text") {
-                const text = asString(input.text);
-                if (text.includes("<think>")) {
-                  const thinkEnd = text.indexOf("</think>");
-                  addThinkingRound(
-                    trace,
-                    (thinkEnd >= 0
-                      ? text.slice(0, thinkEnd + "</think>".length)
-                      : text
-                    )
-                      .replace(/<\/?think>/g, "")
-                      .trim(),
-                  );
-                  if (thinkEnd >= 0) {
-                    const roundBody = text
-                      .slice(thinkEnd + "</think>".length)
-                      .trim();
-                    if (roundBody) {
-                      appendRoundBody(trace, roundBody);
-                    }
-                  }
-                } else {
-                  // A non-thinking `show_text` immediately after a thought is
-                  // this round's narrative; the terminal `message` event is
-                  // still rendered only as the final answer below all rounds.
-                  current.isSearching = false;
-                  trace.answer += text;
-                  trace.isComplete = true;
-                }
-              } else if (
-                toolName === "local_search" ||
-                toolName === "tavily_search" ||
-                toolName === "google_search"
-              ) {
-                const queryData = asRecord(parseJson(input.result));
-                current.title =
-                  toolName === "local_search" ? "本地知识检索" : "联网检索";
-                current.query =
-                  asString(input.q ?? input.query) ||
-                  asString(queryData?.query) ||
-                  current.query;
-                const retrievals = mapRetrievals(input.result);
-                if (retrievals.length > 0) current.retrievals = retrievals;
-                current.isSearching = false;
-              } else if (toolName === "get_textid_content") {
-                const article = asRecord(parseJson(input.result));
-                const body =
-                  asString(article?.content ?? article?.text) ||
-                  asString(input.content);
-                if (body) appendRoundBody(trace, body);
-                current.isSearching = false;
-              }
-              refreshAssistant();
-            } else if (eventType === "message" && typeof data === "string") {
-              latestRound(trace).isSearching = false;
-              trace.answer += data;
-              trace.isComplete = true;
-              refreshAssistant();
-            } else if (eventType === "references") {
-              sources = mapReferences(data);
-              refreshAssistant();
-            } else if (eventType === "done") {
-              trace.isComplete = true;
-              for (const round of trace.rounds) round.isSearching = false;
-              refreshAssistant();
-            }
-          }
+          consumeLines();
         }
-        trace.isComplete = true;
-        for (const round of trace.rounds) round.isSearching = false;
+        buffer += decoder.decode();
+        consumeLines(true);
+        finishTrace();
         refreshAssistant();
       } catch (caught) {
         trace.isComplete = true;

frontend-web/src/core/threads/use-single-round-rag.ts

@@ -2,6 +2,7 @@ import type { Message } from "@langchain/langgraph-sdk";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { readRuntimeEnv } from "@/env";
+import { createClientId } from "@/lib/client-id";
 
 const STORAGE_PREFIX = "workspace.single-round-rag.";
 
@@ -216,6 +217,8 @@ function toRagSource(
     content,
     source,
     time: readString(record.m_publish, record.m_publicsh, record.time),
+    // GeneralQA uses recUuid to open the knowledge-detail page. Prefer that
+    // stable internal record link, then fall back to a backend-provided URL.
     url:
       buildKnowledgeDetailUrl(recUuid) ??
       (rawUrl && /^https?:\/\//i.test(rawUrl) ? rawUrl : undefined),
@@ -227,7 +230,7 @@ function toRagSource(
  * A single-RAG stream is a concatenation of source envelopes, for example:
  * `{docs:["..."], recUuid:"...", m_title:"...", m_content:"..."}`.
  * The root-level metadata is the source; `docs` merely marks the envelope and
- * supplies a fallback body. This mirrors GeneralQA's per-chunk processing.
+  * supplies a fallback body.  This mirrors GeneralQA's per-chunk processing.
  */
 function normalizeSources(chunk: KnowledgeBaseChunk): RagSource[] {
   const hasRootMetadata = [
@@ -275,7 +278,7 @@ function mergeSources(current: RagSource[], incoming: RagSource[]): RagSource[]
 }
 
 function createId(prefix: string) {
-  return `${prefix}-${crypto.randomUUID()}`;
+  return createClientId(prefix);
 }
 
 function isAbortError(error: unknown) {