feat(frontend): enhance chat image handling and typewriter effect

- Introduce a stable skeleton box for protected images during loading to prevent flickering.
- Implement a new composable `useStickyBottomOnResize` to maintain chat scroll position as content loads.
- Add `useTypewriter` for smoother text rendering in chat, improving user experience during streaming.
- Create a directive `vStableHtml` to efficiently update HTML content without losing image states.
- Enhance chat markdown rendering to handle incomplete citation tags and trailing horizontal rules during streaming.
- Add tests for new typewriter functionality and citation handling.
This commit is contained in:
wizardchen
2026-06-18 16:44:39 +08:00
committed by lyingbug
parent 95b97dc379
commit 80bcf200b6
15 changed files with 738 additions and 50 deletions
@@ -574,6 +574,38 @@
transition: transform 0.2s ease;
}
// Protected images not yet hydrated still carry the 1x1 placeholder gif.
// Without a fixed size width:auto/height:auto collapse it to a ~1px line that
// jumps to full size on load (reads as flicker during streaming). Give it a
// stable skeleton box so the later swap to the real image is a calm fade-in.
// Match both the explicit loading marker and the transparent GIF itself.
// During a streaming DOM patch the marker can briefly be absent while src is
// already the 1x1 placeholder; matching src prevents that frame becoming a
// tall, one-pixel vertical line in Chromium.
:deep(img[data-img-loading]),
:deep(img[data-protected-src][src^='data:image/gif;base64']) {
width: 260px;
height: 180px;
min-width: min(260px, 80%);
min-height: 180px;
max-width: 80%;
object-fit: cover;
cursor: default;
background: linear-gradient(
100deg,
var(--td-bg-color-secondarycontainer, #f3f3f3) 30%,
var(--td-bg-color-container-hover, #eaeaea) 50%,
var(--td-bg-color-secondarycontainer, #f3f3f3) 70%
);
background-size: 200% 100%;
animation: chat-img-skeleton 1.2s ease-in-out infinite;
}
@keyframes chat-img-skeleton {
0% { background-position: 100% 0; }
100% { background-position: -100% 0; }
}
:deep(p:has(> img:only-child)) {
margin: 1.25em 0;
line-height: 0;
@@ -20,6 +20,7 @@ import { buildQueryWithHostContext } from '@/utils/embedContext'
import { fileToDataURI } from '@/utils/embedFile'
import { useI18n } from 'vue-i18n'
import { useChatStreamHandler } from '@/composables/useChatStreamHandler'
import { useStickyBottomOnResize } from '@/composables/useStickyBottomOnResize'
export function useEmbedChatSession(options: {
sessionId: Ref<string>
@@ -90,6 +91,8 @@ export function useEmbedChatSession(options: {
scrollToBottom(true)
}
useStickyBottomOnResize(scrollContainer, userHasScrolledUp, scrollToBottom)
const debounce = <T extends (...args: never[]) => void>(fn: T, delay: number) => {
let timer: ReturnType<typeof setTimeout>
return (...args: Parameters<T>) => {
@@ -0,0 +1,44 @@
import { onMounted, onUnmounted, type Ref } from 'vue'
/**
* Keep a chat pinned to the bottom when asynchronously rendered content grows.
*
* Streaming text already requests scrolling when chunks arrive, but images,
* Mermaid diagrams, and other rich content can change height later. Observe the
* message list itself so all delayed layout changes share the same behavior.
* A user who has intentionally scrolled up is never pulled back down.
*/
export function useStickyBottomOnResize(
scrollContainer: Ref<HTMLElement | null>,
userHasScrolledUp: Ref<boolean>,
scrollToBottom: () => void,
): void {
let resizeObserver: ResizeObserver | null = null
let scrollFrame: number | null = null
const scheduleFollow = () => {
if (userHasScrolledUp.value || scrollFrame !== null) return
scrollFrame = requestAnimationFrame(() => {
scrollFrame = null
if (!userHasScrolledUp.value) scrollToBottom()
})
}
onMounted(() => {
const messageList = scrollContainer.value?.firstElementChild
if (!messageList || typeof ResizeObserver === 'undefined') return
resizeObserver = new ResizeObserver(scheduleFollow)
resizeObserver.observe(messageList)
})
onUnmounted(() => {
resizeObserver?.disconnect()
resizeObserver = null
if (scrollFrame !== null) {
cancelAnimationFrame(scrollFrame)
scrollFrame = null
}
})
}
@@ -0,0 +1,28 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { nextTypewriterReveal } from './useTypewriter.ts'
test('reveals Chinese text in compact phrase groups', () => {
const text = '这是一个自然流畅的回答。'
assert.equal(nextTypewriterReveal(text, 0, 1), 0)
assert.equal(nextTypewriterReveal(text, 0, 2), 2)
assert.equal(nextTypewriterReveal(text, 0, 20), 4)
})
test('waits for a complete English word instead of revealing letter by letter', () => {
const text = 'Hello world'
assert.equal(nextTypewriterReveal(text, 0, 3), 0)
assert.equal(nextTypewriterReveal(text, 0, 6), 6)
assert.equal(text.slice(0, nextTypewriterReveal(text, 0, 6)), 'Hello ')
})
test('uses punctuation as a natural reveal boundary', () => {
const text = '你好,接下来继续。'
assert.equal(nextTypewriterReveal(text, 0, 3), 3)
})
test('never splits a surrogate pair', () => {
const text = '🙂 hello'
assert.equal(nextTypewriterReveal(text, 0, 1), 2)
})
+200
View File
@@ -0,0 +1,200 @@
import { computed, onBeforeUnmount, ref, watch, type ComputedRef } from 'vue';
export interface TypewriterOptions {
/** Comfortable reveal floor in characters per second. */
minCps?: number;
/** Time window (seconds) over which ordinary backlog is drained. */
drainSeconds?: number;
/** Upper speed limit when a large SSE chunk arrives at once. */
maxCps?: number;
/** Largest frame delta honored after a backgrounded tab resumes. */
maxFrameSeconds?: number;
}
const NATURAL_BREAK_RE = /[\s,。!?;:、,.!?;:)\]】》」』]/u;
const CJK_RE = /[\u3400-\u9fff\uf900-\ufaff\u3040-\u30ff\uac00-\ud7af]/u;
const WORD_CHARACTER_RE = /[\p{L}\p{N}_]/u;
function nextCodePointEnd(text: string, index: number): number {
if (index >= text.length) return text.length;
const code = text.charCodeAt(index);
return index + (code >= 0xd800 && code <= 0xdbff ? 2 : 1);
}
function previousCodePointStart(text: string, index: number): number {
if (index <= 0) return 0;
const code = text.charCodeAt(index - 1);
return code >= 0xdc00 && code <= 0xdfff ? index - 2 : index - 1;
}
function advanceCodePoints(text: string, start: number, count: number): number {
let end = start;
for (let i = 0; i < count && end < text.length; i += 1) {
end = nextCodePointEnd(text, end);
}
return end;
}
/**
* Pick the next human-readable reveal boundary.
*
* CJK text advances in compact 2–4 character phrases. Latin text waits briefly
* for a whole-word boundary instead of crawling through a word letter by letter.
*/
export function nextTypewriterReveal(
text: string,
start: number,
availableCharacters: number,
): number {
if (start >= text.length) return text.length;
const firstEnd = nextCodePointEnd(text, start);
const firstCharacter = text.slice(start, firstEnd);
const isCjk = CJK_RE.test(firstCharacter);
const isWordCharacter = WORD_CHARACTER_RE.test(firstCharacter);
const minimumGroup = isCjk ? 2 : 1;
const maximumGroup = isCjk ? 4 : 14;
const available = Math.max(0, Math.floor(availableCharacters));
if (available < minimumGroup && text.length - start > available) return start;
const hardEnd = advanceCodePoints(text, start, Math.min(maximumGroup, Math.max(minimumGroup, available)));
const minimumEnd = advanceCodePoints(text, start, minimumGroup);
// Prefer the latest complete phrase/word already covered by the reveal budget.
let cursor = hardEnd;
while (cursor >= minimumEnd) {
const characterStart = previousCodePointStart(text, cursor);
if (NATURAL_BREAK_RE.test(text.slice(characterStart, cursor))) return cursor;
cursor = characterStart;
}
// CJK has no spaces between words; reveal small even groups. For Latin text,
// wait for the word to finish unless it has grown long enough to need a split.
if (isCjk || !isWordCharacter || hardEnd === text.length || available >= maximumGroup) return hardEnd;
return start;
}
/**
* Smooth streamed text into an adaptive phrase cadence.
*
* Network chunks arrive in uneven bursts. The displayed slice follows them with
* short semantic groups, accelerates under backlog, and eases back near the live
* edge. This feels closer to a model composing text than a mechanical cursor.
*/
export function useTypewriter(
getTarget: () => string,
getComplete: () => boolean,
options: TypewriterOptions = {},
): { displayed: ComputedRef<string> } {
const minCps = options.minCps ?? 72;
const drainSeconds = options.drainSeconds ?? 0.42;
const maxCps = options.maxCps ?? 240;
const maxFrameSeconds = options.maxFrameSeconds ?? 0.05;
const typedLength = ref(0);
let revealCredit = 0;
let raf: number | null = null;
let lastTs = 0;
let initialized = false;
let reduceMotion = false;
let motionQuery: MediaQueryList | null = null;
if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
motionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
reduceMotion = motionQuery.matches;
}
const displayed = computed(() => {
const full = getTarget();
let n = Math.min(typedLength.value, full.length);
// Never cut on a high surrogate, which would render a broken glyph.
if (n > 0 && n < full.length) {
const code = full.charCodeAt(n - 1);
if (code >= 0xd800 && code <= 0xdbff) n -= 1;
}
return full.slice(0, n);
});
const stop = () => {
if (raf !== null) {
cancelAnimationFrame(raf);
raf = null;
}
lastTs = 0;
};
const tick = (ts: number) => {
const full = getTarget();
const target = full.length;
if (typedLength.value > target) {
typedLength.value = 0;
revealCredit = 0;
}
if (typedLength.value >= target) {
stop();
return;
}
const dt = lastTs ? Math.min((ts - lastTs) / 1000, maxFrameSeconds) : 0;
lastTs = ts;
const remaining = target - typedLength.value;
const cps = Math.min(maxCps, Math.max(minCps, remaining / drainSeconds));
revealCredit += cps * dt;
const next = nextTypewriterReveal(full, typedLength.value, revealCredit);
if (next > typedLength.value) {
revealCredit = Math.max(0, revealCredit - (next - typedLength.value));
typedLength.value = next;
}
raf = requestAnimationFrame(tick);
};
const ensure = () => {
if (raf === null) {
lastTs = 0;
raf = requestAnimationFrame(tick);
}
};
const handleMotionChange = (event: MediaQueryListEvent) => {
reduceMotion = event.matches;
if (reduceMotion) {
typedLength.value = getTarget().length;
revealCredit = 0;
stop();
}
};
motionQuery?.addEventListener('change', handleMotionChange);
watch(
getTarget,
(full) => {
const target = full.length;
if (!initialized) {
initialized = true;
if (getComplete() || reduceMotion) {
typedLength.value = target;
return;
}
}
if (typedLength.value > target) {
typedLength.value = 0;
revealCredit = 0;
}
if (reduceMotion) {
typedLength.value = target;
} else if (typedLength.value < target) {
ensure();
}
},
{ immediate: true },
);
onBeforeUnmount(() => {
stop();
motionQuery?.removeEventListener('change', handleMotionChange);
});
return { displayed };
}
+116
View File
@@ -0,0 +1,116 @@
import type { ObjectDirective } from 'vue';
function imageIdentity(img: HTMLImageElement): string {
return (img.getAttribute('data-protected-src') || img.currentSrc || img.src || '').trim();
}
function canMorph(current: Node, next: Node): boolean {
if (current.nodeType !== next.nodeType) return false;
if (current.nodeType !== Node.ELEMENT_NODE) return true;
return (current as Element).tagName === (next as Element).tagName;
}
function syncAttributes(current: Element, next: Element, preserved: Set<string> = new Set()): void {
Array.from(current.attributes).forEach(({ name }) => {
if (!preserved.has(name) && !next.hasAttribute(name)) current.removeAttribute(name);
});
Array.from(next.attributes).forEach(({ name, value }) => {
if (!preserved.has(name) && current.getAttribute(name) !== value) {
current.setAttribute(name, value);
}
});
}
function morphImage(current: HTMLImageElement, next: HTMLImageElement): void {
const sameProtectedSource = Boolean(
current.getAttribute('data-protected-src')
&& current.getAttribute('data-protected-src') === next.getAttribute('data-protected-src'),
);
const sameIdentity = imageIdentity(current) === imageIdentity(next);
const sameProtectedAlt = Boolean(
current.getAttribute('data-protected-src')
&& next.getAttribute('data-protected-src')
&& current.alt
&& current.alt === next.alt,
);
const keepDecodedImage = current.complete
&& current.naturalWidth > 1
&& (sameProtectedSource || sameIdentity || sameProtectedAlt);
if (keepDecodedImage) {
// Never write the placeholder src (or loading flags) over an image Chrome
// has already decoded. More importantly, leave this exact DOM node attached
// to the document so Chromium keeps its painted image layer.
syncAttributes(current, next, new Set([
'src',
'data-protected-src',
'data-img-loading',
'data-auth-hydrated',
]));
return;
}
syncAttributes(current, next);
}
function morphNode(current: Node, next: Node): void {
if (current.nodeType === Node.TEXT_NODE || current.nodeType === Node.COMMENT_NODE) {
if (current.nodeValue !== next.nodeValue) current.nodeValue = next.nodeValue;
return;
}
const currentElement = current as Element;
const nextElement = next as Element;
if (currentElement instanceof HTMLImageElement && nextElement instanceof HTMLImageElement) {
morphImage(currentElement, nextElement);
return;
}
syncAttributes(currentElement, nextElement);
morphChildren(currentElement, nextElement);
}
function morphChildren(currentParent: ParentNode, nextParent: ParentNode): void {
const desiredChildren = Array.from(nextParent.childNodes);
let current = currentParent.firstChild;
for (const desired of desiredChildren) {
if (current && canMorph(current, desired)) {
const following = current.nextSibling;
morphNode(current, desired);
current = following;
continue;
}
// Insert only the new/mismatched subtree. Existing matching ancestors and
// their image descendants remain connected throughout streaming updates.
currentParent.insertBefore(desired.cloneNode(true), current);
}
while (current) {
const following = current.nextSibling;
currentParent.removeChild(current);
current = following;
}
}
/**
* Patch sanitized streaming HTML in place.
*
* Replacing innerHTML — or moving decoded images through a detached template —
* makes Chromium briefly drop the image's painted layer on every typewriter
* frame. This directive morphs text and surrounding markup without detaching a
* matching loaded <img> node.
*/
export const vStableHtml: ObjectDirective<HTMLElement, string> = {
beforeMount(el, binding) {
el.innerHTML = binding.value || '';
},
updated(el, binding) {
const html = binding.value || '';
if (html === binding.oldValue) return;
const template = document.createElement('template');
template.innerHTML = html;
morphChildren(el, template.content);
},
};
@@ -6,8 +6,14 @@ import {
preprocessMathDelimiters,
renderChatMarkdown,
replaceIncompleteImageWithPlaceholder,
stripTrailingStreamingHorizontalRule,
} from './chatMarkdownRenderer.ts'
import { resolveCitationChunkId, joinCitationTagsToPreviousLine, collapseStandaloneCitationParagraphs } from './citationMarkdown.ts'
import {
collapseStandaloneCitationParagraphs,
joinCitationTagsToPreviousLine,
resolveCitationChunkId,
stripIncompleteCitationTag,
} from './citationMarkdown.ts'
const SAMPLE_DOC = 'example-report.docx'
const SAMPLE_CHUNK_A = '00000001-0000-4000-8000-000000000001'
@@ -29,6 +35,35 @@ test('replaceIncompleteImageWithPlaceholder hides an unfinished streaming image'
)
})
test('stripIncompleteCitationTag hides only an unfinished streaming citation tail', () => {
const prefix = 'Source '
const complete = '<kb doc="2.jpg" chunk_id="3c67efd5-f2ff-4e26-9032-9e44e6861178" />'
for (const partial of ['<', '<k', '<kb', '<kb ', '<kb doc="2.jpg"', '<w', '<we', '<web url="https://example.com"']) {
assert.equal(stripIncompleteCitationTag(prefix + partial), prefix)
}
assert.equal(stripIncompleteCitationTag(prefix + complete), prefix + complete)
assert.equal(stripIncompleteCitationTag('Value < 5'), 'Value < 5')
})
test('stripTrailingStreamingHorizontalRule hides an ambiguous trailing rule only mid-stream', () => {
for (const rule of ['---', '* * *', '___']) {
assert.equal(stripTrailingStreamingHorizontalRule(`- item\n\n${rule}`), '- item\n\n')
}
assert.equal(stripTrailingStreamingHorizontalRule('- item\n\n---\nnext'), '- item\n\n---\nnext')
const renderer = createChatMarkdownRenderer()
const options = {
renderer,
escapeMarkdown: (text: string) => text,
sanitizeHtml: (html: string) => html,
}
const source = '- item\n\n---'
assert.doesNotMatch(renderChatMarkdown(source, { ...options, streaming: true }), /<hr>/)
assert.match(renderChatMarkdown(source, { ...options, streaming: false }), /<hr>/)
})
test('renderChatMarkdown preserves citations, math, and sanitized output through one shared pipeline', () => {
const renderer = createChatMarkdownRenderer({
imageRenderer: ({ href, title, text }) =>
+24 -1
View File
@@ -9,6 +9,7 @@ import {
preserveCitationTags,
restoreCitationHtmlPlaceholders,
restoreCitationTags,
stripIncompleteCitationTag,
type CitationKnowledgeRef,
} from './citationMarkdown.ts'
@@ -34,6 +35,8 @@ export type RenderChatMarkdownOptions = {
renderer: Renderer
escapeMarkdown: (markdown: string) => string
sanitizeHtml: (html: string) => string
/** The source is still growing and may end in ambiguous partial Markdown. */
streaming?: boolean
collapseStandaloneCitations?: boolean
knowledgeReferences?: CitationKnowledgeRef[] | null
cachedMermaidSvgHtml?: string | null
@@ -75,6 +78,22 @@ export function replaceIncompleteImageWithPlaceholder(content: string): string {
return content
}
/**
* Hide a trailing Markdown horizontal-rule candidate while content is streaming.
*
* A model often emits `---` as the beginning of a table delimiter or another
* structure. At that exact typewriter frame, marked renders it as `<hr>`, then
* removes it when more characters arrive. A real completed horizontal rule is
* still rendered because this guard is enabled only for an active stream.
*/
export function stripTrailingStreamingHorizontalRule(content: string): string {
if (!content) return content
return content.replace(
/(^|\n)[ \t]{0,3}(?:(?:-[ \t]*){3,}|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/,
'$1',
)
}
export function createChatMarkdownRenderer(options: ChatMarkdownRendererOptions = {}): Renderer {
const renderer = new marked.Renderer()
@@ -113,7 +132,11 @@ export function renderChatMarkdown(rawMarkdown: unknown, options: RenderChatMark
configureMarkedForChatMarkdown()
const { text: tagSafe, tags } = preserveCitationTags(rawText)
const streamingSafeText = options.streaming
? stripTrailingStreamingHorizontalRule(rawText)
: rawText
const citationSafeText = stripIncompleteCitationTag(streamingSafeText)
const { text: tagSafe, tags } = preserveCitationTags(citationSafeText)
const imageSafe = replaceIncompleteImageWithPlaceholder(tagSafe)
const mathSafe = preprocessMathDelimiters(imageSafe)
const restoredTags = restoreCitationTags(mathSafe, tags)
+23
View File
@@ -8,6 +8,29 @@ const WEB_TAG_ATTR_RE = /<web\b([^>]*?)\s*\/?>/g
const ATTRIBUTE_REGEX = /([\w-]+)\s*=\s*"([^"]*)"/g
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
/**
* Hide a citation tag while the typewriter has only emitted part of it.
*
* Without this guard, Markdown renders the leading `<` as ordinary text until
* the closing `>` arrives. Only the unfinished tail is removed; a complete tag
* continues through the normal citation pipeline.
*/
export function stripIncompleteCitationTag(content: string): string {
if (!content) return content
const start = content.lastIndexOf('<')
if (start < 0) return content
const tail = content.slice(start)
if (tail.includes('>')) return content
const isCitationPrefix = tail === '<'
|| /^<k(?:b(?:\s[\s\S]*)?)?$/i.test(tail)
|| /^<w(?:e(?:b(?:\s[\s\S]*)?)?)?$/i.test(tail)
return isCitationPrefix ? content.slice(0, start) : content
}
export type CitationKnowledgeRef = {
id?: string
knowledge_id?: string
+2 -2
View File
@@ -2,7 +2,7 @@ export const domPurifyForbidTags = ['script', 'style', 'object', 'embed', 'form'
export const domPurifyForbidAttr = ['onerror', 'onload', 'onclick', 'onmouseover', 'onfocus', 'onblur'] as const;
export const domPurifyAllowedUriRegexp =
/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|(?:local|minio|cos|tos|s3|oss|ks3|obs):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp|blob):|(?:local|minio|cos|tos|s3|oss|ks3|obs):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i;
/** Shared DOMPurify security options (FORBID_*, URI scheme, DOM flags). */
export const domPurifySecurityOptions = {
@@ -60,7 +60,7 @@ export const markdownDomPurifyConfig = {
],
ALLOWED_ATTR: [
'href', 'title', 'target', 'rel', 'data-tooltip', 'data-url', 'data-kb-id',
'data-chunk-id', 'data-doc', 'data-slug', 'class', 'role', 'tabindex', 'src', 'alt', 'data-protected-src',
'data-chunk-id', 'data-doc', 'data-slug', 'class', 'role', 'tabindex', 'src', 'alt', 'data-protected-src', 'data-img-loading',
'width', 'height', 'style', 'id', 'type', 'aria-label', 'data-mermaid', 'disabled',
'd', 'fill', 'stroke', 'stroke-width', 'stroke-linecap', 'stroke-linejoin',
'stroke-dasharray', 'stroke-dashoffset', 'stroke-miterlimit', 'stroke-opacity',
+151 -35
View File
@@ -32,7 +32,7 @@ const DOMPurifyConfig = {
],
// 允许的属性
ALLOWED_ATTR: [
'href', 'title', 'alt', 'src', 'class', 'id', 'style', 'data-protected-src',
'href', 'title', 'alt', 'src', 'class', 'id', 'style', 'data-protected-src', 'data-img-loading',
'target', 'rel', 'width', 'height', 'open',
'type', 'aria-label', 'disabled', 'role', 'tabindex',
// Mermaid SVG 支持的属性
@@ -99,7 +99,23 @@ export function protectProviderImageSrcInHTML(html: string): string {
(_m, before, quote, provider, restPathRaw, after) => {
const restPath = decodeProviderURL(restPathRaw);
const protectedSrc = `${provider}://${restPath}`;
return `<img${before} src=${quote}${PROVIDER_IMAGE_PLACEHOLDER}${quote} data-protected-src=${quote}${protectedSrc}${quote}${after}>`;
// A definitive 404 should not leave a skeleton behind. Streaming
// re-renders call this function repeatedly, so remember the missing
// source until the explicit end-of-stream retry clears the cache.
if (protectedFileMissingSources.has(protectedSrc)) {
return '';
}
// Reuse the already-hydrated blob if we have one, so repeated re-renders
// (typewriter streaming) keep the same stable image instead of flashing
// back to the placeholder every frame.
const cachedBlobURL = protectedFileBlobBySource.get(protectedSrc);
if (cachedBlobURL) {
return `<img${before} src=${quote}${cachedBlobURL}${quote} data-protected-src=${quote}${protectedSrc}${quote}${after}>`;
}
// Not hydrated yet: render the 1x1 placeholder but tag it so CSS can give
// it a stable skeleton box. Otherwise width:auto/height:auto collapse the
// 1x1 gif to a ~1px line that violently jumps to full size once loaded.
return `<img${before} src=${quote}${PROVIDER_IMAGE_PLACEHOLDER}${quote} data-protected-src=${quote}${protectedSrc}${quote} data-img-loading=${quote}1${quote}${after}>`;
},
);
}
@@ -288,15 +304,54 @@ export function createSafeImage(src: string, alt: string = '', title: string = '
return `<img src="${safeSrc}" alt="${safeAlt}" title="${safeTitle}" class="markdown-image" style="max-width: 100%; height: auto;">`;
}
const protectedFileBlobCache = new Map<string, string>();
type ProtectedFileLoadResult =
| { status: 'loaded'; blobURL: string }
| { status: 'missing' }
| { status: 'failed' };
type ProtectedFileCacheState = {
blobByRequest: Map<string, string>;
blobBySource: Map<string, string>;
missingSources: Set<string>;
failures: Map<string, number>;
inflight: Map<string, Promise<ProtectedFileLoadResult>>;
};
// Keep object URLs alive across Vite hot updates. A hot update replaces this
// module but not the page document, so module-local Maps would forget valid
// blob URLs and make already-loaded images fall back to the 1x1 placeholder.
const protectedFileCacheState = (() => {
const fresh = (): ProtectedFileCacheState => ({
blobByRequest: new Map(),
blobBySource: new Map(),
missingSources: new Set(),
failures: new Map(),
inflight: new Map(),
});
if (typeof window === 'undefined') return fresh();
const scope = window as typeof window & {
__weknoraProtectedFileCacheV1__?: ProtectedFileCacheState;
};
scope.__weknoraProtectedFileCacheV1__ ||= fresh();
return scope.__weknoraProtectedFileCacheV1__;
})();
const protectedFileBlobCache = protectedFileCacheState.blobByRequest;
// Blob URL keyed by the protected source URL (e.g. `local://...`). Once an image
// has been hydrated, re-renders of the same markdown can emit the blob src
// directly instead of the placeholder. Without this, the typewriter re-renders
// the answer every frame, recreating each <img> as a placeholder that hydration
// only restores a microtask later — which reads as a per-frame flicker.
const protectedFileBlobBySource = protectedFileCacheState.blobBySource;
const protectedFileMissingSources = protectedFileCacheState.missingSources;
// Throttle retries of failed file fetches. During streaming the same markdown
// is re-rendered on every chunk, producing brand-new <img> elements (so the
// per-element `authHydrated` flag is reset each time). Without throttling a
// not-yet-generated file (404) would be re-requested on every chunk. We record
// the last failure time per URL and skip re-fetching within a cooldown window,
// while still allowing a later attempt once the file becomes available.
const protectedFileFailureCache = new Map<string, number>();
const protectedFileInflight = new Set<string>();
const protectedFileFailureCache = protectedFileCacheState.failures;
const protectedFileInflight = protectedFileCacheState.inflight;
const PROTECTED_FILE_RETRY_COOLDOWN_MS = 5000;
function getProtectedFileRequestHeaders(): Record<string, string> {
@@ -333,6 +388,43 @@ function getProtectedFileRequestHeaders(): Record<string, string> {
*/
export function clearProtectedFileFailureCache(): void {
protectedFileFailureCache.clear();
protectedFileMissingSources.clear();
}
function protectedImageSource(img: HTMLImageElement): string {
return normalizeProtectedImageElement(img)
|| (img.getAttribute('data-protected-src') || '').trim()
|| (img.getAttribute('src') || '').trim();
}
function forEachProtectedImageWithSource(
root: ParentNode,
sourceURL: string,
callback: (img: HTMLImageElement) => void,
): void {
root.querySelectorAll<HTMLImageElement>('img[data-protected-src]').forEach((candidate) => {
if (protectedImageSource(candidate) === sourceURL) callback(candidate);
});
}
function removeMissingProtectedImages(root: ParentNode, sourceURL: string): void {
forEachProtectedImageWithSource(root, sourceURL, (img) => {
const parent = img.parentElement;
img.remove();
// Markdown emits a dedicated paragraph for a standalone image. Remove that
// wrapper too so a missing image leaves no vertical placeholder/gap.
if (parent?.tagName === 'P' && !parent.textContent?.trim() && parent.children.length === 0) {
parent.remove();
}
});
}
function applyHydratedProtectedImage(root: ParentNode, sourceURL: string, blobURL: string): void {
forEachProtectedImageWithSource(root, sourceURL, (img) => {
img.src = blobURL;
img.dataset.authHydrated = '1';
img.removeAttribute('data-img-loading');
});
}
export async function hydrateProtectedFileImages(
@@ -367,6 +459,10 @@ export async function hydrateProtectedFileImages(
if (img.dataset.authHydrated === '1') {
return;
}
if (protectedFileMissingSources.has(sourceURL)) {
removeMissingProtectedImages(root, sourceURL);
return;
}
img.dataset.authHydrated = '1';
const isProviderScheme = isProviderFileURL(sourceURL);
@@ -388,46 +484,66 @@ export async function hydrateProtectedFileImages(
const cachedBlobURL = protectedFileBlobCache.get(requestURL);
if (cachedBlobURL) {
img.src = cachedBlobURL;
applyHydratedProtectedImage(root, sourceURL, cachedBlobURL);
return;
}
// Skip while a fetch for the same URL is already in flight, or while the
// last attempt failed recently. Allow a fresh attempt to fix the element.
if (protectedFileInflight.has(requestURL)) {
img.dataset.authHydrated = '0';
return;
}
const lastFailure = protectedFileFailureCache.get(requestURL);
if (lastFailure !== undefined && Date.now() - lastFailure < PROTECTED_FILE_RETRY_COOLDOWN_MS) {
img.dataset.authHydrated = '0';
return;
}
protectedFileInflight.add(requestURL);
try {
const resp = await fetch(requestURL, {
method: 'GET',
headers,
credentials: 'include',
});
if (!resp.ok) {
throw new Error(`HTTP ${resp.status}`);
}
const blob = await resp.blob();
const blobURL = URL.createObjectURL(blob);
protectedFileBlobCache.set(requestURL, blobURL);
protectedFileFailureCache.delete(requestURL);
img.src = blobURL;
if (protectedSrc) {
img.removeAttribute('data-protected-src');
}
} catch (error) {
console.warn('[security] hydrateProtectedFileImages failed:', error);
protectedFileFailureCache.set(requestURL, Date.now());
// Every component that references the same image awaits the shared task.
// The previous Set-based de-dupe made later components return immediately;
// only the component that started the fetch was updated, leaving all other
// occurrences stuck on the transparent placeholder forever.
let loadTask = protectedFileInflight.get(requestURL);
if (!loadTask) {
loadTask = (async (): Promise<ProtectedFileLoadResult> => {
try {
const resp = await fetch(requestURL, {
method: 'GET',
headers,
credentials: 'include',
});
if (!resp.ok) {
if (resp.status === 404) {
protectedFileFailureCache.set(requestURL, Date.now());
return { status: 'missing' };
}
throw new Error(`HTTP ${resp.status}`);
}
const blob = await resp.blob();
const blobURL = URL.createObjectURL(blob);
protectedFileBlobCache.set(requestURL, blobURL);
protectedFileFailureCache.delete(requestURL);
return { status: 'loaded', blobURL };
} catch (error) {
console.warn('[security] hydrateProtectedFileImages failed:', error);
protectedFileFailureCache.set(requestURL, Date.now());
return { status: 'failed' };
} finally {
protectedFileInflight.delete(requestURL);
}
})();
protectedFileInflight.set(requestURL, loadTask);
}
const result = await loadTask;
if (result.status === 'loaded') {
protectedFileBlobBySource.set(sourceURL, result.blobURL);
protectedFileMissingSources.delete(sourceURL);
applyHydratedProtectedImage(root, sourceURL, result.blobURL);
return;
}
if (result.status === 'missing') {
protectedFileMissingSources.add(sourceURL);
removeMissingProtectedImages(root, sourceURL);
return;
}
if (result.status === 'failed') {
img.dataset.authHydrated = '0';
} finally {
protectedFileInflight.delete(requestURL);
}
}));
}
@@ -260,7 +260,7 @@
<div v-else-if="event.type === 'answer' && (event.done || (event.content && event.content.trim()))"
class="answer-event">
<div v-if="event.content && event.content.trim()" class="answer-content markdown-content">
<div :key="event.content" v-html="renderAnswerContent(event.content)"></div>
<div v-stable-html="renderAnswerContent(event === activeAnswerEventRef ? typedAnswer : event.content)"></div>
</div>
<div v-if="event.done && event.content && event.content.trim() && !embeddedMode" class="answer-toolbar">
<t-button size="small" variant="outline" shape="round" @click.stop="handleCopyAnswer(event)"
@@ -456,6 +456,8 @@ import {
renderMermaidToSvg,
} from '@/utils/mermaidShared';
import { attachMarkdownEnhancementListeners, refreshMarkdownEnhancements } from '@/utils/markdownEnhancements';
import { useTypewriter } from '@/composables/useTypewriter';
import { vStableHtml } from '@/directives/stableHtml';
const getToolIconName = getAgentToolIconName;
@@ -884,6 +886,23 @@ const activeAnswerMarkdown = computed(() => {
return typeof active?.content === 'string' ? active.content : '';
});
// The answer event whose text is currently streaming. The template renders the
// smoothed typewriter text for this event and the raw content for any others.
const activeAnswerEventRef = computed(() => {
const stream = eventStream.value;
if (!stream?.length) return null;
const answers = stream.filter((e: any) => e.type === 'answer' && !e.superseded);
return answers.find((e: any) => !e.done) ?? answers[answers.length - 1] ?? null;
});
// Smooth the streamed answer into a steady typewriter cadence (shared with the
// non-Agent markdown path). History reloads arrive already complete and snap to
// full instead of replaying.
const { displayed: typedAnswer } = useTypewriter(
() => activeAnswerMarkdown.value,
() => isConversationDone.value,
);
const cacheStreamingMermaidSvg = async () => {
if (streamingMermaidSvgCache.value) return;
const code = extractFirstMermaidCode(activeAnswerMarkdown.value);
@@ -921,10 +940,21 @@ watch(activeAnswerMarkdown, () => {
// Files referenced mid-stream (e.g. exported images) may only become available
// at completion; throttling stops the chunk-by-chunk 404 spam during streaming,
// and this final pass guarantees they load without waiting out the cooldown.
watch(isConversationDone, (done) => {
if (!done) return;
//
// Gate this on the typewriter having fully revealed the answer: when done flips,
// the smoothed text may still be catching up, so the <img> tag is not in the DOM
// yet. Hydrating too early would find nothing and leave a permanent placeholder
// (until a manual reload). Waiting for full reveal guarantees the image exists.
const answerFullyRendered = computed(
() => isConversationDone.value && typedAnswer.value.length >= activeAnswerMarkdown.value.length,
);
watch(answerFullyRendered, (ready) => {
if (!ready) return;
// Clear before this reactive update renders, so a source that returned 404
// mid-stream gets one real final-attempt <img> node instead of remaining
// suppressed by the missing-source cache.
clearProtectedFileFailureCache();
nextTick(async () => {
clearProtectedFileFailureCache();
await hydrateProtectedFileImages(rootElement.value);
});
});
@@ -1649,8 +1679,15 @@ onBeforeUnmount(() => {
});
onUpdated(() => {
nextTick(() => {
nextTick(async () => {
rebindCitations();
// Hydrate protected-file images (e.g. local:// exports) as soon as the
// typewriter reveals their <img> into the DOM, so they show in real time
// mid-stream instead of waiting for the turn to finish. Hydration is cheap
// and idempotent: blob results are cached per URL, in-flight fetches are
// de-duped, and failures back off for a cooldown — so a not-yet-ready file
// simply retries later (and the answerFullyRendered pass is the backstop).
await hydrateProtectedFileImages(rootElement.value);
});
});
@@ -1676,6 +1713,7 @@ const renderAgentMarkdown = (
renderer: agentRenderer,
escapeMarkdown,
sanitizeHtml: sanitizeMarkdownHTML,
streaming: !isConversationDone.value,
knowledgeReferences: props.session?.knowledge_references,
cachedMermaidSvgHtml: streamingMermaidSvgCache.value,
prepareMarkdown: prepareAgentMarkdown,
@@ -2316,8 +2354,6 @@ const handleAddToKnowledge = (answerEvent: any) => {
.chat-citation-pills();
:deep(img) {
min-height: 100px;
/* 防止流式输出时图片高度塌陷导致抖动 */
background-color: var(--td-bg-color-secondarycontainer);
/* 加载时的占位背景色 */
}
+16 -2
View File
@@ -31,7 +31,7 @@
<!-- 直接渲染完整内容,避免切分导致的问题,样式与 thinking 一致 -->
<!-- 只有当有实际内容时才显示包围框 -->
<div class="content-wrapper" v-if="hasActualContent">
<div class="ai-markdown-template markdown-content" v-html="renderedHTML">
<div class="ai-markdown-template markdown-content" v-stable-html="renderedHTML">
</div>
</div>
<!-- Streaming indicator (non-Agent mode) -->
@@ -101,6 +101,8 @@ import {
} from '@/utils/mermaidShared';
import { refreshMarkdownEnhancements } from '@/utils/markdownEnhancements';
import { useChatCitationPopover } from '@/composables/useChatCitationPopover';
import { useTypewriter } from '@/composables/useTypewriter';
import { vStableHtml } from '@/directives/stableHtml';
ensureMermaidInitialized();
@@ -170,14 +172,26 @@ const mentionedItems = computed(() => {
return props.session?.mentioned_items || [];
});
// Smooth the streamed answer into a steady typewriter cadence (shared with the
// Agent path). Copy/toolbar still read the full content; only display is paced.
const answerText = computed(() => {
const text = props.content || props.session?.content || '';
return typeof text === 'string' ? text : '';
});
const { displayed: typedAnswer } = useTypewriter(
() => answerText.value,
() => Boolean(props.session?.is_completed),
);
// 单次渲染整个 Markdown 内容(替代 token-by-token,修复 KaTeX 公式在 streaming 时闪烁消失的问题)
const renderedHTML = computed(() => {
const text = props.content || props.session?.content || '';
const text = typedAnswer.value;
if (!text || typeof text !== 'string') return '';
return renderChatMarkdown(text, {
renderer: markdownRenderer,
escapeMarkdown: safeMarkdownToHTML,
sanitizeHtml: sanitizeMarkdownHTML,
streaming: !props.session?.is_completed,
knowledgeReferences: props.session?.knowledge_references,
});
});
+7
View File
@@ -126,6 +126,7 @@ import { useUIStore } from '@/stores/ui';
import KnowledgeBaseEditorModal from '@/views/knowledge/KnowledgeBaseEditorModal.vue';
import { useKnowledgeBaseCreationNavigation } from '@/hooks/useKnowledgeBaseCreationNavigation';
import { useChatStreamHandler } from '@/composables/useChatStreamHandler';
import { useStickyBottomOnResize } from '@/composables/useStickyBottomOnResize';
import { clearCitationChunkCache } from '@/utils/citationChunkCache';
const props = defineProps({
@@ -392,6 +393,12 @@ const onClickScrollToBottom = () => {
userHasScrolledUp.value = false;
scrollToBottom(true);
}
// Images and other rich Markdown content can grow after the SSE chunk that
// introduced them. Follow those delayed height changes while the user remains
// at the live edge; preserve position when they intentionally scroll upward.
useStickyBottomOnResize(scrollContainer, userHasScrolledUp, scrollToBottom);
const debounce = (fn, delay) => {
let timer
return (...args) => {
+13 -2
View File
@@ -13,7 +13,7 @@
<DeepThink v-if="session?.showThink && !session?.isAgentMode" :deep-session="session" />
<div v-if="!session?.hideContent && !session?.isAgentMode" ref="parentMd">
<div v-if="hasActualContent" class="content-wrapper">
<div class="ai-markdown-template markdown-content" v-html="renderedHTML" />
<div class="ai-markdown-template markdown-content" v-stable-html="renderedHTML" />
</div>
<div v-if="hasActualContent && !session?.is_completed" class="loading-indicator">
<div class="loading-typing">
@@ -63,6 +63,8 @@ import {
enhanceMarkdownContainer,
} from '@/utils/mermaidShared'
import { useEmbedCitationPopover } from '@/composables/useEmbedCitationPopover'
import { useTypewriter } from '@/composables/useTypewriter'
import { vStableHtml } from '@/directives/stableHtml'
const RagPipelineProgress = defineAsyncComponent(
() => import('@/views/chat/components/RagPipelineProgress.vue'),
@@ -142,13 +144,22 @@ const scheduleCitationClose = () => {
}, 120)
}
// Smooth the streamed answer into a steady typewriter cadence (shared with the
// Agent path). History reloads arrive complete and snap to full.
const answerText = computed(() => String(props.content || props.session?.content || ''))
const { displayed: typedAnswer } = useTypewriter(
() => answerText.value,
() => Boolean(props.session?.is_completed),
)
const renderedHTML = computed(() => {
const text = String(props.content || props.session?.content || '')
const text = typedAnswer.value
if (!text.trim()) return ''
return renderChatMarkdown(text, {
renderer: markdownRenderer,
escapeMarkdown: safeMarkdownToHTML,
sanitizeHtml: sanitizeMarkdownHTML,
streaming: !props.session?.is_completed,
})
})