Merge branch 'master-nj' into 'master'

增强 Deep Research 可靠性，并接入 8BF 任务卡片与会商上下文。

See merge request knowledge-base-bj/deerflow-code!25

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/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/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/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,10 +2,11 @@ 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.";
 
-type KnowledgeBaseChunk = {
+type KnowledgeBaseChunk = Record<string, unknown> & {
   answer?: unknown;
   docs?: unknown;
 };
@@ -168,38 +169,116 @@ function parseKnowledgeBaseChunk(jsonText: string): KnowledgeBaseChunk {
   }
 }
 
-function flattenDocs(value: unknown): Record<string, unknown>[] {
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => flattenDocs(item));
+function readString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value;
   }
-  if (!value || typeof value !== "object") return [];
-  const record = value as Record<string, unknown>;
-  if ("docs" in record) return flattenDocs(record.docs);
-  return [record];
+  return undefined;
 }
 
-function normalizeSources(value: unknown): RagSource[] {
-  return flattenDocs(value).map((item, index) => {
-    const title = String(item.m_title ?? item.title ?? item.source ?? `参考资料 ${index + 1}`);
-    const content = String(item.m_content ?? item.content ?? item.snippet ?? "");
-    const source = item.source1 ?? item.source;
-    const rawUrl = item.url ?? item.link ?? item.href;
-    return {
-      id: String(item.recUuid ?? item.rec_uuid ?? item.uuid ?? item.id ?? "") || undefined,
-      title,
-      type: String(item.source1 ?? item.type ?? "知识库"),
-      snippet: content,
-      content,
-      source: typeof source === "string" ? source : undefined,
-      time: typeof item.m_publish === "string" ? item.m_publish : undefined,
-      url: typeof rawUrl === "string" && /^https?:\/\//i.test(rawUrl) ? rawUrl : undefined,
-      raw: item,
-    };
+function docsFallbackContent(docs: unknown): string | undefined {
+  const candidates = Array.isArray(docs) ? docs : [docs];
+  return readString(...candidates);
+}
+
+function buildKnowledgeDetailUrl(recUuid: string | undefined): string | undefined {
+  const knowledgeUrl = readRuntimeEnv("VITE_AIPI_KNOWLEDGE_URL")?.replace(/\/$/, "");
+  if (!knowledgeUrl || !recUuid) return undefined;
+  return `${knowledgeUrl}/#/knowledge/mid-detail?recUuid=${encodeURIComponent(recUuid)}`;
+}
+
+function toRagSource(
+  record: Record<string, unknown>,
+  index: number,
+  fallbackContent?: string,
+): RagSource {
+  const title =
+    readString(record.m_title, record.title, record.source, record.source1) ??
+    `参考资料 ${index + 1}`;
+  const content =
+    readString(
+      record.m_content,
+      // Some deployed responses spell this field incorrectly; keep it as a
+      // read-only compatibility alias rather than dropping the document.
+      record.m_conent,
+      record.content,
+      record.snippet,
+      fallbackContent,
+      record.url,
+  ) ?? "";
+  const source = readString(record.source1, record.source, record.m_source);
+  const rawUrl = readString(record.url, record.link, record.href);
+  const recUuid = readString(record.recUuid, record.rec_uuid, record.uuid, record.id);
+  return {
+    id: recUuid,
+    title,
+    type: readString(record.type, record.source1) ?? "知识库",
+    snippet: content,
+    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),
+    raw: record,
+  };
+}
+
+/**
+ * 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.
+ */
+function normalizeSources(chunk: KnowledgeBaseChunk): RagSource[] {
+  const hasRootMetadata = [
+    chunk.recUuid,
+    chunk.rec_uuid,
+    chunk.m_title,
+    chunk.m_content,
+    chunk.m_conent,
+    chunk.source1,
+    chunk.m_publish,
+    chunk.m_publicsh,
+  ].some((value) => typeof value === "string" && value.trim());
+  if (hasRootMetadata) {
+    return [toRagSource(chunk, 0, docsFallbackContent(chunk.docs))];
+  }
+
+  const docs = Array.isArray(chunk.docs) ? chunk.docs : chunk.docs ? [chunk.docs] : [];
+  return docs.flatMap((item, index): RagSource[] => {
+    if (typeof item === "string") {
+      return [toRagSource({}, index, item)];
+    }
+    if (!item || typeof item !== "object") return [];
+    return [toRagSource(item as Record<string, unknown>, index)];
   });
 }
 
+function mergeSources(current: RagSource[], incoming: RagSource[]): RagSource[] {
+  const result = [...current];
+  const keys = new Set(
+    current.map((source) =>
+      source.id
+        ? `id:${source.id}`
+        : `content:${source.title}\u0000${source.content}\u0000${source.source ?? ""}`,
+    ),
+  );
+  for (const source of incoming) {
+    const key = source.id
+      ? `id:${source.id}`
+      : `content:${source.title}\u0000${source.content}\u0000${source.source ?? ""}`;
+    if (keys.has(key)) continue;
+    keys.add(key);
+    result.push(source);
+  }
+  return result;
+}
+
 function createId(prefix: string) {
-  return `${prefix}-${crypto.randomUUID()}`;
+  return createClientId(prefix);
 }
 
 function isAbortError(error: unknown) {
@@ -397,7 +476,9 @@ export function useSingleRoundRagMessages(threadId: string) {
           for (const jsonText of extracted.objects) {
             const chunk = parseKnowledgeBaseChunk(jsonText);
             if (typeof chunk.answer === "string") answerChunks.push({ answer: chunk.answer });
-            if (chunk.docs !== undefined) sources = normalizeSources(chunk.docs);
+            if (chunk.docs !== undefined) {
+              sources = mergeSources(sources, normalizeSources(chunk));
+            }
             refreshAssistant();
           }
         }