@agent-native/toolkit 0.23.1 → 0.198.1

package/dist/app/chat/chat/markdown-renderer.d.ts

@@ -0,0 +1,77 @@
+import React from "react";
+import type { default as ReactMarkdownType } from "react-markdown";
+import type { defaultUrlTransform as DefaultUrlTransformType } from "react-markdown";
+import type remarkGfmType from "remark-gfm";
+type ReactMarkdownModule = {
+    default: typeof ReactMarkdownType;
+    defaultUrlTransform: typeof DefaultUrlTransformType;
+};
+export declare let markdownModule: ReactMarkdownModule | null;
+export declare let remarkGfmFn: typeof remarkGfmType | null;
+export declare function loadMarkdown(): void;
+export declare function onMarkdownReady(fn: () => void): () => void;
+type ShikiHighlighter = {
+    codeToHtml: (code: string, options: {
+        lang: string;
+        themes: {
+            light: string;
+            dark: string;
+        };
+        defaultColor?: false | "light" | "dark";
+    }) => string | Promise<string>;
+    getLoadedLanguages: () => string[];
+};
+export declare function loadHighlighter(): Promise<ShikiHighlighter>;
+export declare const TextStreamingContext: React.Context<boolean>;
+export declare const ExternalTextStreamingContext: React.Context<boolean>;
+export declare const AgentRunActiveContext: React.Context<boolean | undefined>;
+export interface ActiveTextStreamingIdentity {
+    runId: string | null;
+    turnId: string | null;
+}
+export declare const ActiveTextStreamingIdentityContext: React.Context<ActiveTextStreamingIdentity | null>;
+export declare function AgentTextStreamingProvider({ children, identity, streaming, runActive, }: {
+    children: React.ReactNode;
+    identity: ActiveTextStreamingIdentity | null;
+    streaming: boolean;
+    runActive: boolean;
+}): React.JSX.Element;
+export declare function messageMatchesActiveTextStream(message: unknown, activeIdentity: ActiveTextStreamingIdentity | null): boolean;
+export declare function HighlightedCodeBlock({ code, lang, }: {
+    code: string;
+    lang: string;
+}): React.JSX.Element;
+export declare function markdownUrlTransform(value: string): string;
+export declare function extractCodeText(child: React.ReactNode): string;
+export declare const markdownComponents: {
+    a(props: React.AnchorHTMLAttributes<HTMLAnchorElement>): React.JSX.Element;
+    table(props: React.TableHTMLAttributes<HTMLTableElement>): React.JSX.Element;
+    pre(props: React.HTMLAttributes<HTMLPreElement>): React.JSX.Element;
+};
+export declare function renderMarkdownToClipboardHtml(markdown: string): string | null;
+export declare function useSmoothStreamingText(targetText: string, streaming: boolean, resetKey: string): string;
+export declare function useMarkdownReady(): boolean;
+export declare const MemoizedMarkdownBlock: React.MemoExoticComponent<({ blockText, }: {
+    blockText: string;
+}) => React.JSX.Element | null>;
+export declare function StreamingText({ text, streaming, resetKey, statusType, animateStreaming, onRevealComplete, }: {
+    text: string;
+    streaming: boolean;
+    resetKey: string;
+    statusType?: string;
+    /** Allow callers to opt out for static or deliberately chunk-native surfaces. */
+    animateStreaming?: boolean;
+    onRevealComplete?: () => void;
+}): React.JSX.Element;
+/** @deprecated Use StreamingText for new AgentKit surfaces. */
+export declare const SmoothMarkdownText: typeof StreamingText;
+export declare function shouldAnimateMarkdownText({ textStreaming, isLastAssistantMessage, statusType, externalStreaming, activeMessageStreaming, runActive, }: {
+    textStreaming: boolean;
+    isLastAssistantMessage: boolean;
+    statusType: string;
+    externalStreaming?: boolean;
+    activeMessageStreaming?: boolean;
+    runActive?: boolean;
+}): boolean;
+export {};
+//# sourceMappingURL=markdown-renderer.d.ts.map

package/dist/app/chat/chat/markdown-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-renderer.d.ts","sourceRoot":"","sources":["../../../../src/app/chat/chat/markdown-renderer.tsx"],"names":[],"mappings":"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"}

package/dist/app/chat/chat/markdown-renderer.js

@@ -0,0 +1,578 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Owns the shared markdown loader, streaming text helpers, and renderer.
+import { NEW_CHAT_ACTION_HREF } from "@agent-native/core/client/agent-chat";
+import { cn } from "@agent-native/toolkit/utils";
+import { IconPlus, IconExternalLink } from "@tabler/icons-react";
+import React, { useState, useEffect, useCallback, useMemo, useRef, } from "react";
+import { splitMarkdownBlocks } from "../../../markdown-block-split.js";
+import { initialSmoothStreamingGraphemeCount, SMOOTH_STREAMING_COMMIT_INTERVAL_MS, smoothStreamingPunctuationDelayMs, smoothStreamingRevealCount, splitStreamingTextGraphemes, } from "../../../streaming-text-smoothing.js";
+import { HighlightedCodeBlock as SharedHighlightedCodeBlock } from "../HighlightedCodeBlock.js";
+import { IframeEmbed, parseEmbedBody } from "./IframeEmbed.js";
+import { LEGACY_CHART_SHORTHAND_LANG, LegacyChartShorthandChart, LegacyChartShorthandFallback, parseLegacyChartShorthand, wrapLegacyChartShorthandLines, } from "./legacy-chart-shorthand.js";
+export let markdownModule = null;
+export let remarkGfmFn = null;
+let renderToStaticMarkupFn = null;
+const markdownListeners = new Set();
+export function loadMarkdown() {
+    if (markdownModule !== null)
+        return; // already loaded
+    void Promise.all([
+        import("react-markdown"),
+        import("remark-gfm"),
+        // react-dom/server powers the synchronous markdown→HTML string used for
+        // rich clipboard copy; loaded alongside so readiness stays a single gate.
+        import("react-dom/server"),
+    ]).then(([md, gfm, server]) => {
+        markdownModule = md;
+        remarkGfmFn = gfm.default;
+        renderToStaticMarkupFn = server.renderToStaticMarkup;
+        markdownListeners.forEach((fn) => fn());
+        markdownListeners.clear();
+    });
+}
+export function onMarkdownReady(fn) {
+    if (markdownModule !== null) {
+        fn();
+        return () => { };
+    }
+    markdownListeners.add(fn);
+    return () => markdownListeners.delete(fn);
+}
+loadMarkdown();
+let highlighterLoader = null;
+export function loadHighlighter() {
+    if (!highlighterLoader) {
+        highlighterLoader = (async () => {
+            // Use the JavaScript regex engine instead of Oniguruma WASM (~608 KB saved).
+            // forgiving:true degrades unsupported patterns gracefully instead of throwing.
+            const [{ createHighlighterCore }, { createJavaScriptRegexEngine }] = await Promise.all([
+                import("shiki/core"),
+                import("shiki/engine/javascript"),
+            ]);
+            return createHighlighterCore({
+                themes: [
+                    import("shiki/themes/github-light-default.mjs"),
+                    import("shiki/themes/github-dark-default.mjs"),
+                ],
+                langs: [
+                    import("shiki/langs/javascript.mjs"),
+                    import("shiki/langs/typescript.mjs"),
+                    import("shiki/langs/jsx.mjs"),
+                    import("shiki/langs/tsx.mjs"),
+                    import("shiki/langs/json.mjs"),
+                    import("shiki/langs/css.mjs"),
+                    import("shiki/langs/html.mjs"),
+                    import("shiki/langs/markdown.mjs"),
+                    import("shiki/langs/bash.mjs"),
+                    import("shiki/langs/shellscript.mjs"),
+                    import("shiki/langs/python.mjs"),
+                    import("shiki/langs/yaml.mjs"),
+                    import("shiki/langs/sql.mjs"),
+                ],
+                engine: createJavaScriptRegexEngine({ forgiving: true }),
+            });
+        })().catch((error) => {
+            // Reset on failure so a future code block can retry instead of
+            // silently failing forever on a stale chunk / network blip.
+            highlighterLoader = null;
+            throw error;
+        });
+    }
+    return highlighterLoader;
+}
+// ─── Streaming context ───────────────────────────────────────────────────────
+// Declared at module level so HighlightedCodeBlock (used in markdownComponents
+// below) can read the current streaming state without the components object
+// needing to be rebuilt on every render.
+export const TextStreamingContext = React.createContext(false);
+export const ExternalTextStreamingContext = React.createContext(false);
+// `undefined` means "no chat host is providing run state", which is different
+// from `false` ("a host is providing it and the run has ended"). Embedded and
+// test surfaces render markdown without an AssistantChat above them, and they
+// must not be told the run is over.
+export const AgentRunActiveContext = React.createContext(undefined);
+export const ActiveTextStreamingIdentityContext = React.createContext(null);
+export function AgentTextStreamingProvider({ children, identity, streaming, runActive, }) {
+    return (_jsx(AgentRunActiveContext.Provider, { value: runActive, children: _jsx(ActiveTextStreamingIdentityContext.Provider, { value: identity, children: _jsx(TextStreamingContext.Provider, { value: streaming, children: children }) }) }));
+}
+function messageStreamingIdentity(message) {
+    const metadata = message?.metadata;
+    return {
+        runId: typeof metadata?.custom?.runId === "string"
+            ? metadata.custom.runId
+            : typeof metadata?.runId === "string"
+                ? metadata.runId
+                : null,
+        turnId: typeof metadata?.custom?.turnId === "string"
+            ? metadata.custom.turnId
+            : typeof metadata?.turnId === "string"
+                ? metadata.turnId
+                : null,
+    };
+}
+export function messageMatchesActiveTextStream(message, activeIdentity) {
+    if (!activeIdentity)
+        return false;
+    const messageIdentity = messageStreamingIdentity(message);
+    if (activeIdentity.turnId && messageIdentity.turnId) {
+        return activeIdentity.turnId === messageIdentity.turnId;
+    }
+    return Boolean(activeIdentity.runId &&
+        messageIdentity.runId &&
+        activeIdentity.runId === messageIdentity.runId);
+}
+// ─── HighlightedCodeBlock wrapper ────────────────────────────────────────────
+// Reads streaming state from context so markdownComponents (a static constant)
+// can opt into debounced highlighting without needing to rebuild on every render.
+export function HighlightedCodeBlock({ code, lang, }) {
+    const streaming = React.useContext(TextStreamingContext);
+    return (_jsx(SharedHighlightedCodeBlock, { code: code, lang: lang, containerClass: "agent-markdown-shiki", streaming: streaming, loadHighlighter: loadHighlighter }));
+}
+// ─── CTA helpers ─────────────────────────────────────────────────────────────
+const CTA_BUTTON_CLASSES = "agent-markdown-cta mt-1 inline-flex items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs font-medium text-background no-underline shadow-sm transition-colors hover:bg-foreground/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background cursor-pointer";
+function isBuilderErrorCtaHref(href) {
+    if (!href)
+        return false;
+    try {
+        const url = new URL(href);
+        if (url.protocol !== "https:" || url.hostname !== "builder.io") {
+            return false;
+        }
+        return ((url.origin === "https://builder.io" &&
+            url.pathname === "/account/space") ||
+            url.pathname === "/account/billing" ||
+            url.pathname === "/account/subscription" ||
+            /^\/app\/organizations\/[^/]+\/billing$/.test(url.pathname));
+    }
+    catch {
+        return false;
+    }
+}
+function opensMarkdownLinkInNewTab(href) {
+    if (!href || typeof window === "undefined")
+        return false;
+    try {
+        const url = new URL(href, window.location.href);
+        return ((url.protocol === "http:" || url.protocol === "https:") &&
+            url.origin !== window.location.origin);
+    }
+    catch {
+        // coercion-ok: malformed links remain in the current tab and are not fetched here.
+        return false;
+    }
+}
+// react-markdown's defaultUrlTransform strips href values whose protocol
+// isn't on its safe list (https, mailto, etc.). Our in-app pseudo-href
+// `agent-native:new-chat` would be blanked out by that, so let it through
+// while delegating every other URL to the default transform for sanitization.
+// Falls back to the value unchanged when the react-markdown module hasn't
+// landed yet (conservative: no stripping beats an empty href).
+export function markdownUrlTransform(value) {
+    if (value === NEW_CHAT_ACTION_HREF)
+        return value;
+    if (!markdownModule)
+        return value;
+    return markdownModule.defaultUrlTransform(value);
+}
+// ─── Code text extraction ─────────────────────────────────────────────────────
+export function extractCodeText(child) {
+    if (typeof child === "string")
+        return child;
+    if (Array.isArray(child))
+        return child.map(extractCodeText).join("");
+    if (React.isValidElement(child)) {
+        const props = child.props;
+        return extractCodeText(props.children);
+    }
+    return "";
+}
+// ─── Markdown components ──────────────────────────────────────────────────────
+export const markdownComponents = {
+    a(props) {
+        const { href, children, className, rel: _rel, target: _target, ...rest } = props;
+        if (href === NEW_CHAT_ACTION_HREF) {
+            // In-app action: dispatch a CustomEvent that MultiTabAssistantChat
+            // listens for and opens a new chat tab. Not an external navigation.
+            return (_jsxs("button", { type: "button", onClick: (e) => {
+                    e.preventDefault();
+                    window.dispatchEvent(new CustomEvent("agent-chat:new-chat"));
+                }, className: cn(CTA_BUTTON_CLASSES, className), children: [_jsx(IconPlus, { size: 13, strokeWidth: 2, "aria-hidden": "true" }), _jsx("span", { children: children })] }));
+        }
+        const isBuilderCta = isBuilderErrorCtaHref(href);
+        if (!isBuilderCta) {
+            const openInNewTab = opensMarkdownLinkInNewTab(href);
+            return (_jsx("a", { href: href, target: openInNewTab ? "_blank" : undefined, rel: openInNewTab ? "noopener noreferrer" : undefined, className: className, ...rest, children: children }));
+        }
+        return (_jsxs("a", { href: href, target: "_blank", rel: "noreferrer", className: cn(CTA_BUTTON_CLASSES, className), ...rest, children: [_jsx("span", { children: children }), _jsx(IconExternalLink, { size: 13, strokeWidth: 2, "aria-hidden": "true" })] }));
+    },
+    table(props) {
+        const { children, ...rest } = props;
+        return (_jsx("div", { className: "agent-markdown-table-wrap", children: _jsx("table", { ...rest, children: children }) }));
+    },
+    pre(props) {
+        const { children, ...rest } = props;
+        if (React.isValidElement(children)) {
+            const childProps = children.props;
+            const className = childProps.className || "";
+            if (/\blanguage-embed\b/.test(className)) {
+                const body = extractCodeText(childProps.children);
+                const parsed = parseEmbedBody(body);
+                return (_jsx(IframeEmbed, { ...parsed }));
+            }
+            if (new RegExp(`\\blanguage-${LEGACY_CHART_SHORTHAND_LANG}\\b`).test(className)) {
+                const body = extractCodeText(childProps.children).replace(/\n$/, "");
+                const parsed = parseLegacyChartShorthand(body);
+                return parsed ? (_jsx(LegacyChartShorthandChart, { parsed: parsed })) : (_jsx(LegacyChartShorthandFallback, { text: body }));
+            }
+            const langMatch = className.match(/\blanguage-([\w+-]+)\b/);
+            if (langMatch) {
+                const code = extractCodeText(childProps.children).replace(/\n$/, "");
+                return _jsx(HighlightedCodeBlock, { code: code, lang: langMatch[1] });
+            }
+        }
+        return _jsx("pre", { ...rest, children: children });
+    },
+};
+// ─── Clipboard HTML rendering ─────────────────────────────────────────────────
+// A stripped component set for the `text/html` clipboard flavor: plain <a> and
+// <pre>/<code> with no in-app buttons, iframes, or syntax-highlight markup, so
+// pasted output is portable structure (bold, lists, links, code) rather than
+// app-specific chrome that receiving apps (Slack, Notion) discard anyway.
+const clipboardMarkdownComponents = {
+    a(props) {
+        const { href, children } = props;
+        if (href === NEW_CHAT_ACTION_HREF || !href)
+            return _jsx("span", { children: children });
+        return _jsx("a", { href: href, children: children });
+    },
+    pre(props) {
+        return _jsx("pre", { children: props.children });
+    },
+};
+// Renders joined message markdown to an HTML string for rich clipboard copy.
+// Returns null when the lazy markdown/react-dom-server modules haven't landed
+// yet; callers fall back to plain-text copy in that case.
+export function renderMarkdownToClipboardHtml(markdown) {
+    const ReactMarkdown = markdownModule?.default;
+    const gfm = remarkGfmFn;
+    const renderToStaticMarkup = renderToStaticMarkupFn;
+    if (!ReactMarkdown || !gfm || !renderToStaticMarkup)
+        return null;
+    return renderToStaticMarkup(_jsx(ReactMarkdown, { remarkPlugins: [gfm], components: clipboardMarkdownComponents, urlTransform: markdownUrlTransform, children: markdown }));
+}
+// ─── Smooth streaming ─────────────────────────────────────────────────────────
+function usePrefersReducedMotion() {
+    const [prefersReducedMotion, setPrefersReducedMotion] = useState(() => typeof window !== "undefined" && window.matchMedia
+        ? window.matchMedia("(prefers-reduced-motion: reduce)").matches
+        : false);
+    useEffect(() => {
+        if (typeof window === "undefined" || !window.matchMedia)
+            return undefined;
+        const media = window.matchMedia("(prefers-reduced-motion: reduce)");
+        const handleChange = () => setPrefersReducedMotion(media.matches);
+        handleChange();
+        if (typeof media.addEventListener === "function") {
+            media.addEventListener("change", handleChange);
+            return () => media.removeEventListener("change", handleChange);
+        }
+        media.addListener(handleChange);
+        return () => media.removeListener(handleChange);
+    }, []);
+    return prefersReducedMotion;
+}
+function sliceGraphemes(targetText, graphemes, count) {
+    if (count >= graphemes.length)
+        return targetText;
+    if (count <= 0)
+        return "";
+    return graphemes.slice(0, count).join("");
+}
+// Grouped message parts are rebuilt as tool calls arrive. A text part can
+// therefore be unmounted and mounted again even though its identity did not
+// change. Keep the reveal state outside that subtree so a structural update
+// continues from the current position instead of replaying the opening sentence.
+const smoothStreamingTextCache = new Map();
+function cachedStreamingText(resetKey, targetText) {
+    const cached = smoothStreamingTextCache.get(resetKey);
+    if (!cached)
+        return undefined;
+    if (!targetText.startsWith(cached.targetText) ||
+        !targetText.startsWith(cached.visibleText)) {
+        return undefined;
+    }
+    return cached.visibleText;
+}
+function rememberStreamingText(resetKey, targetText, visibleText) {
+    smoothStreamingTextCache.delete(resetKey);
+    smoothStreamingTextCache.set(resetKey, { targetText, visibleText });
+    if (smoothStreamingTextCache.size <= 128)
+        return;
+    const oldestKey = smoothStreamingTextCache.keys().next().value;
+    if (oldestKey !== undefined)
+        smoothStreamingTextCache.delete(oldestKey);
+}
+/** Stable placeholder so the grapheme ref stays `string[]` before it is seeded. */
+const EMPTY_GRAPHEMES = [];
+export function useSmoothStreamingText(targetText, streaming, resetKey) {
+    const prefersReducedMotion = usePrefersReducedMotion();
+    const [visibleText, setVisibleText] = useState(() => {
+        if (!streaming || prefersReducedMotion)
+            return targetText;
+        const cachedText = cachedStreamingText(resetKey, targetText);
+        if (cachedText !== undefined)
+            return cachedText;
+        const graphemes = splitStreamingTextGraphemes(targetText);
+        return sliceGraphemes(targetText, graphemes, initialSmoothStreamingGraphemeCount(graphemes));
+    });
+    const visibleTextRef = useRef(visibleText);
+    const targetTextRef = useRef(targetText);
+    // `useRef(expr)` evaluates `expr` on EVERY render and throws it away after
+    // mount. Segmenting here therefore ran a full Intl.Segmenter pass per commit
+    // — up to 60Hz per streaming message — and, because `visibleText` is a strict
+    // prefix of `targetText`, that pass could never hit the incremental path and
+    // evicted the shared segmenter cache for every other live stream too. Seed
+    // once; the streaming effect below keeps both refs authoritative after that.
+    const visibleCountRef = useRef(-1);
+    const targetGraphemesRef = useRef(EMPTY_GRAPHEMES);
+    if (visibleCountRef.current < 0) {
+        if (streaming && !prefersReducedMotion) {
+            targetGraphemesRef.current = splitStreamingTextGraphemes(targetText);
+            visibleCountRef.current = splitStreamingTextGraphemes(visibleText).length;
+        }
+        else {
+            visibleCountRef.current = 0;
+        }
+    }
+    const frameRef = useRef(null);
+    const lastCommitAtRef = useRef(0);
+    const pauseUntilRef = useRef(0);
+    const inputDoneRef = useRef(false);
+    const resetKeyRef = useRef(resetKey);
+    const cacheKeyRef = useRef(resetKey);
+    const cacheStreamingRef = useRef(streaming);
+    const cacheReducedMotionRef = useRef(prefersReducedMotion);
+    const stepRef = useRef(() => { });
+    cacheKeyRef.current = resetKey;
+    cacheStreamingRef.current = streaming;
+    cacheReducedMotionRef.current = prefersReducedMotion;
+    const commitVisibleCount = useCallback((nextCount) => {
+        const graphemes = targetGraphemesRef.current;
+        const boundedCount = Math.max(0, Math.min(nextCount, graphemes.length));
+        const nextText = sliceGraphemes(targetTextRef.current, graphemes, boundedCount);
+        visibleCountRef.current = boundedCount;
+        if (visibleTextRef.current !== nextText) {
+            visibleTextRef.current = nextText;
+            setVisibleText(nextText);
+        }
+        if (cacheStreamingRef.current && !cacheReducedMotionRef.current) {
+            rememberStreamingText(cacheKeyRef.current, targetTextRef.current, nextText);
+        }
+    }, []);
+    const cancelFrame = useCallback(() => {
+        if (frameRef.current != null &&
+            typeof window !== "undefined" &&
+            typeof window.cancelAnimationFrame === "function") {
+            window.cancelAnimationFrame(frameRef.current);
+        }
+        frameRef.current = null;
+        pauseUntilRef.current = 0;
+    }, []);
+    const scheduleFrame = useCallback(() => {
+        if (frameRef.current != null)
+            return;
+        if (typeof window === "undefined" ||
+            typeof window.requestAnimationFrame !== "function") {
+            commitVisibleCount(targetGraphemesRef.current.length);
+            return;
+        }
+        frameRef.current = window.requestAnimationFrame((time) => {
+            frameRef.current = null;
+            stepRef.current(time);
+        });
+    }, [commitVisibleCount]);
+    stepRef.current = (time) => {
+        const targetGraphemes = targetGraphemesRef.current;
+        const backlog = targetGraphemes.length - visibleCountRef.current;
+        if (backlog <= 0) {
+            pauseUntilRef.current = 0;
+            return;
+        }
+        if (pauseUntilRef.current > time) {
+            scheduleFrame();
+            return;
+        }
+        const lastCommitAt = lastCommitAtRef.current || time - SMOOTH_STREAMING_COMMIT_INTERVAL_MS;
+        if (time - lastCommitAt < SMOOTH_STREAMING_COMMIT_INTERVAL_MS &&
+            backlog > 1) {
+            scheduleFrame();
+            return;
+        }
+        const revealCount = smoothStreamingRevealCount({
+            backlog,
+            elapsedMs: Math.min(120, Math.max(8, time - lastCommitAt)),
+            inputDone: inputDoneRef.current,
+        });
+        if (revealCount > 0) {
+            const nextCount = visibleCountRef.current + revealCount;
+            commitVisibleCount(nextCount);
+            lastCommitAtRef.current = time;
+            const nextBacklog = targetGraphemes.length - visibleCountRef.current;
+            const pauseMs = smoothStreamingPunctuationDelayMs(targetGraphemes[visibleCountRef.current - 1], nextBacklog);
+            pauseUntilRef.current = pauseMs > 0 ? time + pauseMs : 0;
+        }
+        if (visibleCountRef.current < targetGraphemes.length) {
+            scheduleFrame();
+        }
+        else {
+            pauseUntilRef.current = 0;
+        }
+    };
+    useEffect(() => {
+        targetTextRef.current = targetText;
+        const keyChanged = resetKeyRef.current !== resetKey;
+        resetKeyRef.current = resetKey;
+        const targetGraphemes = splitStreamingTextGraphemes(targetText);
+        const shouldSettleBufferedText = !keyChanged &&
+            !streaming &&
+            !prefersReducedMotion &&
+            visibleTextRef.current.length > 0 &&
+            visibleTextRef.current !== targetText &&
+            targetText.startsWith(visibleTextRef.current);
+        if (shouldSettleBufferedText) {
+            targetGraphemesRef.current = targetGraphemes;
+            inputDoneRef.current = true;
+            if (visibleCountRef.current < targetGraphemes.length) {
+                scheduleFrame();
+            }
+            return;
+        }
+        if (!streaming || prefersReducedMotion) {
+            cancelFrame();
+            inputDoneRef.current = false;
+            targetGraphemesRef.current = EMPTY_GRAPHEMES;
+            visibleCountRef.current = 0;
+            if (visibleTextRef.current !== targetText) {
+                visibleTextRef.current = targetText;
+                setVisibleText(targetText);
+            }
+            return;
+        }
+        targetGraphemesRef.current = targetGraphemes;
+        inputDoneRef.current = false;
+        const visibleNoLongerMatchesTarget = visibleTextRef.current.length > 0 &&
+            !targetText.startsWith(visibleTextRef.current);
+        if (keyChanged ||
+            visibleNoLongerMatchesTarget ||
+            visibleCountRef.current > targetGraphemes.length) {
+            commitVisibleCount(initialSmoothStreamingGraphemeCount(targetGraphemes));
+            lastCommitAtRef.current = 0;
+            pauseUntilRef.current = 0;
+        }
+        if (visibleCountRef.current < targetGraphemes.length) {
+            scheduleFrame();
+        }
+    }, [
+        targetText,
+        streaming,
+        prefersReducedMotion,
+        resetKey,
+        cancelFrame,
+        commitVisibleCount,
+        scheduleFrame,
+    ]);
+    useEffect(() => {
+        if (!streaming || prefersReducedMotion)
+            return;
+        rememberStreamingText(resetKey, targetText, visibleText);
+    }, [prefersReducedMotion, resetKey, streaming, targetText, visibleText]);
+    // When the tab returns from background, rAF has been paused and the backlog
+    // may be tens of thousands of characters. Animating from where we left off
+    // would replay minutes of content at the normal rate — instead jump the
+    // cursor to near the tail so only the final ~200 graphemes animate in.
+    // Reduced-motion users already get instant reveals (handled above), so this
+    // guard only applies to the normal animation path.
+    useEffect(() => {
+        if (typeof document === "undefined")
+            return;
+        const onVisibilityChange = () => {
+            if (document.visibilityState !== "visible")
+                return;
+            if (!streaming || prefersReducedMotion)
+                return;
+            const graphemes = targetGraphemesRef.current;
+            const backlog = graphemes.length - visibleCountRef.current;
+            const BACKGROUND_CATCH_UP_THRESHOLD = 2000;
+            const BACKGROUND_TAIL_GRAPHEMES = 200;
+            if (backlog > BACKGROUND_CATCH_UP_THRESHOLD) {
+                commitVisibleCount(Math.max(0, graphemes.length - BACKGROUND_TAIL_GRAPHEMES));
+                lastCommitAtRef.current = 0;
+                pauseUntilRef.current = 0;
+                scheduleFrame();
+            }
+        };
+        document.addEventListener("visibilitychange", onVisibilityChange);
+        return () => document.removeEventListener("visibilitychange", onVisibilityChange);
+    }, [streaming, prefersReducedMotion, commitVisibleCount, scheduleFrame]);
+    useEffect(() => cancelFrame, [cancelFrame]);
+    return visibleText;
+}
+// ─── Markdown readiness hook ──────────────────────────────────────────────────
+export function useMarkdownReady() {
+    const [ready, setReady] = useState(() => markdownModule !== null);
+    useEffect(() => {
+        if (markdownModule !== null)
+            return;
+        return onMarkdownReady(() => setReady(true));
+    }, []);
+    return ready;
+}
+export const MemoizedMarkdownBlock = React.memo(function MemoizedMarkdownBlock({ blockText, }) {
+    const ReactMarkdown = markdownModule?.default;
+    const gfm = remarkGfmFn;
+    if (!ReactMarkdown || !gfm)
+        return null;
+    return (_jsx(ReactMarkdown, { remarkPlugins: [gfm], components: markdownComponents, urlTransform: markdownUrlTransform, children: wrapLegacyChartShorthandLines(blockText) }));
+});
+// ─── StreamingText ────────────────────────────────────────────────────────────
+export function StreamingText({ text, streaming, resetKey, statusType = "complete", animateStreaming = true, onRevealComplete, }) {
+    const mdReady = useMarkdownReady();
+    const shouldAnimate = streaming && animateStreaming;
+    const visibleText = useSmoothStreamingText(text, shouldAnimate, resetKey);
+    const ReactMarkdown = markdownModule?.default;
+    const gfm = remarkGfmFn;
+    // Split whether or not the turn is still streaming. Rendering the finished
+    // message as one whole-document ReactMarkdown instead swapped the element
+    // tree the instant `streaming` went false, so React unmounted every block and
+    // rebuilt it: code blocks re-highlighted, heights collapsed for a frame, and
+    // the scroll jumped — the "flash at the end" report. The split is faithful to
+    // a whole-document parse (see markdown-block-split.ts), so one tree serves
+    // both phases and nothing is rebuilt when streaming stops.
+    const markdownBlocks = useMemo(() => splitMarkdownBlocks(visibleText), [visibleText]);
+    // The tail renders through the same component as completed blocks, so when it
+    // is promoted to a completed block React matches the same type at the same
+    // key and keeps its DOM instead of remounting that paragraph.
+    const renderedBlocks = useMemo(() => markdownBlocks.tail
+        ? [...markdownBlocks.completedBlocks, markdownBlocks.tail]
+        : markdownBlocks.completedBlocks, [markdownBlocks]);
+    useEffect(() => {
+        if (!onRevealComplete || !shouldAnimate || visibleText !== text)
+            return;
+        onRevealComplete();
+    }, [onRevealComplete, shouldAnimate, text, visibleText]);
+    return (_jsx("div", { className: "agent-markdown break-words", "data-status": statusType, "data-streaming": streaming ? "true" : undefined, children: mdReady && ReactMarkdown && gfm ? (renderedBlocks.map((blockText, index) => (_jsx(MemoizedMarkdownBlock, { blockText: blockText }, index)))) : (_jsx("span", { style: { whiteSpace: "pre-wrap" }, children: visibleText })) }));
+}
+/** @deprecated Use StreamingText for new AgentKit surfaces. */
+export const SmoothMarkdownText = StreamingText;
+// ─── MarkdownText ──────────────────────────────────────────────────────────────
+export function shouldAnimateMarkdownText({ textStreaming, isLastAssistantMessage, statusType, externalStreaming, activeMessageStreaming, runActive, }) {
+    // The active-turn identity is deliberately retained after a run ends so a
+    // late final chunk still animates. Without the `runActive` gate that makes
+    // the finished turn's last message permanently "streaming": it never enters
+    // the fast settle drain and keeps re-animating on remount.
+    const identityStreaming = activeMessageStreaming === true && runActive !== false;
+    return (isLastAssistantMessage &&
+        (identityStreaming ||
+            (textStreaming &&
+                (statusType === "running" || externalStreaming === true))));
+}
+//# sourceMappingURL=markdown-renderer.js.map