@ant-design/agentic-ui 2.30.21 → 2.30.23

package/dist/MarkdownRenderer/extractFootnoteDefinitions.d.ts

@@ -0,0 +1,13 @@
+/** 与 `fncProps.onFootnoteDefinitionChange` 数组元素一致 */
+export interface FootnoteDefinitionRow {
+    id: any;
+    placeholder: any;
+    origin_text: any;
+    url: any;
+    origin_url: any;
+}
+/**
+ * 从 Markdown 源码提取 GFM 脚注定义，结构与 Slate 只读 Editor 中
+ * `fncProps.onFootnoteDefinitionChange` 入参对齐。
+ */
+export declare const extractFootnoteDefinitionsFromMarkdown: (content: string) => FootnoteDefinitionRow[];

package/dist/MarkdownRenderer/extractFootnoteDefinitions.js

@@ -0,0 +1,40 @@
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+var mdastFootnoteProcessor = unified().use(remarkParse).use(remarkGfm, {
+    singleTilde: false
+});
+var mdastPlainText = function mdastPlainText1(node) {
+    if (!node) return '';
+    if (node.type === 'text') return node.value || '';
+    if (Array.isArray(node.children)) {
+        return node.children.map(mdastPlainText).join('');
+    }
+    return '';
+};
+/**
+ * 从 Markdown 源码提取 GFM 脚注定义，结构与 Slate 只读 Editor 中
+ * `fncProps.onFootnoteDefinitionChange` 入参对齐。
+ */ export var extractFootnoteDefinitionsFromMarkdown = function extractFootnoteDefinitionsFromMarkdown(content) {
+    if (!(content === null || content === void 0 ? void 0 : content.trim())) return [];
+    try {
+        var tree = mdastFootnoteProcessor.parse(content);
+        var list = [];
+        visit(tree, 'footnoteDefinition', function(node) {
+            var _node_label;
+            list.push({
+                id: node.identifier,
+                placeholder: (_node_label = node.label) !== null && _node_label !== void 0 ? _node_label : node.identifier,
+                origin_text: mdastPlainText({
+                    children: node.children
+                }),
+                url: undefined,
+                origin_url: undefined
+            });
+        });
+        return list;
+    } catch (unused) {
+        return [];
+    }
+};

package/dist/MarkdownRenderer/markdownReactShared.d.ts

@@ -1,18 +1,14 @@
 import React from 'react';
 import type { Processor } from 'unified';
 import { type MarkdownRemarkPlugin, type MarkdownToHtmlConfig } from '../MarkdownEditor/editor/utils/markdownToHtml';
+import type { MarkdownEditorProps } from '../MarkdownEditor/types';
 import type { MarkdownRendererEleProps, RendererBlockProps } from './types';
 declare const createHastProcessor: (extraRemarkPlugins?: MarkdownRemarkPlugin[], config?: MarkdownToHtmlConfig) => Processor;
-/**
- * 构建与 MarkdownEditor Readonly 组件对齐的 hast→React 组件映射。
- *
- * MarkdownEditor 的 Slate 元素使用 data-be 属性和 prefixCls 类名，
- * 这里为原生 HTML 标签添加相同的属性，使共用的 CSS 能正确命中。
- */
+/** hast → React 组件映射，与 MarkdownEditor Readonly 的 data-be / prefixCls 对齐 */
 declare const buildEditorAlignedComponents: (prefixCls: string, userComponents: Record<string, React.ComponentType<RendererBlockProps>>, streaming?: boolean, linkConfig?: {
     openInNewTab?: boolean | undefined;
     onClick?: ((url?: string) => boolean | void) | undefined;
-} | undefined, streamingParagraphAnimation?: boolean, eleRender?: ((props: MarkdownRendererEleProps, defaultDom: React.ReactNode) => React.ReactNode) | undefined) => {
+} | undefined, fncProps?: MarkdownEditorProps['fncProps'], streamingParagraphAnimation?: boolean, eleRender?: ((props: MarkdownRendererEleProps, defaultDom: React.ReactNode) => React.ReactNode) | undefined) => {
     p: (props: any) => React.ReactNode;
     h1: (props: any) => React.ReactNode;
     h2: (props: any) => React.ReactNode;
@@ -51,50 +47,27 @@ declare const buildEditorAlignedComponents: (prefixCls: string, userComponents:
     think: (props: any) => React.FunctionComponentElement<import("../ToolUseBarThink").ToolUseBarThinkProps>;
     answer: (props: any) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
 };
-/**
- * 在 hast 上标记「最后一个 p」，用于流式时仅该段落播放入场（单块长文时避免全页 p 一起闪）
- */
-declare const markLastParagraphStreamingTail: (hast: any) => void;
-/**
- * 将单个 markdown 片段转为 React 元素（内部函数）
- */
-declare const renderMarkdownBlock: (blockContent: string, processor: Processor, components: Record<string, any>, blockOpts?: {
-    markStreamingTailParagraph?: boolean;
-}) => React.ReactNode;
-/**
- * 将 markdown 按块（双换行）拆分，尊重代码围栏边界。
- * 返回的每个块是一个独立的 markdown 片段，可单独解析。
- */
+/** markdown 片段 → React 元素 */
+declare const renderMarkdownBlock: (blockContent: string, processor: Processor, components: Record<string, any>) => React.ReactNode;
+/** 按双换行拆块，尊重代码围栏边界 */
 declare const splitMarkdownBlocks: (content: string) => string[];
 export interface UseMarkdownToReactOptions {
     remarkPlugins?: MarkdownRemarkPlugin[];
     htmlConfig?: MarkdownToHtmlConfig;
     components?: Record<string, React.ComponentType<RendererBlockProps>>;
-    /** MarkdownEditor 的 CSS 前缀，用于生成对齐的 className */
     prefixCls?: string;
-    /** 链接配置：onClick 拦截、openInNewTab 控制 */
     linkConfig?: {
         openInNewTab?: boolean;
         onClick?: (url?: string) => boolean | void;
     };
-    /** 是否处于流式状态，用于最后一个块的打字动画 */
+    fncProps?: MarkdownEditorProps['fncProps'];
     streaming?: boolean;
-    /**
-     * 流式时是否对「生长中的末段」启用段落淡入（AnimationText）。
-     * 默认 false：重解析时频繁触发动画易导致整页闪动；需要时再显式传入 true。
-     */
+    /** 默认开启；传 false 关闭末段段落动画 */
     streamingParagraphAnimation?: boolean;
-    /**
-     * 单调增长的原始流字符串，仅用于判断是否应保留分块缓存。
-     * 与 `content`（常为 useStreaming 输出的可解析串）分离，避免占位符与正文切换时误判为非前缀修订。
-     */
+    /** 原始流字符串，与 useStreaming 输出分离避免缓存误判 */
     contentRevisionSource?: string;
-    /**
-     * 自定义元素渲染拦截函数（markdown 渲染模式）。
-     * 允许在默认渲染结果基础上包装、替换任意元素。
-     * 返回 undefined 时回退到默认渲染。
-     */
+    /** 返回 undefined 回退默认渲染 */
     eleRender?: (props: MarkdownRendererEleProps, defaultDom: React.ReactNode) => React.ReactNode;
 }
-export { buildEditorAlignedComponents, createHastProcessor, markLastParagraphStreamingTail, renderMarkdownBlock, splitMarkdownBlocks, };
+export { buildEditorAlignedComponents, createHastProcessor, renderMarkdownBlock, splitMarkdownBlocks, };
 export type { MarkdownRendererEleProps };

package/dist/MarkdownRenderer/markdownReactShared.js

@@ -140,6 +140,7 @@ import { REMARK_REHYPE_DIRECTIVE_HANDLERS } from "../MarkdownEditor/editor/utils
 import { parseChineseCurrencyToNumber } from "../Plugins/chart/utils";
 import { ToolUseBarThink } from "../ToolUseBarThink";
 import AnimationText from "./AnimationText";
+import { FncRefForMarkdown, extractFootnoteRefFromSupChildren } from "./FncRefForMarkdown";
 import { StreamingAnimationContext } from "./StreamingAnimationContext";
 var INLINE_MATH_WITH_SINGLE_DOLLAR = {
     singleDollarTextMath: true
@@ -391,9 +392,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return undefined;
 };
-/**
- * 提取 React children 的文本内容
- */ var extractChildrenText = function extractChildrenText1(children) {
+var extractChildrenText = function extractChildrenText1(children) {
     var _children_props;
     if (typeof children === 'string') return children;
     if (typeof children === 'number') return String(children);
@@ -403,13 +402,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return '';
 };
-/**
- * <think> 标签渲染组件——使用 ToolUseBarThink 替代原生 DOM。
- * 在 MarkdownEditor 中，<think> 被预处理为 ```think 代码块，
- * 然后由 ThinkBlock 组件（依赖 Slate 上下文）渲染为 ToolUseBarThink。
- * 在 MarkdownRenderer 中，<think> 通过 rehypeRaw 保留为 hast 元素，
- * 这里直接渲染为 ToolUseBarThink，无需 Slate 上下文。
- */ var ThinkBlockRendererComponent = function ThinkBlockRendererComponent(props) {
+/** <think> 标签 → ToolUseBarThink（MarkdownRenderer 无 Slate 上下文，直接渲染） */ var ThinkBlockRendererComponent = function ThinkBlockRendererComponent(props) {
     var children = props.children;
     var content = extractChildrenText(children);
     var isLoading = content.endsWith('...');
@@ -427,21 +420,16 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         status: isLoading ? 'loading' : 'success'
     });
 };
-/**
- * 构建与 MarkdownEditor Readonly 组件对齐的 hast→React 组件映射。
- *
- * MarkdownEditor 的 Slate 元素使用 data-be 属性和 prefixCls 类名，
- * 这里为原生 HTML 标签添加相同的属性，使共用的 CSS 能正确命中。
- */ var buildEditorAlignedComponents = function buildEditorAlignedComponents(prefixCls, userComponents, streaming, linkConfig, streamingParagraphAnimation, eleRender) {
+/** hast → React 组件映射，与 MarkdownEditor Readonly 的 data-be / prefixCls 对齐 */ var buildEditorAlignedComponents = function buildEditorAlignedComponents(prefixCls, userComponents, streaming, linkConfig, fncProps, streamingParagraphAnimation, eleRender) {
     var listCls = "".concat(prefixCls, "-list");
     var tableCls = "".concat(prefixCls, "-content-table");
     var contentCls = prefixCls; // e.g. ant-agentic-md-editor-content
-    /** 仅当 streaming、末块动画上下文允许且显式开启段落动画时包 AnimationText */ var StreamAnimWrap = function StreamAnimWrap(param) {
+    /** 仅当 streaming、末块动画上下文允许且未显式关闭段落动画时包 AnimationText */ var StreamAnimWrap = function StreamAnimWrap(param) {
         var children = param.children;
         var _ref;
         var ctx = useContext(StreamingAnimationContext);
         var animateBlock = (_ref = ctx === null || ctx === void 0 ? void 0 : ctx.animateBlock) !== null && _ref !== void 0 ? _ref : true;
-        var allow = !!streaming && animateBlock && !!streamingParagraphAnimation;
+        var allow = !!streaming && animateBlock && streamingParagraphAnimation !== false;
         if (!allow) return children;
         return jsx(AnimationText, {
             children: children
@@ -887,7 +875,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
             var defaultDom = jsx('mark', _object_spread_props(_object_spread({}, rest), {
                 'data-testid': 'markdown-mark',
                 style: {
-                    background: '#f59e0b',
+                    background: 'var(--ant-color-warning-bg, #f59e0b)',
                     padding: '0.1em 0.2em',
                     borderRadius: 2
                 },
@@ -1119,12 +1107,22 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
                 node: node
             }, rest), defaultDom);
         },
-        // 脚注引用 sup > a（remark-gfm 有定义时生成）
+        // 脚注引用 sup > a（remark-gfm 有定义时生成）— 与 Slate FncLeaf 对齐
         sup: function sup(props) {
             var node = props.node, children = props.children, rest = _object_without_properties(props, [
                 "node",
                 "children"
             ]);
+            var meta = extractFootnoteRefFromSupChildren(children);
+            if (meta) {
+                return jsx(FncRefForMarkdown, {
+                    fncProps: fncProps,
+                    linkConfig: linkConfig,
+                    identifier: meta.identifier,
+                    url: meta.url,
+                    children: children
+                });
+            }
             var defaultDom = jsx('span', _object_spread_props(_object_spread({}, rest), {
                 'data-fnc': 'fnc',
                 'data-testid': 'markdown-footnote-ref',
@@ -1146,15 +1144,14 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
                 "children"
             ]);
             if (rest['data-fnc'] === 'fnc') {
-                return jsx('span', _object_spread_props(_object_spread({}, rest), {
-                    'data-testid': 'markdown-footnote-ref',
-                    className: "".concat(contentCls, "-fnc"),
-                    style: {
-                        fontSize: 12,
-                        cursor: 'pointer'
-                    },
+                var raw = rest['data-fnc-name'];
+                var identifier = raw !== undefined && raw !== null && String(raw).length > 0 ? String(raw) : extractChildrenText(children) || '?';
+                return jsx(FncRefForMarkdown, {
+                    fncProps: fncProps,
+                    linkConfig: linkConfig,
+                    identifier: identifier,
                     children: children
-                }));
+                });
             }
             return jsx('span', _object_spread_props(_object_spread({}, rest), {
                 children: children
@@ -1194,31 +1191,11 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         }
     }, userComponents);
 };
-/**
- * 在 hast 上标记「最后一个 p」，用于流式时仅该段落播放入场（单块长文时避免全页 p 一起闪）
- */ var markLastParagraphStreamingTail = function markLastParagraphStreamingTail(hast) {
-    var paragraphs = [];
-    visit(hast, 'element', function(node) {
-        if (node.tagName === 'p') {
-            paragraphs.push(node);
-        }
-    });
-    var last = paragraphs[paragraphs.length - 1];
-    if (last) {
-        last.properties = last.properties || {};
-        last.properties.dataStreamingTail = true;
-    }
-};
-/**
- * 将单个 markdown 片段转为 React 元素（内部函数）
- */ var renderMarkdownBlock = function renderMarkdownBlock(blockContent, processor, components, blockOpts) {
+/** markdown 片段 → React 元素 */ var renderMarkdownBlock = function renderMarkdownBlock(blockContent, processor, components) {
     if (!blockContent.trim()) return null;
     try {
         var mdast = processor.parse(blockContent);
         var hast = processor.runSync(mdast);
-        if (blockOpts === null || blockOpts === void 0 ? void 0 : blockOpts.markStreamingTailParagraph) {
-            markLastParagraphStreamingTail(hast);
-        }
         return toJsxRuntime(hast, {
             Fragment: Fragment,
             jsx: jsx,
@@ -1230,10 +1207,7 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
         return null;
     }
 };
-/**
- * 将 markdown 按块（双换行）拆分，尊重代码围栏边界。
- * 返回的每个块是一个独立的 markdown 片段，可单独解析。
- */ var splitMarkdownBlocks = function splitMarkdownBlocks(content) {
+/** 按双换行拆块，尊重代码围栏边界 */ var splitMarkdownBlocks = function splitMarkdownBlocks(content) {
     var lines = content.split('\n');
     var blocks = [];
     var current = [];
@@ -1277,4 +1251,4 @@ var extractLanguageFromClassName = function extractLanguageFromClassName(classNa
     }
     return blocks;
 };
-export { buildEditorAlignedComponents, createHastProcessor, markLastParagraphStreamingTail, renderMarkdownBlock, splitMarkdownBlocks };
+export { buildEditorAlignedComponents, createHastProcessor, renderMarkdownBlock, splitMarkdownBlocks };

package/dist/MarkdownRenderer/renderers/ChartRenderer.js

@@ -284,15 +284,23 @@ var extractTextContent = function extractTextContent1(children) {
     useEffect(function() {
         // 延迟一帧渲染图表，确保容器已挂载到 DOM 且有正确的宽度
         // 解决 recharts ResponsiveContainer 在零宽容器中崩溃的问题
+        var cancelled = false;
         var raf = requestAnimationFrame(function() {
+            if (cancelled) {
+                return;
+            }
             setMounted(true);
         });
         return function() {
-            return cancelAnimationFrame(raf);
+            cancelled = true;
+            cancelAnimationFrame(raf);
         };
     }, []);
     useEffect(function() {
         if (!mounted) return;
+        if (typeof window === 'undefined') {
+            return;
+        }
         var updateWidth = function updateWidth() {
             var _containerRef_current;
             var width = ((_containerRef_current = containerRef.current) === null || _containerRef_current === void 0 ? void 0 : _containerRef_current.clientWidth) || 400;

package/dist/MarkdownRenderer/renderers/CodeRenderer.d.ts

@@ -1,7 +1,10 @@
 import React from 'react';
+import type { MarkdownEditorProps } from '../../MarkdownEditor/types';
 import type { RendererBlockProps } from '../types';
 /**
  * 代码块渲染器——复用 MarkdownEditor 的 CodeContainer 和样式体系。
  * 不依赖 Slate 上下文，提供与 CodeRenderer readonly 模式一致的视觉效果。
  */
-export declare const CodeBlockRenderer: React.FC<RendererBlockProps>;
+export declare const CodeBlockRenderer: React.FC<RendererBlockProps & {
+    editorCodeProps?: MarkdownEditorProps['codeProps'];
+}>;

package/dist/MarkdownRenderer/renderers/CodeRenderer.js

@@ -52,6 +52,7 @@ import { I18nContext } from "../../I18n";
 import { CodeContainer } from "../../Plugins/code/components/CodeContainer";
 import { LoadImage } from "../../Plugins/code/components/LoadImage";
 import { langIconMap } from "../../Plugins/code/langIconMap";
+import { debugInfo } from "../../Utils/debugUtils";
 var extractTextContent = function extractTextContent1(children) {
     var _children_props;
     if (typeof children === 'string') return children;
@@ -67,8 +68,10 @@ var extractTextContent = function extractTextContent1(children) {
  * 不依赖 Slate 上下文，提供与 CodeRenderer readonly 模式一致的视觉效果。
  */ export var CodeBlockRenderer = function CodeBlockRenderer(props) {
     var _i18n_locale, _i18n_locale1, _i18n_locale2;
-    var language = props.language, children = props.children;
-    var _useState = _sliced_to_array(useState('github'), 2), theme = _useState[0], setTheme = _useState[1];
+    var language = props.language, children = props.children, editorCodeProps = props.editorCodeProps;
+    var _useState = _sliced_to_array(useState(function() {
+        return (editorCodeProps === null || editorCodeProps === void 0 ? void 0 : editorCodeProps.theme) || 'github';
+    }), 2), theme = _useState[0], setTheme = _useState[1];
     var _useState1 = _sliced_to_array(useState(true), 2), isExpanded = _useState1[0], setIsExpanded = _useState1[1];
     var i18n = useContext(I18nContext);
     var code = useMemo(function() {
@@ -101,7 +104,7 @@ var extractTextContent = function extractTextContent1(children) {
         code
     ]);
     var langIcon = langIconMap.get((language === null || language === void 0 ? void 0 : language.toLowerCase()) || '');
-    return /*#__PURE__*/ React.createElement(CodeContainer, {
+    var defaultDom = /*#__PURE__*/ React.createElement(CodeContainer, {
         element: fakeElement,
         showBorder: false,
         hide: false,
@@ -214,5 +217,26 @@ var extractTextContent = function extractTextContent1(children) {
     }, /*#__PURE__*/ React.createElement("code", {
         className: language ? "language-".concat(language) : undefined
     }, children))));
+    var customRender = editorCodeProps === null || editorCodeProps === void 0 ? void 0 : editorCodeProps.render;
+    if (!customRender) {
+        return defaultDom;
+    }
+    try {
+        var renderElementProps = {
+            attributes: {},
+            children: null,
+            element: fakeElement
+        };
+        var rendered = customRender(renderElementProps, defaultDom, editorCodeProps);
+        if (rendered === undefined) {
+            return defaultDom;
+        }
+        return rendered;
+    } catch (error) {
+        debugInfo('CodeBlockRenderer - codeProps.render 异常，回退默认', {
+            error: (error === null || error === void 0 ? void 0 : error.message) || String(error)
+        });
+        return defaultDom;
+    }
 };
 CodeBlockRenderer.displayName = 'CodeBlockRenderer';

package/dist/MarkdownRenderer/renderers/SchemaRenderer.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { MarkdownEditorProps } from '../../MarkdownEditor/types';
 import type { RendererBlockProps } from '../types';
 /**
  * Schema / Apaasify 渲染器
@@ -12,4 +13,5 @@ import type { RendererBlockProps } from '../types';
  */
 export declare const SchemaBlockRenderer: React.FC<RendererBlockProps & {
     apaasifyRender?: (value: any) => React.ReactNode;
+    editorCodeProps?: MarkdownEditorProps['codeProps'];
 }>;

package/dist/MarkdownRenderer/renderers/SchemaRenderer.js

@@ -1,6 +1,7 @@
 import React, { useMemo } from "react";
 import partialParse from "../../MarkdownEditor/editor/parser/json-parse";
 import { SchemaRenderer } from "../../Schema";
+import { debugInfo } from "../../Utils/debugUtils";
 var extractTextContent = function extractTextContent1(children) {
     var _children_props;
     if (typeof children === 'string') return children;
@@ -34,15 +35,38 @@ var extractTextContent = function extractTextContent1(children) {
  * - ```apassify   → 同 apaasify（兼容旧版）
  * - ```agentar-card → SchemaRenderer
  */ export var SchemaBlockRenderer = function SchemaBlockRenderer(props) {
-    var children = props.children, language = props.language, apaasifyRender = props.apaasifyRender;
+    var children = props.children, language = props.language, apaasifyRender = props.apaasifyRender, editorCodeProps = props.editorCodeProps;
     var code = extractTextContent(children);
     var schemaValue = useMemo(function() {
         return parseSchemaValue(code);
     }, [
         code
     ]);
+    var applyCodeRender = function applyCodeRender(defaultDom, valueForElement) {
+        var customRender = editorCodeProps === null || editorCodeProps === void 0 ? void 0 : editorCodeProps.render;
+        if (!customRender) return defaultDom;
+        var slateLike = {
+            attributes: {},
+            children: null,
+            element: {
+                type: language === 'agentar-card' ? 'card' : 'schema',
+                value: valueForElement,
+                language: language
+            }
+        };
+        try {
+            var rendered = customRender(slateLike, defaultDom, editorCodeProps);
+            if (rendered === undefined) return defaultDom;
+            return rendered;
+        } catch (error) {
+            debugInfo('SchemaBlockRenderer - codeProps.render 异常，回退默认', {
+                error: (error === null || error === void 0 ? void 0 : error.message) || String(error)
+            });
+            return defaultDom;
+        }
+    };
     if (!schemaValue) {
-        return /*#__PURE__*/ React.createElement("pre", {
+        var fallbackDom = /*#__PURE__*/ React.createElement("pre", {
             "data-testid": "schema-fallback",
             style: {
                 background: 'rgb(242, 241, 241)',
@@ -59,11 +83,12 @@ var extractTextContent = function extractTextContent1(children) {
                 wordWrap: 'break-word'
             }
         }, /*#__PURE__*/ React.createElement("code", null, code));
+        return applyCodeRender(fallbackDom, code);
     }
     if (apaasifyRender) {
         var rendered = apaasifyRender(schemaValue);
         if (rendered !== undefined) {
-            return /*#__PURE__*/ React.createElement("div", {
+            var apaasifyDom = /*#__PURE__*/ React.createElement("div", {
                 "data-testid": "schema-container",
                 contentEditable: false,
                 style: {
@@ -82,10 +107,11 @@ var extractTextContent = function extractTextContent1(children) {
                     overflow: 'hidden'
                 }
             }, JSON.stringify(schemaValue, null, 2)));
+            return applyCodeRender(apaasifyDom, schemaValue);
         }
     }
     if (language === 'agentar-card') {
-        return /*#__PURE__*/ React.createElement("div", {
+        var cardDom = /*#__PURE__*/ React.createElement("div", {
             "data-testid": "agentar-card-container",
             style: {
                 padding: '0.5em'
@@ -98,8 +124,9 @@ var extractTextContent = function extractTextContent1(children) {
             debug: false,
             fallbackContent: null
         }));
+        return applyCodeRender(cardDom, schemaValue);
     }
-    return /*#__PURE__*/ React.createElement("div", {
+    var schemaDom = /*#__PURE__*/ React.createElement("div", {
         "data-testid": "schema-renderer",
         style: {
             padding: '0.5em'
@@ -111,5 +138,6 @@ var extractTextContent = function extractTextContent1(children) {
         debug: false,
         fallbackContent: null
     }));
+    return applyCodeRender(schemaDom, schemaValue);
 };
 SchemaBlockRenderer.displayName = 'SchemaBlockRenderer';

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.d.ts

@@ -1,15 +1,13 @@
 import type { Processor } from 'unified';
 import React from 'react';
 export interface MarkdownBlockPieceProps {
-    /** 末块为 tail（生长中）；一旦其后出现新块，同一段内容变为 sealed，保持同一 React key 可避免重组件卸载 */
     variant: 'sealed' | 'tail';
     blockSource: string;
     processor: Processor;
     components: Record<string, any>;
-    /** 仅末块且处于流式模式时为 true，用于节流与末段动画 */
     streaming: boolean;
 }
 /**
- * 统一的块级渲染：封版与末块使用同一组件类型；按 blockSource 缓存解析结果引用，使 tail→sealed 时与旧 Map 缓存一样复用同一棵 React 子树。
+ * 块级渲染单元：sealed 块缓存不动，tail 块节流重解析 + 闪烁光标。
  */
 export declare const MarkdownBlockPiece: React.NamedExoticComponent<MarkdownBlockPieceProps>;

package/dist/MarkdownRenderer/streaming/MarkdownBlockPiece.js

@@ -1,49 +1,37 @@
 import React, { memo, useMemo, useRef } from "react";
 import { renderMarkdownBlock } from "../markdownReactShared";
 import { StreamingAnimationContext } from "../StreamingAnimationContext";
+import { StreamingCursor } from "../StreamingCursor";
 import { shouldReparseLastBlock } from "./lastBlockThrottle";
 /**
- * 统一的块级渲染：封版与末块使用同一组件类型；按 blockSource 缓存解析结果引用，使 tail→sealed 时与旧 Map 缓存一样复用同一棵 React 子树。
+ * 块级渲染单元：sealed 块缓存不动，tail 块节流重解析 + 闪烁光标。
  */ export var MarkdownBlockPiece = /*#__PURE__*/ memo(function MarkdownBlockPiece(param) {
     var variant = param.variant, blockSource = param.blockSource, processor = param.processor, components = param.components, streaming = param.streaming;
     var lastParsedRef = useRef(null);
-    /** 完整 parse 结果缓存：键为 block 源串，供 sealed 与 tail 晋升时复用同一引用 */ var parseBySourceRef = useRef(new Map());
+    var cacheRef = useRef(new Map());
     var node = useMemo(function() {
-        var cached = parseBySourceRef.current.get(blockSource);
-        if (cached && variant === 'sealed') {
-            return cached;
-        }
-        if (variant === 'sealed') {
-            var el = renderMarkdownBlock(blockSource, processor, components, {
-                markStreamingTailParagraph: false
-            });
-            parseBySourceRef.current.set(blockSource, el);
-            return el;
-        }
-        if (!streaming) {
-            var el1 = renderMarkdownBlock(blockSource, processor, components, {
-                markStreamingTailParagraph: false
-            });
-            parseBySourceRef.current.set(blockSource, el1);
-            lastParsedRef.current = {
+        var cached = cacheRef.current.get(blockSource);
+        if (cached && variant === 'sealed') return cached;
+        if (variant === 'sealed' || !streaming) {
+            var el = renderMarkdownBlock(blockSource, processor, components);
+            cacheRef.current.set(blockSource, el);
+            if (variant === 'tail') lastParsedRef.current = {
                 source: blockSource,
-                node: el1
+                node: el
             };
-            return el1;
+            return el;
         }
         var prev = lastParsedRef.current;
         if (prev && !shouldReparseLastBlock(prev.source, blockSource, true)) {
             return prev.node;
         }
-        var el2 = renderMarkdownBlock(blockSource, processor, components, {
-            markStreamingTailParagraph: true
-        });
-        parseBySourceRef.current.set(blockSource, el2);
+        var el1 = renderMarkdownBlock(blockSource, processor, components);
+        cacheRef.current.set(blockSource, el1);
         lastParsedRef.current = {
             source: blockSource,
-            node: el2
+            node: el1
         };
-        return el2;
+        return el1;
     }, [
         variant,
         blockSource,
@@ -56,6 +44,6 @@ import { shouldReparseLastBlock } from "./lastBlockThrottle";
         value: {
             animateBlock: animateBlock
         }
-    }, node);
+    }, node, animateBlock && /*#__PURE__*/ React.createElement(StreamingCursor, null));
 });
 MarkdownBlockPiece.displayName = 'MarkdownBlockPiece';

package/dist/MarkdownRenderer/streaming/useStreamingMarkdownReact.js

@@ -18,12 +18,13 @@ import { shouldResetRevisionProgress } from "./revisionPolicy";
     ]);
     var prefixCls = (options === null || options === void 0 ? void 0 : options.prefixCls) || 'ant-agentic-md-editor';
     var components = useMemo(function() {
-        return buildEditorAlignedComponents(prefixCls, (options === null || options === void 0 ? void 0 : options.components) || {}, options === null || options === void 0 ? void 0 : options.streaming, options === null || options === void 0 ? void 0 : options.linkConfig, options === null || options === void 0 ? void 0 : options.streamingParagraphAnimation, options === null || options === void 0 ? void 0 : options.eleRender);
+        return buildEditorAlignedComponents(prefixCls, (options === null || options === void 0 ? void 0 : options.components) || {}, options === null || options === void 0 ? void 0 : options.streaming, options === null || options === void 0 ? void 0 : options.linkConfig, options === null || options === void 0 ? void 0 : options.fncProps, options === null || options === void 0 ? void 0 : options.streamingParagraphAnimation, options === null || options === void 0 ? void 0 : options.eleRender);
     }, [
         prefixCls,
         options === null || options === void 0 ? void 0 : options.components,
         options === null || options === void 0 ? void 0 : options.streaming,
         options === null || options === void 0 ? void 0 : options.linkConfig,
+        options === null || options === void 0 ? void 0 : options.fncProps,
         options === null || options === void 0 ? void 0 : options.streamingParagraphAnimation,
         options === null || options === void 0 ? void 0 : options.eleRender
     ]);

package/dist/MarkdownRenderer/style.js

@@ -42,6 +42,24 @@ export var useRendererVarStyle = function useRendererVarStyle(prefixCls) {
                 transform: 'translateY(0)',
                 filter: 'blur(0px)'
             }
+        }), _define_property(_obj, '@keyframes markdownStreamingCursorBlink', {
+            '0%, 100%': {
+                opacity: 0.9,
+                boxShadow: '0 0 4px currentColor'
+            },
+            '50%': {
+                opacity: 0,
+                boxShadow: '0 0 0 currentColor'
+            }
+        }), _define_property(_obj, '@keyframes markdownStreamingCursorFadeIn', {
+            from: {
+                opacity: 0,
+                transform: 'scaleY(0.3)'
+            },
+            to: {
+                opacity: 0.9,
+                transform: 'scaleY(1)'
+            }
         }), _obj;
     });
 };