@aparte/core 0.17.0 → 0.17.2

package/dist/{dialog-triggers-Bb-3EkT4.js → dialog-triggers-DwTGKWeU.js}

@@ -1318,6 +1318,7 @@ class AparteConfig {
   // Tool Registry
   _tools = /* @__PURE__ */ new Map();
   _toolRenderers = /* @__PURE__ */ new Map();
+  _toolSummaries = /* @__PURE__ */ new Map();
   /** Tagged blocks the stream parser recognises in the prose — see {@link registerStreamBlock}. */
   _streamBlocks = /* @__PURE__ */ new Map();
   _segmentDefaults = /* @__PURE__ */ new Map();
@@ -1415,11 +1416,12 @@ class AparteConfig {
    * Set an incremental (streaming) Markdown renderer provider. Optional —
    * when set, the chat bubble uses it to render the assistant message
    * token-by-token DURING streaming (incremental parse + DOM append, O(n)),
-   * instead of re-parsing the whole string on every token. When the turn ends,
-   * a registered one-shot `setMarkdownProvider` re-renders the finished message
-   * at full fidelity; with no one-shot provider registered, what the streaming
-   * renderer drew is kept (sanitised), rather than replaced by the built-in
-   * escape-and-line-break fallback.
+   * instead of re-parsing the whole string on every token. With no one-shot
+   * `setMarkdownProvider` registered, it also renders a COMPLETE string
+   * (`renderMarkdown`): a restored reply, a non-streaming provider's answer, a
+   * stored segment — so a reply renders the same however it arrived. A registered
+   * one-shot provider takes over for those, and re-renders the finished message
+   * at full fidelity.
    */
   setStreamingMarkdownProvider(fn) {
     this._streamingMarkdownProvider = fn;
@@ -2033,8 +2035,16 @@ class AparteConfig {
     return val === void 0 ? "" : val;
   }
   /**
-   * Render Markdown to HTML
-   * Fallback: Escapes HTML and converts newlines to <br>
+   * Render a complete Markdown string to HTML: the one-shot provider when one is
+   * registered, else the incremental provider run over the whole string, else core's
+   * default (escape + `<br>`).
+   *
+   * The middle step is what makes the incremental provider enough on its own. Without
+   * it a reply rendered two ways depending on how it arrived: rich while it streamed,
+   * escaped source once it came back complete — a restored conversation, a
+   * non-streaming provider, a stored segment. Same parser, same sanitizer, so the two
+   * cannot disagree. It needs a `document` to write into; without one (a server render)
+   * the default answers, as before.
    */
   renderMarkdown(raw) {
     if (this._markdownProvider) {
@@ -2043,6 +2053,16 @@ class AparteConfig {
       } catch (error) {
         console.warn("[AparteConfig] Markdown provider failed, using fallback:", error);
       }
+    } else if (this._streamingMarkdownProvider && typeof document !== "undefined") {
+      try {
+        const target = document.createElement("div");
+        const renderer = this._streamingMarkdownProvider(target);
+        renderer.write(raw);
+        renderer.end();
+        return this.sanitizeHtml(target.innerHTML);
+      } catch (error) {
+        console.warn("[AparteConfig] Streaming Markdown provider failed on a complete string, using fallback:", error);
+      }
     }
     return this._defaultMarkdownRenderer(raw);
   }
@@ -2174,6 +2194,37 @@ class AparteConfig {
   getToolRenderer(toolName) {
     return this._toolRenderers.get(toolName);
   }
+  /**
+   * Say what a call targets, in the default row, after the tool's name.
+   *
+   * The default row names the tool and keeps its arguments behind a disclosure, so a
+   * reader saw that a file was read, not which one. Replacing the row with
+   * `registerToolRenderer` for that one line meant re-implementing its six states,
+   * the spinner, the disclosure and the relabel contract. This keeps all of them and
+   * adds the line. A tool with its own renderer draws its own row, so its summary is
+   * never read.
+   *
+   * The text is written as text, never parsed as HTML. It is read when the row
+   * renders, on every update to the call (its arguments may still be arriving), and
+   * on every config change — so registering one after a row is on screen shows up on
+   * that row's next update.
+   *
+   * @example
+   * // read_file skills.json
+   * aparteGlobalConfig.registerToolSummary('read_file', (segment) =>
+   *     String(segment.toolCall.input['path'] ?? ''));
+   */
+  registerToolSummary(toolName, summary) {
+    this._toolSummaries.set(toolName, summary);
+  }
+  /** Unregister a per-tool summary. */
+  unregisterToolSummary(toolName) {
+    this._toolSummaries.delete(toolName);
+  }
+  /** Get the summary for a specific tool name. Returns undefined if none registered. */
+  getToolSummary(toolName) {
+    return this._toolSummaries.get(toolName);
+  }
   /**
    * Teach the stream parser a tagged block: `<tag attr="…">…</tag>` in the model's
    * prose becomes the segment `toSegment` builds, streamed delta by delta.
@@ -2382,6 +2433,7 @@ class AparteConfig {
     this._fetchedModels.clear();
     this._tools.clear();
     this._toolRenderers.clear();
+    this._toolSummaries.clear();
     this._streamBlocks.clear();
     this._modelConfig = {};
     this._requireModelSelection = false;
@@ -2467,6 +2519,7 @@ function subscribeConfigChange(el2, handler) {
   window.addEventListener(APARTE_CONFIG_CHANGE, listener);
   return () => window.removeEventListener(APARTE_CONFIG_CHANGE, listener);
 }
+const settledFromParser = /* @__PURE__ */ new WeakMap();
 const ONE_SHOT_PROBE = "<i>a</i>";
 function hasOneShotMarkdownProvider() {
   return contextConfig().renderMarkdown(ONE_SHOT_PROBE) !== escapeHtml(ONE_SHOT_PROBE);
@@ -2474,6 +2527,7 @@ function hasOneShotMarkdownProvider() {
 function writeStreamedMarkdown(host, contentEl, content, streaming) {
   if (streaming) {
     if (host._aparteSmd === void 0) {
+      settledFromParser.delete(contentEl);
       const renderer = contextConfig().createStreamingMarkdownRenderer(contentEl);
       if (renderer) {
         contentEl.textContent = "";
@@ -2502,9 +2556,13 @@ function writeStreamedMarkdown(host, contentEl, content, streaming) {
     host._aparteSmd = void 0;
     if (!hasOneShotMarkdownProvider()) {
       contentEl.innerHTML = contextConfig().sanitizeHtml(contentEl.innerHTML);
+      settledFromParser.set(contentEl, content);
       return;
     }
+  } else if (settledFromParser.get(contentEl) === content && !hasOneShotMarkdownProvider()) {
+    return;
   }
+  settledFromParser.delete(contentEl);
   contentEl.innerHTML = contextConfig().renderMarkdown(content);
 }
 function highlightMarkdownFences(contentEl) {
@@ -2843,12 +2901,31 @@ function highlightParts(element) {
     });
   }
 }
+function toolTarget(segment) {
+  const summary = contextConfig().getToolSummary(segment.toolCall?.name ?? "");
+  if (!summary) return "";
+  try {
+    const text = summary(segment);
+    return typeof text === "string" ? text.trim() : "";
+  } catch {
+    return "";
+  }
+}
+function setTarget(element, segment) {
+  const el2 = element.querySelector(".aparte-tool-target");
+  if (!el2) return;
+  const text = toolTarget(segment);
+  if (el2.textContent !== text) el2.textContent = text;
+  el2.toggleAttribute("hidden", !text);
+}
 function pillMarkup(segment, name, status) {
   const badge = stateBadge(segment);
+  const target = toolTarget(segment);
   return `
                 <span class="aparte-tool-label">
                     <span class="aparte-tool-icon">${contextConfig().getIcon("tool")}</span>
                     <span class="aparte-tool-name">${escapeHtml(name)}</span>
+                    <span class="aparte-tool-target"${target ? "" : " hidden"}>${escapeHtml(target)}</span>
                 </span>
                 <span class="aparte-spinner aparte-tool-spinner" aria-hidden="true"${status === "pending" ? "" : " hidden"}></span>
                 <span class="aparte-tool-state">${badge}</span>`;
@@ -2913,6 +2990,7 @@ const toolCallRenderer = {
     }
     const icon = element.querySelector(".aparte-tool-icon");
     if (icon) icon.innerHTML = cfg.getIcon("tool");
+    setTarget(element, segment);
     const statusEl = element.querySelector(".aparte-tool-state");
     if (statusEl) statusEl.innerHTML = stateBadge(segment);
   },
@@ -2953,6 +3031,7 @@ const toolCallRenderer = {
     const badge = element.querySelector(".aparte-tool-state");
     if (badge) badge.innerHTML = stateBadge(segment);
     element.querySelector(".aparte-tool-spinner")?.toggleAttribute("hidden", status !== "pending");
+    setTarget(element, segment);
     setPart(element, "input", input);
     setPart(element, "output", segment.result ?? "");
     highlightParts(element);
@@ -6908,7 +6987,8 @@ export {
   isTerminalStatus as ag,
   adoptMessageSegments as ah,
   APARTE_DERIVED_SEGMENTS as ai,
-  rootOf as aj,
+  chatBoundaryOf as aj,
+  rootOf as ak,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
@@ -6935,4 +7015,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=dialog-triggers-Bb-3EkT4.js.map
+//# sourceMappingURL=dialog-triggers-DwTGKWeU.js.map