@aparte/core 0.13.0 → 0.14.0

package/dist/{is-awaiting-reply-DrO_oR32.js → is-awaiting-reply-BZ_iJ3s3.js}

@@ -1,4 +1,5 @@
-import { A as APARTE_ICON_GLYPHS } from "./glyphs-QXfbL3n_.js";
+import { A as APARTE_ICON_GLYPHS } from "./glyphs-B3BZ2TIb.js";
+import { deriveArtifactKind, runStreamAgent } from "@aparte/engine";
 function contentToText(content) {
   if (typeof content === "string") return content;
   return content.filter((p) => p.type === "text").map((p) => p.text).join("");
@@ -6,6 +7,7 @@ function contentToText(content) {
 var AparteErrorCode = /* @__PURE__ */ ((AparteErrorCode2) => {
   AparteErrorCode2["CONFIG_NO_PROVIDER"] = "CONFIG_NO_PROVIDER";
   AparteErrorCode2["CONFIG_MISSING_KEY"] = "CONFIG_MISSING_KEY";
+  AparteErrorCode2["CONFIG_INVALID_KEY"] = "CONFIG_INVALID_KEY";
   AparteErrorCode2["CONFIG_INVALID_MODEL"] = "CONFIG_INVALID_MODEL";
   AparteErrorCode2["USAGE_RATE_LIMIT"] = "USAGE_RATE_LIMIT";
   AparteErrorCode2["USAGE_CONTEXT_EXCEEDED"] = "USAGE_CONTEXT_EXCEEDED";
@@ -29,11 +31,50 @@ class AparteError extends Error {
     this.httpStatus = httpStatus;
     this.name = "AparteError";
   }
+  /**
+   * The code an HTTP status stands for — the table the enum's own comments promise.
+   * `undefined` for a status the enum does not name (a 404 can be a wrong model or a
+   * wrong URL; the message says which, a code would guess).
+   */
+  static codeForStatus(status) {
+    switch (status) {
+      case 400:
+        return "USAGE_BAD_REQUEST";
+      case 401:
+      case 403:
+        return "CONFIG_INVALID_KEY";
+      case 408:
+        return "NET_TIMEOUT";
+      case 429:
+        return "USAGE_RATE_LIMIT";
+      case 503:
+        return "PROVIDER_UNAVAILABLE";
+      default:
+        return status !== void 0 && status >= 500 ? "PROVIDER_ERROR" : void 0;
+    }
+  }
   static from(error, defaultCode = "UNKNOWN_ERROR", defaultStatus) {
     if (error instanceof AparteError) return error;
     const message = error instanceof Error ? error.message : String(error);
     const status = error?.status || error?.statusCode || defaultStatus;
-    return new AparteError(message, defaultCode, void 0, error, status);
+    const code = defaultCode !== "UNKNOWN_ERROR" ? defaultCode : AparteError.codeForStatus(status) ?? AparteError.codeForFailure(error) ?? defaultCode;
+    return new AparteError(message, code, void 0, error, status);
+  }
+  /**
+   * What a thrown, statusless error says about itself. `fetch` rejects a network
+   * failure with a TypeError whose message names the fetch ("Failed to fetch",
+   * "NetworkError when attempting to fetch resource.", "Load failed") — any other
+   * TypeError is a bug, not the network, and stays unclassified. `AbortSignal.timeout()`
+   * rejects with a TimeoutError.
+   */
+  static codeForFailure(error) {
+    if (!(error instanceof Error)) return void 0;
+    if (error.name === "TimeoutError") return "NET_TIMEOUT";
+    if (error instanceof TypeError && /fetch|network|load failed/i.test(error.message)) {
+      const offline = typeof navigator !== "undefined" && navigator.onLine === false;
+      return offline ? "NET_OFFLINE" : "NET_ERROR";
+    }
+    return void 0;
   }
 }
 const APARTE_DEFAULT_ICON_FALLBACKS = APARTE_ICON_GLYPHS;
@@ -57,6 +98,10 @@ const APARTE_DEFAULT_LOCALE = {
   approvalInstructionPlaceholder: "Or tell it what to do instead…",
   approvalAsk: "Run {tool}?",
   approvalWaiting: "waiting for you",
+  scrollToBottom: "Scroll to bottom",
+  suggestionsLabel: "Suggested prompts",
+  contextLabel: "Context window",
+  compactionSummaryTitle: "Conversation summary",
   toolRunning: "Running",
   toolCompleted: "Done",
   toolRejected: "Rejected",
@@ -101,14 +146,6 @@ const APARTE_DEFAULT_LOCALE = {
   unarchiveConversation: "Unarchive conversation",
   direction: "ltr"
 };
-const APARTE_DEFAULT_SKELETON_FALLBACKS = {
-  message: '<div class="aparte-skeleton-fallback">Loading...</div>',
-  code: '<div class="aparte-skeleton-fallback aparte-skeleton-fallback--code">Loading code...</div>',
-  thinking: '<div class="aparte-skeleton-fallback aparte-skeleton-fallback--tight">Thinking...</div>',
-  input: '<div class="aparte-skeleton-fallback aparte-skeleton-fallback--snug">...</div>',
-  list: '<div class="aparte-skeleton-fallback">Loading items...</div>',
-  text: '<div class="aparte-skeleton-fallback aparte-skeleton-fallback--tight">...</div>'
-};
 function isFormatAdapter(p) {
   return typeof p.buildRequest === "function" && typeof p.parseStream === "function" && typeof p.defaultEndpoint === "string" && (typeof p.authHeaders === "function" || typeof p.authQuery === "function");
 }
@@ -123,6 +160,11 @@ async function vendorErrorMessage(response, label = "HTTP") {
   const msg = typeof raw === "object" ? raw?.message : raw;
   return typeof msg === "string" && msg ? msg : `${label} ${response.status}`;
 }
+async function vendorError(response, label = "HTTP") {
+  const message = await vendorErrorMessage(response, label);
+  const code = AparteError.codeForStatus(response.status) ?? AparteErrorCode.UNKNOWN_ERROR;
+  return new AparteError(message, code, void 0, void 0, response.status);
+}
 async function parseNonStreamText(provider, response, providerId) {
   const json = await response.json();
   if (typeof provider.parseText !== "function") {
@@ -163,7 +205,7 @@ class AparteDirectTransport {
       signal: ctx.signal
     });
     if (!response.ok) {
-      throw new Error(await vendorErrorMessage(response));
+      throw await vendorError(response);
     }
     if (request.stream === false) {
       return parseNonStreamText(provider, response, ctx.providerId);
@@ -241,7 +283,7 @@ class AparteStreamParser {
       if ("content" in this._state.activeSegment) {
         const seg = this._state.activeSegment;
         let content = seg.content + this._state.buffer;
-        if (seg.type === "text") content = stripTrailingFence(content);
+        if (seg.type === "text" || seg.type === "code") content = stripTrailingFence(content);
         seg.content = content;
       }
       finalSegments.push(this._closed(this._state.activeSegment));
@@ -362,16 +404,6 @@ class AparteStreamParser {
   _parseCodeMode(buffer) {
     const closeIndex = buffer.indexOf("\n```");
     if (closeIndex === -1) {
-      if (buffer.endsWith("```")) {
-        const codeContent2 = buffer.slice(0, -3);
-        if (this._state.activeSegment && "content" in this._state.activeSegment) {
-          this._state.activeSegment.content += codeContent2;
-        }
-        const segment2 = this._closed(this._state.activeSegment);
-        this._state.mode = "text";
-        this._state.activeSegment = null;
-        return { segment: segment2, remaining: "" };
-      }
       if (buffer.length > 4) {
         const safeContent = buffer.slice(0, -4);
         if (this._state.activeSegment && "content" in this._state.activeSegment) {
@@ -594,28 +626,6 @@ function parseMarkdownToSegments(content, options) {
   const finalSegments = parser.finalize();
   return [...result.segments, ...finalSegments];
 }
-function deriveArtifactKind(mimeType, fallback = "unknown") {
-  const m = (mimeType || "").toLowerCase().trim();
-  const ant = m.match(/^application\/vnd\.ant\.([a-z0-9-]+)/);
-  if (ant) return ant[1];
-  if (m === "text/html" || m === "application/xhtml+xml") return "html";
-  if (m === "application/javascript" || m === "text/javascript") return "js";
-  if (m === "text/css") return "css";
-  if (m === "image/svg+xml") return "svg";
-  if (m === "application/json") return "json";
-  if (m === "text/markdown") return "markdown";
-  if (m === "text/csv") return "csv";
-  if (m === "text/plain") return "text";
-  if (m.includes("react")) return "react";
-  if (m.includes("html")) return "html";
-  if (m.includes("javascript")) return "js";
-  if (m.includes("css")) return "css";
-  if (m.includes("svg")) return "svg";
-  if (m.includes("json")) return "json";
-  if (m.includes("csv")) return "csv";
-  if (m.includes("markdown")) return "markdown";
-  return fallback;
-}
 function parseAparteEventStream(stream) {
   const decoder = new TextDecoder();
   let buffer = "";
@@ -668,7 +678,7 @@ class AparteBackendTransport {
       signal: ctx.signal
     });
     if (!response.ok) {
-      throw new Error(await vendorErrorMessage(response, "Backend HTTP"));
+      throw await vendorError(response, "Backend HTTP");
     }
     if (request.stream === false) {
       const json = await response.json();
@@ -1056,7 +1066,7 @@ const escapeAttr = escapeHtml;
 function isChatBoundary(el2) {
   if (!el2) return false;
   const tag = el2.tagName?.toLowerCase();
-  return tag === "aparte-chat" || tag === "aparte-chat-component" || el2.hasAttribute?.("data-aparte-chat") === true;
+  return tag === "aparte-chat" || el2.hasAttribute?.("data-aparte-chat") === true;
 }
 function chatBoundaryOf(el2) {
   let node = el2 ?? null;
@@ -1090,7 +1100,6 @@ class AparteConfig {
   _sanitizer = defaultSanitizer;
   _systemPromptTemplate;
   _systemPromptVarsProvider;
-  _skeletonProvider;
   _statusRenderer;
   _errorRenderer;
   _attachmentRenderer;
@@ -1367,13 +1376,6 @@ class AparteConfig {
     const resolved = this._systemPromptTemplate.replace(/\{\{([^}]+)\}\}/g, (_, key) => vars[key.trim()] ?? "");
     return resolved.trim() || null;
   }
-  /**
-   * Set a custom Skeleton generator for loading states
-   * @param provider Object implementing AparteSkeletonProvider interface
-   */
-  setSkeletonProvider(provider) {
-    this._skeletonProvider = provider;
-  }
   /**
    * Set a custom Icon provider (e.g., Lucide, FontAwesome, Material)
    * @param provider Object implementing AparteIconProvider interface
@@ -1831,16 +1833,6 @@ class AparteConfig {
     }
     return this._defaultHighlightRenderer(code);
   }
-  /**
-   * Get HTML for a skeleton loader
-   * Fallback: Simple CSS-animated box
-   */
-  getSkeleton(type) {
-    if (this._skeletonProvider) {
-      return this._skeletonProvider.getSkeleton(type);
-    }
-    return this._defaultSkeletonRenderer(type);
-  }
   // ─────────────────────────────────────────────────────────────────────────
   // Tool Registry
   // ─────────────────────────────────────────────────────────────────────────
@@ -2087,7 +2079,6 @@ class AparteConfig {
     this._highlightProvider = void 0;
     this._systemPromptTemplate = void 0;
     this._systemPromptVarsProvider = void 0;
-    this._skeletonProvider = void 0;
     this._statusRenderer = void 0;
     this._errorRenderer = void 0;
     this._attachmentRenderer = void 0;
@@ -2128,16 +2119,6 @@ class AparteConfig {
   _defaultHighlightRenderer(code) {
     return `<pre><code>${escapeHtml(code)}</code></pre>`;
   }
-  /**
-   * ONE owner. This used to hold a second, hand-written copy of
-   * `APARTE_DEFAULT_SKELETON_FALLBACKS`, and the two had already drifted — `message`
-   * said "Loading message…" here and "Loading…" there, `text` the reverse. A duplicate
-   * that disagrees with its original is worse than either: whichever one you read, you
-   * cannot tell which one ships.
-   */
-  _defaultSkeletonRenderer(type) {
-    return APARTE_DEFAULT_SKELETON_FALLBACKS[type] ?? APARTE_DEFAULT_SKELETON_FALLBACKS.text;
-  }
 }
 const GLOBAL_CONFIG_KEY = Symbol.for("aparte.globalConfig.1");
 function getGlobalConfig() {
@@ -2475,7 +2456,7 @@ function stateBadge(segment) {
   if (status === "pending") return word("toolRunning");
   if (status === "resolved") return `${cfg.getIcon("check")}${word("toolCompleted")}`;
   if (status === "rejected") return `${cfg.getIcon("close")}${word("toolRejected")}`;
-  if (status === "aborted") return `${cfg.getIcon("close")}${word("toolStopped")}`;
+  if (status === "aborted") return `${cfg.getIcon("stop")}${word("toolStopped")}`;
   return "";
 }
 function setPart(element, part, text) {
@@ -2539,6 +2520,7 @@ const toolCallRenderer = {
     const toolCallId = segment.toolCall?.id ?? "";
     const customRenderer = contextConfig().getToolRenderer(segment.toolCall?.name);
     if (customRenderer) {
+      injectToolRendererStyles(segment.toolCall?.name ?? "", customRenderer);
       const out = customRenderer.render(segment);
       if (out) return out;
     }
@@ -2635,44 +2617,6 @@ const toolCallRenderer = {
   // has no other way onto the page.
   getStyles: () => ""
 };
-const waitingLabel = () => contextConfig().t("generating");
-const pipelineWaitingRenderer = {
-  type: "pipeline-waiting",
-  render: (segment) => {
-    return `
-        <div class="aparte-segment aparte-segment-pipeline-waiting" data-segment-id="${escapeHtml(segment.id)}" aria-label="${escapeAttr(waitingLabel())}" role="status">
-            <span class="aparte-dot aparte-pw-dot"></span>
-            <span class="aparte-dot aparte-pw-dot"></span>
-            <span class="aparte-dot aparte-pw-dot"></span>
-        </div>`;
-  },
-  update: () => {
-  },
-  /**
-   * Three dots and an accessible name. The dots are CSS; the name is the whole
-   * content as far as a screen reader is concerned, and it was hardcoded English in
-   * every locale — the one string in this library where being untranslated is
-   * invisible to everyone who can see the screen.
-   */
-  relabel: (element) => {
-    element.setAttribute("aria-label", waitingLabel());
-  },
-  setup: (el2) => {
-    const parent = el2.parentElement;
-    if (!parent) return;
-    const observer = new MutationObserver(() => {
-      if (el2.nextElementSibling) {
-        observer.disconnect();
-        el2.remove();
-      }
-    });
-    observer.observe(parent, { childList: true });
-  },
-  // CSS lives in styles/segment/ — see that folder for why a
-  // built-in's rules belong there. `getStyles` stays for a CONSUMER's renderer, which
-  // has no other way onto the page.
-  getStyles: () => ""
-};
 function stripCodeFences(content) {
   let s = content;
   if (s.startsWith("```") || s.startsWith("~~~")) {
@@ -3440,6 +3384,17 @@ function injectRendererStyles(config = contextConfig()) {
   }
   if (added) styleElement.textContent = Array.from(injectedRendererStyles).join("\n");
 }
+function injectToolRendererStyles(toolName, renderer) {
+  if (typeof document === "undefined") return;
+  const css = renderer.getStyles?.();
+  if (!css) return;
+  const id = `aparte-tool-renderer-${toolName}`;
+  if (document.getElementById(id)) return;
+  const el2 = document.createElement("style");
+  el2.id = id;
+  el2.textContent = css;
+  document.head.appendChild(el2);
+}
 function registerDefaultRenderers(config = contextConfig()) {
   const reg = registryFor(config);
   reg.defaultsInstalled = true;
@@ -3455,8 +3410,7 @@ const DEFAULT_RENDERERS = [
   codeRenderer,
   errorRenderer,
   toolCallRenderer,
-  artifactRenderer,
-  pipelineWaitingRenderer
+  artifactRenderer
 ];
 const OPEN_TOOL_STATUSES = /* @__PURE__ */ new Set(["pending", "awaiting-approval"]);
 const ACTIVITY_KEYS = ["content", "output", "result"];
@@ -4416,7 +4370,7 @@ class AparteChatHost {
     this.binding.setMessages(next);
     this.binding.onMessagesChange?.(next);
   }
-  /** Remove a transient segment (e.g. pipeline-waiting indicator). */
+  /** Remove a transient segment (a status row the host added itself). */
   removeSegment(segmentId) {
     this._flushStreamState();
     this._lastBubble()?.removeSegment?.(segmentId);
@@ -4595,7 +4549,7 @@ class AparteChatHost {
         this._bufferToken(messageId, res.value);
       }
       this._flushStreamState();
-      if (!ac.signal.aborted) this._vp()?.completeMessage?.(messageId);
+      this._vp()?.completeMessage?.(messageId);
       this._setStreamingId(null);
     } catch (err) {
       this._flushStreamState();
@@ -4852,176 +4806,6 @@ function dispatchArtifactLifecycle(target, messageId, segment, progress, isFinal
     }));
   }
 }
-const INLINE_MAX_LINES = 15;
-const XML_OPEN_TAG = "<artifact";
-function partialXmlOpenTagLength(text) {
-  const max = Math.min(text.length, XML_OPEN_TAG.length - 1);
-  for (let k = max; k > 0; k--) {
-    if (text.endsWith(XML_OPEN_TAG.slice(0, k))) return k;
-  }
-  return 0;
-}
-function feedXmlArtifactDelta(delta, xml, ctx) {
-  const { targetElement, messageId, textParser, streamingSegmentIds, artifactProgress, artifactXmlHint } = ctx;
-  let remaining = delta;
-  const emitChatText = (text, syncActive = true) => {
-    if (!text) return;
-    const r = textParser.parse(text);
-    for (const seg of r.segments) {
-      if (!streamingSegmentIds.has(seg.id)) {
-        targetElement.addSegment?.(seg);
-        streamingSegmentIds.add(seg.id);
-      } else if ("content" in seg) {
-        targetElement.updateSegment?.(seg.id, segmentContentUpdate(seg));
-      }
-    }
-    const active = textParser.getState().activeSegment;
-    if (syncActive && active) {
-      if (!streamingSegmentIds.has(active.id)) {
-        targetElement.addSegment?.(active);
-        streamingSegmentIds.add(active.id);
-      } else {
-        targetElement.updateSegment?.(active.id, segmentContentUpdate(active));
-      }
-    } else if (!r.segments.length && !active) ;
-  };
-  while (remaining.length > 0) {
-    if (xml.state === "normal") {
-      const tagStart = remaining.indexOf(XML_OPEN_TAG);
-      if (tagStart === -1) {
-        const held = partialXmlOpenTagLength(remaining);
-        if (held > 0) {
-          emitChatText(remaining.slice(0, remaining.length - held), false);
-          xml.scanBuf = remaining.slice(remaining.length - held);
-          xml.state = "scanning";
-        } else {
-          emitChatText(remaining);
-        }
-        remaining = "";
-      } else {
-        emitChatText(remaining.slice(0, tagStart), false);
-        xml.scanBuf = "";
-        remaining = remaining.slice(tagStart);
-        xml.state = "scanning";
-      }
-    } else if (xml.state === "scanning") {
-      xml.scanBuf += remaining;
-      remaining = "";
-      const cmp = Math.min(xml.scanBuf.length, XML_OPEN_TAG.length);
-      if (xml.scanBuf.slice(0, cmp) !== XML_OPEN_TAG.slice(0, cmp)) {
-        emitChatText(xml.scanBuf);
-        xml.scanBuf = "";
-        xml.state = "normal";
-        continue;
-      }
-      const gtIdx = xml.scanBuf.indexOf(">");
-      if (gtIdx !== -1) {
-        const tag = xml.scanBuf.slice(0, gtIdx + 1);
-        const mimeMatch = /mimeType=['"]([^'"]+)['"]/.exec(tag);
-        const titleMatch = /title=['"]([^'"]+)['"]/.exec(tag);
-        xml.mime = mimeMatch?.[1] ?? artifactXmlHint.mimeType;
-        xml.title = titleMatch?.[1] ?? artifactXmlHint.kind;
-        xml.kind = deriveArtifactKind(xml.mime, artifactXmlHint.kind);
-        xml.segId = `artifact-xml-${uuid()}`;
-        xml.content = "";
-        const openSeg = {
-          id: xml.segId,
-          type: "artifact",
-          mimeType: xml.mime,
-          artifactType: xml.kind,
-          title: xml.title,
-          content: ""
-        };
-        targetElement.addSegment?.(openSeg);
-        streamingSegmentIds.add(xml.segId);
-        dispatchArtifactLifecycle(targetElement, messageId, openSeg, artifactProgress, false);
-        xml.state = "in-artifact";
-        remaining = xml.scanBuf.slice(gtIdx + 1);
-        xml.scanBuf = "";
-      }
-    } else {
-      const CLOSE = "</artifact>";
-      const combined = xml.closeBuf + remaining;
-      const closeIdx = combined.indexOf(CLOSE);
-      if (closeIdx !== -1) {
-        xml.content += combined.slice(0, closeIdx);
-        const lineCount = xml.content.split("\n").length;
-        const isInline = lineCount < INLINE_MAX_LINES;
-        const finalSeg = {
-          id: xml.segId,
-          mimeType: xml.mime,
-          artifactType: xml.kind,
-          title: xml.title,
-          content: xml.content
-        };
-        targetElement.updateSegment?.(xml.segId, { content: xml.content, inline: isInline });
-        dispatchArtifactLifecycle(targetElement, messageId, finalSeg, artifactProgress, true);
-        xml.state = "normal";
-        xml.closeBuf = "";
-        remaining = combined.slice(closeIdx + CLOSE.length);
-      } else {
-        const safeLen = Math.max(0, combined.length - CLOSE.length + 1);
-        const safe = combined.slice(0, safeLen);
-        xml.content += safe;
-        xml.closeBuf = combined.slice(safeLen);
-        remaining = "";
-        if (xml.segId) {
-          targetElement.updateSegment?.(xml.segId, { content: xml.content });
-          dispatchArtifactLifecycle(targetElement, messageId, {
-            id: xml.segId,
-            mimeType: xml.mime,
-            artifactType: xml.kind,
-            title: xml.title,
-            content: xml.content
-          }, artifactProgress, false);
-        }
-      }
-    }
-  }
-}
-function finalizeXmlArtifact(xml, ctx) {
-  const { targetElement, messageId, artifactProgress, artifactXmlHint } = ctx;
-  if (xml.state === "scanning") {
-    const held = xml.scanBuf;
-    xml.scanBuf = "";
-    xml.state = "normal";
-    if (held) {
-      const r = ctx.textParser.parse(held);
-      for (const seg of r.segments) {
-        if (!ctx.streamingSegmentIds.has(seg.id)) {
-          targetElement.addSegment?.(seg);
-          ctx.streamingSegmentIds.add(seg.id);
-        } else if ("content" in seg) {
-          targetElement.updateSegment?.(seg.id, segmentContentUpdate(seg));
-        }
-      }
-      const active = ctx.textParser.getState().activeSegment;
-      if (active) {
-        if (!ctx.streamingSegmentIds.has(active.id)) {
-          targetElement.addSegment?.(active);
-          ctx.streamingSegmentIds.add(active.id);
-        } else {
-          targetElement.updateSegment?.(active.id, segmentContentUpdate(active));
-        }
-      }
-    }
-    return;
-  }
-  if (artifactXmlHint && xml.state === "in-artifact" && xml.segId) {
-    xml.content += xml.closeBuf;
-    const lineCount = xml.content.split("\n").length;
-    const isInline = lineCount < INLINE_MAX_LINES;
-    targetElement.updateSegment?.(xml.segId, { content: xml.content, inline: isInline });
-    dispatchArtifactLifecycle(targetElement, messageId, {
-      id: xml.segId,
-      mimeType: xml.mime,
-      artifactType: xml.kind,
-      title: xml.title,
-      content: xml.content
-    }, artifactProgress, true);
-    console.warn("[AparteClient] XML artifact finalized without closing tag — content may be partial.");
-  }
-}
 function createStreamAdapter(opts) {
   const { target, config, messageId, artifactHint } = opts;
   let parser = new AparteStreamParser();
@@ -5031,7 +4815,6 @@ function createStreamAdapter(opts) {
   let thinkingCollapsed = false;
   let artifactProgress = /* @__PURE__ */ new Map();
   let artifactPromoted = false;
-  let artifactMeta = /* @__PURE__ */ new Map();
   return (e) => {
     switch (e.type) {
       case "run-start":
@@ -5045,7 +4828,6 @@ function createStreamAdapter(opts) {
         thinkingCollapsed = false;
         artifactProgress = /* @__PURE__ */ new Map();
         artifactPromoted = false;
-        artifactMeta = /* @__PURE__ */ new Map();
         break;
       case "thinking-delta": {
         thinkingContent += e.delta;
@@ -5070,18 +4852,6 @@ function createStreamAdapter(opts) {
           target.updateSegment?.(thinkingId, { collapsed: true, isStreaming: false });
           thinkingCollapsed = true;
         }
-        if (e.reduced) {
-          const r = parser.parse(e.delta);
-          for (const segment of r.segments) {
-            if (!streaming.has(segment.id)) {
-              target.addSegment?.(segment);
-              streaming.add(segment.id);
-            } else if ("content" in segment) {
-              target.updateSegment?.(segment.id, segmentContentUpdate(segment));
-            }
-          }
-          break;
-        }
         const result = parser.parse(e.delta);
         for (let segment of result.segments) {
           if (artifactHint && !artifactPromoted && segment.type === "code") {
@@ -5154,33 +4924,6 @@ function createStreamAdapter(opts) {
         }
         break;
       }
-      case "artifact-open": {
-        const seg = {
-          id: e.id,
-          type: "artifact",
-          mimeType: e.mimeType,
-          artifactType: e.kind,
-          title: e.title,
-          content: ""
-        };
-        target.addSegment?.(seg);
-        streaming.add(e.id);
-        artifactMeta.set(e.id, { mimeType: e.mimeType, artifactType: e.kind, title: e.title });
-        dispatchArtifactLifecycle(target, messageId, seg, artifactProgress, false);
-        break;
-      }
-      case "artifact-chunk": {
-        const meta = artifactMeta.get(e.id);
-        target.updateSegment?.(e.id, { content: e.content });
-        dispatchArtifactLifecycle(target, messageId, { id: e.id, content: e.content, ...meta }, artifactProgress, false);
-        break;
-      }
-      case "artifact-close": {
-        const meta = artifactMeta.get(e.id);
-        target.updateSegment?.(e.id, { content: e.content, inline: e.inline });
-        dispatchArtifactLifecycle(target, messageId, { id: e.id, content: e.content, ...meta }, artifactProgress, true);
-        break;
-      }
       case "artifact-ready": {
         const seg = {
           id: e.id,
@@ -5203,18 +4946,7 @@ function createStreamAdapter(opts) {
         };
         const renderer = config.getToolRenderer(e.name);
         if (renderer) {
-          if (renderer.getStyles) {
-            const styles = renderer.getStyles();
-            if (styles) {
-              const styleId = `aparte-tool-renderer-${e.name}`;
-              if (!document.getElementById(styleId)) {
-                const styleEl = document.createElement("style");
-                styleEl.id = styleId;
-                styleEl.textContent = styles;
-                document.head.appendChild(styleEl);
-              }
-            }
-          }
+          injectToolRendererStyles(e.name, renderer);
           const html = renderer.render(toolSeg);
           if (html) target.addSegment?.(toolSeg);
         } else {
@@ -5250,9 +4982,6 @@ function createStreamAdapter(opts) {
           target.updateSegment?.(`tool-${e.toolCallId}`, { status: "aborted" });
         }
         break;
-      case "phase-advance":
-        target.addSegment?.({ id: `pw-${uuid()}`, type: "pipeline-waiting" });
-        break;
       case "run-aborted":
         dispatchLifecycleEvent(target, "aparte-message-aborted", { messageId });
         break;
@@ -5790,20 +5519,6 @@ function buildApprovalPanel(message, options, onChange) {
 function requestUserInput(request) {
   return resolveConfig(request.target ?? null).requestUserInput(request);
 }
-const DEFAULT_TOOL_HANDLER_TIMEOUT_MS = 5 * 60 * 1e3;
-function withToolTimeout(work, controller, timeoutMs) {
-  let timer;
-  const timedOut = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => {
-      controller.abort();
-      reject(Object.assign(new Error(`tool handler exceeded ${timeoutMs}ms`), { name: "AbortError" }));
-    }, timeoutMs);
-  });
-  return {
-    raced: Promise.race([work(controller.signal), timedOut]),
-    done: () => clearTimeout(timer)
-  };
-}
 class AparteClient {
   _boundHandler = null;
   _boundAbortHandler = null;
@@ -5838,6 +5553,8 @@ class AparteClient {
   }
   /** Aborts the in-flight vendor/transport fetch when the user stops a stream. */
   _streamController = null;
+  /** Aborts an in-flight `compact()` summarisation — its own slot, see `compact`. */
+  _compactController = null;
   options;
   /** Config read by this client — an instance config, or the global default. */
   _config;
@@ -5963,6 +5680,7 @@ class AparteClient {
   abort() {
     this._isAborted = true;
     this._streamController?.abort();
+    this._compactController?.abort();
     for (const controller of this._activeToolControllers) {
       controller.abort();
     }
@@ -6070,6 +5788,7 @@ class AparteClient {
     }
     if (this._isAborted) {
       dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId });
+      this._updateMessage(targetElement, messageId, { status: "completed" });
       return;
     }
     dispatchLifecycleEvent(targetElement, "aparte-message-start", { messageId, role: "assistant" });
@@ -6149,7 +5868,7 @@ class AparteClient {
         stream: false
       };
       const compactController = new AbortController();
-      this._streamController = compactController;
+      this._compactController = compactController;
       const response = await this._config.getTransport().chat(
         provider,
         summarizeRequest,
@@ -6180,7 +5899,11 @@ class AparteClient {
       target.appendMessage?.({
         id: uuid(),
         role: "assistant",
-        content: `📝 **Conversation summary**
+        // Through the locale, like every string the user reads — this was a
+        // hardcoded English title (with an emoji) in an otherwise localised
+        // transcript. The engine compactor's `summaryLabel` is a separate,
+        // per-call knob; this is the UI's own title.
+        content: `**${this._config.t("compactionSummaryTitle")}**
 
 ${summary}`,
         timestamp: Date.now(),
@@ -6634,67 +6357,6 @@ ${content}
     );
     return parts.filter((p) => p !== null);
   }
-  /**
-   * Turn-1 forced tool call. When `toolChoice = { name, input }`
-   * (orchestrator-driven), execute the handler directly instead of consulting
-   * the LLM, render the tool segment, inject the result as `tool_result`, and
-   * strip `toolChoice` for the follow-up turn. Returns the (possibly-updated)
-   * request and whether the loop should skip to the next turn (handler missing
-   * or aborted). Extracted from `_streamLoop`. `messages` is mutated in place.
-   */
-  async _maybeRunSyntheticTool(baseRequest, turns, messages, targetElement) {
-    const toolChoice = baseRequest.toolChoice;
-    if (!(turns === 1 && toolChoice && typeof toolChoice === "object" && toolChoice.input !== void 0)) {
-      return { baseRequest, skip: false };
-    }
-    const syntheticId = uuid();
-    const syntheticCall = { id: syntheticId, name: toolChoice.name, input: toolChoice.input };
-    const toolSeg = {
-      id: `tool-${syntheticId}`,
-      type: "tool_call",
-      toolCall: syntheticCall,
-      status: "pending"
-    };
-    const toolRenderer = this._config.getToolRenderer(toolChoice.name);
-    if (toolRenderer) {
-      const html = toolRenderer.render(toolSeg);
-      if (html) targetElement.addSegment?.(toolSeg);
-    } else {
-      targetElement.addSegment?.(toolSeg);
-    }
-    const handler = this._config.getToolHandler(toolChoice.name);
-    if (!handler) {
-      console.warn(`[AparteClient] No handler for synthetic tool "${toolChoice.name}"`);
-      targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-      return { baseRequest, skip: true };
-    }
-    const controller = new AbortController();
-    this._activeToolControllers.add(controller);
-    const { raced, done: clearToolTimeout } = withToolTimeout(
-      (sig) => handler(syntheticCall, sig, {
-        target: targetElement,
-        config: this._config
-      }),
-      controller,
-      this.options.toolTimeoutMs ?? DEFAULT_TOOL_HANDLER_TIMEOUT_MS
-    );
-    try {
-      const result = await raced;
-      targetElement.updateSegment?.(toolSeg.id, { status: "resolved", result: result.content });
-      messages.push({ role: "tool_call", content: "", toolCalls: [syntheticCall] });
-      messages.push({ role: "tool_result", content: result.content, toolCallId: syntheticId });
-      return { baseRequest: { ...baseRequest, toolChoice: "none", tools: void 0 }, skip: false };
-    } catch (err) {
-      if (err?.name === "AbortError") {
-        targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-        return { baseRequest, skip: true };
-      }
-      throw err;
-    } finally {
-      clearToolTimeout();
-      this._activeToolControllers.delete(controller);
-    }
-  }
   /**
    * What the loop does after one tool call. THREE outcomes, because a boolean
    * conflated two questions that a refusal answers differently.
@@ -6707,536 +6369,41 @@ ${content}
    * - `'halt'`     — the run is over: an abort, a turn limit, a missing handler.
    */
   /**
-   * Handle one `tool_use` stream event from {@link _streamLoop}: the built-in
-   * `create_artifact`, per-tool renderer selection, the human-in-the-loop
-   * approval gate, and running the registered handler (timeout / abort).
-   * Mutates the shared `messages` / `toolCallsThisTurn` history in place and
-   * returns what the loop should do next.
-   */
-  async _handleToolUseEvent(event, ctx) {
-    const { targetElement, messageId, messages, toolCallsThisTurn, precedingText, artifactProgress, turns, globalMaxTurns } = ctx;
-    let flow = "continue";
-    toolCallsThisTurn.push({ id: event.id, name: event.name, input: event.input });
-    if (event.name === "create_artifact") {
-      const input = event.input;
-      const mimeType = input.mimeType ?? "text/plain";
-      const kind = deriveArtifactKind(mimeType, "text");
-      const artifactSeg = {
-        id: `artifact-${event.id}`,
-        type: "artifact",
-        mimeType,
-        artifactType: kind,
-        title: input.title ?? kind,
-        content: input.content ?? ""
-      };
-      targetElement.addSegment?.(artifactSeg);
-      dispatchArtifactLifecycle(targetElement, messageId, artifactSeg, artifactProgress, true);
-      messages.push({
-        role: "tool_call",
-        content: "",
-        toolCalls: [{ id: event.id, name: event.name, input: event.input }]
-      });
-      messages.push({
-        role: "tool_result",
-        content: "Artifact created successfully.",
-        toolCallId: event.id
-      });
-      return { flow: "continue" };
-    }
-    const toolSeg = {
-      id: `tool-${event.id}`,
-      type: "tool_call",
-      toolCall: { id: event.id, name: event.name, input: event.input },
-      status: "pending"
-    };
-    const toolRenderer = this._config.getToolRenderer(event.name);
-    if (toolRenderer) {
-      if (toolRenderer.getStyles) {
-        const styles = toolRenderer.getStyles();
-        if (styles) {
-          const styleId = `aparte-tool-renderer-${event.name}`;
-          if (!document.getElementById(styleId)) {
-            const el2 = document.createElement("style");
-            el2.id = styleId;
-            el2.textContent = styles;
-            document.head.appendChild(el2);
-          }
-        }
-      }
-      const html = toolRenderer.render(toolSeg);
-      if (html) {
-        targetElement.addSegment?.(toolSeg);
-      }
-    } else {
-      targetElement.addSegment?.(toolSeg);
-    }
-    const toolDef = this._config.getTools().find((t) => t.name === event.name);
-    const effectiveMaxTurns = toolDef?.maxTurns ?? globalMaxTurns;
-    if (turns >= effectiveMaxTurns) {
-      console.warn(`[AparteClient] Tool "${event.name}" maxTurns (${effectiveMaxTurns}) reached.`);
-      targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-      return { flow: "halt" };
-    }
-    const handler = this._config.getToolHandler(event.name);
-    if (handler) {
-      let effectiveInput = event.input;
-      if (toolDef?.needsApproval) {
-        const approvalController = new AbortController();
-        this._activeToolControllers.add(approvalController);
-        targetElement.updateSegment?.(toolSeg.id, { status: "awaiting-approval" });
-        dispatchLifecycleEvent(targetElement, "aparte-tool-approval-request", {
-          toolCallId: event.id,
-          toolName: event.name,
-          input: event.input
-        });
-        let decision;
-        const resolveApproval = this.options.approvalResolver ?? ((call, sig) => this._askForApproval(call, sig, targetElement));
-        try {
-          decision = await resolveApproval(event, approvalController.signal);
-        } catch (err) {
-          if (err?.name === "AbortError") {
-            targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-            return { flow: "halt" };
-          }
-          throw err;
-        } finally {
-          this._activeToolControllers.delete(approvalController);
-        }
-        if (approvalController.signal.aborted) {
-          targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-          return { flow: "halt" };
-        }
-        if (!decision.approved) {
-          const rejection = decision.instruction ? `The user rejected this tool call and said: ${decision.instruction}` : "Tool execution was rejected by the user.";
-          targetElement.updateSegment?.(toolSeg.id, { status: "rejected", result: rejection });
-          const existingToolCallMsg = messages.find(
-            (m) => m.role === "tool_call" && m.toolCalls?.some((tc) => tc.id === event.id)
-          );
-          if (!existingToolCallMsg) {
-            messages.push({
-              role: "tool_call",
-              content: "",
-              toolCalls: toolCallsThisTurn,
-              precedingText: precedingText.trim() || void 0
-            });
-          }
-          messages.push({ role: "tool_result", content: rejection, toolCallId: event.id });
-          return { flow: "respond" };
-        }
-        if (decision.payload && typeof decision.payload === "object" && !Array.isArray(decision.payload)) {
-          effectiveInput = { ...event.input, ...decision.payload };
-        }
-        targetElement.updateSegment?.(toolSeg.id, { status: "pending" });
-      }
-      const controller = new AbortController();
-      this._activeToolControllers.add(controller);
-      const { raced, done: clearToolTimeout } = withToolTimeout(
-        (sig) => handler(
-          { id: event.id, name: event.name, input: effectiveInput },
-          sig,
-          { target: targetElement, config: this._config }
-        ),
-        controller,
-        this.options.toolTimeoutMs ?? DEFAULT_TOOL_HANDLER_TIMEOUT_MS
-      );
-      try {
-        const result = await raced;
-        targetElement.updateSegment?.(toolSeg.id, { status: "resolved", result: result.content });
-        const existingToolCallMsg = messages.find(
-          (m) => m.role === "tool_call" && m.toolCalls?.some((tc) => tc.id === event.id)
-        );
-        if (!existingToolCallMsg) {
-          messages.push({
-            role: "tool_call",
-            content: "",
-            toolCalls: toolCallsThisTurn,
-            precedingText: precedingText.trim() || void 0
-          });
-        }
-        messages.push({
-          role: "tool_result",
-          content: result.content,
-          toolCallId: event.id
-        });
-      } catch (err) {
-        if (err?.name === "AbortError") {
-          targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-          flow = "halt";
-        } else {
-          throw err;
-        }
-      } finally {
-        clearToolTimeout();
-        this._activeToolControllers.delete(controller);
-      }
-    } else {
-      console.warn(`[AparteClient] No handler registered for tool "${event.name}"`);
-      targetElement.updateSegment?.(toolSeg.id, { status: "aborted" });
-      flow = "halt";
-    }
-    return { flow };
-  }
-  /**
-   * Stream loop: runs one provider.chat() call and repeats if a tool was called.
-   * Maintains a running messages array to inject tool_call / tool_result turns.
+   * The turn's agent loop — the engine's `runStreamAgent` rendered through the core
+   * adapter, or the runner a host injected — after the fetch-level abort bookkeeping.
    */
   async _streamLoop(targetElement, messageId, provider, baseRequest, authConfig) {
     this._streamController?.abort();
     const streamController = new AbortController();
     this._streamController = streamController;
-    if (this.options.streamRunner) {
-      return this._runViaStreamRunner(this.options.streamRunner, targetElement, messageId, provider, baseRequest, authConfig, streamController);
-    }
-    const messages = [...baseRequest.messages];
-    let continueLoop = true;
-    let turns = 0;
-    const globalMaxTurns = this.options.maxTurns ?? 10;
-    let lastUsage;
-    const pipeline = baseRequest._meta?.pipeline;
-    let pipelineIndex = 0;
-    this._updateMessage(targetElement, messageId, { status: "streaming" });
-    for (const seg of baseRequest._meta?.prefixSegments ?? []) {
-      targetElement.addSegment?.(seg);
-    }
-    while (continueLoop) {
-      let endTurnEarly = false;
-      if (this._isAborted) {
-        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId });
-        break;
-      }
-      turns++;
-      if (turns > globalMaxTurns) {
-        console.warn(`[AparteClient] maxTurns (${globalMaxTurns}) exceeded — stopping loop.`);
-        targetElement.addSegment?.({
-          id: `max-turns-${uuid()}`,
-          type: "error",
-          content: `Stopped after ${globalMaxTurns} tool calls to prevent an infinite loop.`,
-          details: "MAX_TURNS_EXCEEDED"
-        });
-        break;
-      }
-      const synthetic = await this._maybeRunSyntheticTool(baseRequest, turns, messages, targetElement);
-      baseRequest = synthetic.baseRequest;
-      if (synthetic.skip) {
-        continueLoop = false;
-        continue;
-      }
-      let phaseMessages = messages;
-      let phaseMeta = baseRequest._meta;
-      if (pipeline && pipelineIndex < pipeline.length) {
-        const phase = pipeline[pipelineIndex];
-        phaseMessages = [{ role: "system", content: phase.system }, ...messages];
-        if (phase.mode === "artifact") {
-          phaseMeta = { ...phaseMeta, artifactRaw: { mimeType: phase.mimeType, kind: phase.kind } };
-        } else {
-          const { artifactRaw: _dropped, pipeline: _p, ...restMeta } = phaseMeta ?? {};
-          phaseMeta = restMeta;
-        }
-      }
-      const request = { ...baseRequest, messages: phaseMessages, _meta: phaseMeta };
-      const response = await this._config.getTransport().chat(provider, request, authConfig, { providerId: provider.id, signal: streamController.signal });
-      if (typeof response === "string") {
-        const wholeParser = new AparteStreamParser();
-        const parsed = [
-          ...wholeParser.parse(response).segments,
-          ...wholeParser.finalize()
-        ];
-        const stringHint = baseRequest._meta?.artifactHint;
-        if (stringHint) {
-          const codeIdx = parsed.findIndex((s) => s.type === "code");
-          if (codeIdx !== -1) {
-            const codeSeg = parsed[codeIdx];
-            parsed[codeIdx] = {
-              id: codeSeg.id,
-              type: "artifact",
-              mimeType: stringHint.mimeType,
-              artifactType: stringHint.kind,
-              title: codeSeg.filename ?? stringHint.kind,
-              content: codeSeg.content
-            };
-          }
-        }
-        if (parsed.length > 0) {
-          for (const segment of parsed) targetElement.addSegment?.(segment);
-          this._updateMessage(targetElement, messageId, { status: "completed" });
-        } else {
-          this._updateMessage(targetElement, messageId, { content: response, status: "completed" });
-        }
-        return void 0;
-      }
-      const reader = response.getReader();
-      const textParser = new AparteStreamParser();
-      const streamingSegmentIds = /* @__PURE__ */ new Set();
-      const artifactProgress = /* @__PURE__ */ new Map();
-      let thinkingSegmentId = null;
-      let thinkingContent = "";
-      let thinkingCollapsed = false;
-      const artifactHint = baseRequest._meta?.artifactHint;
-      let artifactPromoted = false;
-      const artifactRawHint = request._meta?.artifactRaw;
-      let rawSegId = null;
-      let rawContent = "";
-      if (artifactRawHint) {
-        rawSegId = `artifact-raw-${uuid()}`;
-        const rawSeg = {
-          id: rawSegId,
-          type: "artifact",
-          mimeType: artifactRawHint.mimeType,
-          artifactType: artifactRawHint.kind,
-          title: artifactRawHint.kind,
-          content: ""
-        };
-        targetElement.addSegment?.(rawSeg);
-        streamingSegmentIds.add(rawSegId);
-        dispatchArtifactLifecycle(targetElement, messageId, rawSeg, artifactProgress, false);
-      }
-      const artifactXmlHint = baseRequest._meta?.artifactXml;
-      const xmlCtx = {
-        state: "normal",
-        scanBuf: "",
-        closeBuf: "",
-        segId: null,
-        content: "",
-        mime: "",
-        kind: "",
-        title: ""
-      };
-      let precedingText = "";
-      const toolCallsThisTurn = [];
-      const bailOnAbort = () => {
-        if (!this._isAborted) return false;
-        try {
-          void reader.cancel();
-        } catch {
-        }
-        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId });
-        continueLoop = false;
-        return true;
-      };
-      let streamDrained = false;
-      try {
-        while (true) {
-          if (bailOnAbort()) break;
-          const { done, value: event } = await reader.read();
-          if (bailOnAbort()) break;
-          if (done) {
-            streamDrained = true;
-            break;
-          }
-          switch (event.type) {
-            case "thinking": {
-              thinkingContent += event.delta;
-              if (!thinkingSegmentId) {
-                const seg = {
-                  id: `think-${uuid()}`,
-                  type: "thinking",
-                  content: thinkingContent,
-                  collapsed: true,
-                  label: "Thinking"
-                };
-                thinkingSegmentId = seg.id;
-                streamingSegmentIds.add(seg.id);
-                targetElement.addSegment?.(seg);
-              } else {
-                targetElement.updateSegment?.(thinkingSegmentId, { content: thinkingContent });
-              }
-              break;
-            }
-            case "text": {
-              if (thinkingSegmentId && !thinkingCollapsed) {
-                targetElement.updateSegment?.(thinkingSegmentId, { collapsed: true, isStreaming: false });
-                thinkingCollapsed = true;
-              }
-              precedingText += event.delta;
-              if (artifactRawHint && rawSegId) {
-                rawContent += event.delta;
-                targetElement.updateSegment?.(rawSegId, { content: rawContent });
-                dispatchArtifactLifecycle(targetElement, messageId, {
-                  id: rawSegId,
-                  type: "artifact",
-                  mimeType: artifactRawHint.mimeType,
-                  artifactType: artifactRawHint.kind,
-                  title: artifactRawHint.kind,
-                  content: rawContent
-                }, artifactProgress, false);
-                break;
-              }
-              if (artifactXmlHint) {
-                feedXmlArtifactDelta(event.delta, xmlCtx, {
-                  targetElement,
-                  messageId,
-                  textParser,
-                  streamingSegmentIds,
-                  artifactProgress,
-                  artifactXmlHint
-                });
-                break;
-              }
-              const result = textParser.parse(event.delta);
-              for (let segment of result.segments) {
-                if (artifactHint && !artifactPromoted && segment.type === "code") {
-                  const codeSeg = segment;
-                  const promoted = {
-                    id: codeSeg.id,
-                    type: "artifact",
-                    mimeType: artifactHint.mimeType,
-                    artifactType: artifactHint.kind,
-                    title: codeSeg.filename ?? artifactHint.kind,
-                    content: codeSeg.content
-                  };
-                  segment = promoted;
-                  artifactPromoted = true;
-                }
-                if (!streamingSegmentIds.has(segment.id)) {
-                  targetElement.addSegment?.(segment);
-                  streamingSegmentIds.add(segment.id);
-                } else if ("content" in segment) {
-                  targetElement.updateSegment?.(segment.id, segmentContentUpdate(segment));
-                }
-                if (segment.type === "artifact") {
-                  dispatchArtifactLifecycle(targetElement, messageId, segment, artifactProgress, true);
-                }
-              }
-              const active = textParser.getState().activeSegment;
-              if (active) {
-                if (!streamingSegmentIds.has(active.id)) {
-                  targetElement.addSegment?.(active);
-                  streamingSegmentIds.add(active.id);
-                  if (active.type === "artifact") {
-                    dispatchArtifactLifecycle(targetElement, messageId, active, artifactProgress, false);
-                  }
-                } else {
-                  targetElement.updateSegment?.(active.id, segmentContentUpdate(active));
-                  if (active.type === "artifact") {
-                    dispatchArtifactLifecycle(targetElement, messageId, active, artifactProgress, false);
-                  }
-                }
-              } else if (result.segments.length === 0) {
-              }
-              break;
-            }
-            case "tool_use": {
-              const toolResult = await this._handleToolUseEvent(
-                { id: event.id, name: event.name, input: event.input },
-                { targetElement, messageId, messages, toolCallsThisTurn, precedingText, artifactProgress, turns, globalMaxTurns }
-              );
-              if (toolResult.flow !== "continue") endTurnEarly = true;
-              if (toolResult.flow === "halt") continueLoop = false;
-              break;
-            }
-            case "error":
-              throw new Error(event.message);
-            case "done":
-              if (event.usage) lastUsage = event.usage;
-              break;
-            default: {
-              const exhaustive = event;
-              void exhaustive;
-              this._warnUnknownStreamEvent(event);
-              break;
-            }
-          }
-          if (endTurnEarly) break;
-        }
-        finalizeXmlArtifact(xmlCtx, { targetElement, messageId, artifactProgress, artifactXmlHint, textParser, streamingSegmentIds });
-        const finals = textParser.finalize();
-        if (artifactRawHint && rawSegId) {
-          const lineCount = rawContent.split("\n").length;
-          const isInline = lineCount < 15;
-          targetElement.updateSegment?.(rawSegId, { content: rawContent, inline: isInline });
-          dispatchArtifactLifecycle(targetElement, messageId, {
-            id: rawSegId,
-            type: "artifact",
-            mimeType: artifactRawHint.mimeType,
-            artifactType: artifactRawHint.kind,
-            title: artifactRawHint.kind,
-            content: rawContent,
-            inline: isInline
-          }, artifactProgress, true);
-        }
-        if (artifactHint && !artifactPromoted) {
-          const codeIdx = finals.findIndex((s) => s.type === "code");
-          if (codeIdx !== -1) {
-            const codeSeg = finals[codeIdx];
-            const promoted = {
-              id: codeSeg.id,
-              type: "artifact",
-              mimeType: artifactHint.mimeType,
-              artifactType: artifactHint.kind,
-              title: codeSeg.filename ?? artifactHint.kind,
-              content: codeSeg.content
-            };
-            finals[codeIdx] = promoted;
-            artifactPromoted = true;
-            if (streamingSegmentIds.has(promoted.id)) {
-              targetElement.updateSegment?.(promoted.id, promoted);
-            }
-          }
-        }
-        for (const s of finals) {
-          if (!streamingSegmentIds.has(s.id)) {
-            targetElement.addSegment?.(s);
-          } else if ("content" in s) {
-            targetElement.updateSegment?.(s.id, segmentContentUpdate(s));
-          }
-          if (s.type === "artifact") {
-            dispatchArtifactLifecycle(targetElement, messageId, s, artifactProgress, true);
-          }
-        }
-        if (toolCallsThisTurn.length === 0) {
-          if (pipeline && pipelineIndex < pipeline.length - 1) {
-            if (precedingText.trim()) {
-              messages.push({ role: "assistant", content: precedingText.trim() });
-            }
-            pipelineIndex++;
-            const pwId = `pw-${uuid()}`;
-            targetElement.addSegment?.({ id: pwId, type: "pipeline-waiting" });
-          } else {
-            continueLoop = false;
-          }
-        }
-      } finally {
-        if (!streamDrained) {
-          try {
-            await reader.cancel();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-    this._updateMessage(targetElement, messageId, { status: "completed" });
-    if (lastUsage) {
-      try {
-        targetElement.setUsage?.(messageId, lastUsage);
-      } catch {
-      }
-    }
-    return lastUsage;
+    const runner = this.options.streamRunner ?? runStreamAgent;
+    return this._runViaStreamRunner(runner, targetElement, messageId, provider, baseRequest, authConfig, streamController);
   }
   /**
-   * Delegate `_streamLoop`'s agentic loop to an injected {@link AparteStreamRunner},
-   * rendering its DOM-free events through {@link createStreamAdapter}.
-   * Builds the runner's dependencies from this client's config / provider /
-   * transport; the adapter reproduces the inline loop's `targetElement.*` calls
-   * (validated by the engine `stream-parity` suite). Leading writes (status
-   * streaming, prefix segments) mirror the inline path; the runner's `run-start`
-   * re-asserts `streaming` idempotently.
+   * Run the loop through a {@link AparteStreamRunner} — the engine's by default —
+   * rendering its DOM-free events through {@link createStreamAdapter}. Builds the
+   * runner's dependencies from this client's config / provider / transport. The
+   * leading writes (status streaming, prefix segments) happen here; the runner's
+   * `run-start` re-asserts `streaming` idempotently. The call sequence this
+   * produces is pinned by the `stream-parity` suite's snapshots, recorded while
+   * the inline loop it replaced still ran beside it.
    */
   async _runViaStreamRunner(streamRunner, targetElement, messageId, provider, baseRequest, authConfig, streamController) {
     const signal = streamController.signal;
-    this._updateMessage(targetElement, messageId, { status: "streaming" });
-    const prefixSegments = baseRequest._meta?.["prefixSegments"];
-    if (prefixSegments?.length) {
-      for (const seg of prefixSegments) targetElement.addSegment?.(seg);
-    }
     const artifactHint = baseRequest._meta?.artifactHint;
-    const emitter = createStreamAdapter({
+    const adapter = createStreamAdapter({
       target: targetElement,
       config: this._config,
       messageId,
       artifactHint
     });
+    const prefixSegments = baseRequest._meta?.["prefixSegments"];
+    const emitter = (event) => {
+      adapter(event);
+      if (event.type === "run-start" && prefixSegments?.length) {
+        for (const seg of prefixSegments) targetElement.addSegment?.(seg);
+      }
+    };
     const transportCall = async (request) => {
       const response = await this._config.getTransport().chat(provider, request, authConfig, { providerId: provider.id, signal });
       return typeof response === "string" ? response : readableToAsyncIterable(response, signal);
@@ -7267,7 +6434,7 @@ ${content}
       // inline path, so setting it was silently ignored here. Exactly the
       // asymmetry the option was added to remove.
       toolTimeoutMs: this.options.toolTimeoutMs,
-      // Match the inline loop's id conventions: prefixed artifact ids, but a
+      // The id conventions the loop always had: prefixed artifact ids, but a
       // BARE uuid for the synthetic tool (the adapter renders `tool-<id>`).
       idGen: (prefix) => prefix === "synthetic-tool" ? uuid() : `${prefix}-${uuid()}`
     });
@@ -7308,16 +6475,6 @@ ${content}
     }
     dispatchLifecycleEvent(target, "aparte-message-error", { messageId, error });
   }
-  /** Warn once per client for an unrecognised stream event, then carry on. */
-  _warnedUnknownEvents = /* @__PURE__ */ new Set();
-  _warnUnknownStreamEvent(event) {
-    const type = String(event?.type ?? "undefined");
-    if (this._warnedUnknownEvents.has(type)) return;
-    this._warnedUnknownEvents.add(type);
-    console.warn(
-      `[AparteClient] Ignoring unrecognised stream event "${type}". The reply is unaffected; this usually means the provider or its SDK emits a part this version of aparté does not map yet.`
-    );
-  }
 }
 function findHead(node) {
   if (node.next) return findHead(node.next);
@@ -7489,6 +6646,12 @@ class AparteMessageRepository {
   import(exported) {
     this.clear();
     for (const { message, parentId } of exported.messages) {
+      if (parentId !== null && !this._nodes.has(parentId)) {
+        console.warn(
+          `[AparteMessageRepository] import: message "${message.id}" names a parent "${parentId}" the snapshot does not hold before it — skipped.`
+        );
+        continue;
+      }
       this.addOrUpdateMessage(parentId, message);
     }
     if (exported.headId) {
@@ -7498,15 +6661,25 @@ class AparteMessageRepository {
   /**
    * Export the full tree for serialisation or debugging.
    * Compatible with the assistant-ui ExportedMessageRepository format.
+   *
+   * Walked from the root through each node's `children`, so a parent is always
+   * written before its children. It used to iterate `_nodes` in insertion order and
+   * call that topological — which holds until `_relink` re-parents an EXISTING node
+   * under one inserted after it (`addOrUpdateMessage` with a known id and a newer
+   * parent). The snapshot then listed the child first, and `import()` threw "parent
+   * not found" on the very tree this method had just produced.
    */
   export() {
     const messages = [];
-    this._nodes.forEach((node) => {
-      messages.push({
-        message: node.current,
-        parentId: node.prev?.current.id ?? null
-      });
-    });
+    const walk = (children, parentId) => {
+      for (const id of children) {
+        const node = this._nodes.get(id);
+        if (!node) continue;
+        messages.push({ message: node.current, parentId });
+        walk(node.children, id);
+      }
+    };
+    walk(this._root.children, null);
     return { headId: this.headId, messages };
   }
   // ─── Private helpers ────────────────────────────────────────────────────
@@ -7612,75 +6785,73 @@ function isAwaitingReply(message) {
   return message.status === void 0 && message.role === "assistant" && !message.content?.trim() && !message.segments?.length;
 }
 export {
-  resolveConfig as $,
+  runWithConfig as $,
   APARTE_CONFIG_CHANGE as A,
-  contentToText as B,
-  contextConfig as C,
-  createAparteChatHandler as D,
-  createStreamAdapter as E,
-  cssEscape as F,
-  declineDefaultRenderers as G,
-  defaultSanitizer as H,
-  deriveArtifactKind as I,
-  detachConfig as J,
-  escapeAttr as K,
-  escapeHtml as L,
-  filesToAttachments as M,
-  getAllRenderers as N,
-  getSegmentRenderer as O,
-  installDefaultRenderersOnce as P,
-  isAwaitingReply as Q,
-  isFormatAdapter as R,
-  isSafeUrl as S,
-  isSegmentSettled as T,
-  parseAparteEventStream as U,
-  parseMarkdownToSegments as V,
-  populateBubbleFromMessage as W,
-  readableToAsyncIterable as X,
-  registerDefaultRenderers as Y,
-  registerSegmentRenderer as Z,
-  requestUserInput as _,
+  contextConfig as B,
+  createAparteChatHandler as C,
+  createStreamAdapter as D,
+  cssEscape as E,
+  declineDefaultRenderers as F,
+  defaultSanitizer as G,
+  detachConfig as H,
+  escapeAttr as I,
+  escapeHtml as J,
+  filesToAttachments as K,
+  getAllRenderers as L,
+  getSegmentRenderer as M,
+  installDefaultRenderersOnce as N,
+  isAwaitingReply as O,
+  isFormatAdapter as P,
+  isSafeUrl as Q,
+  isSegmentSettled as R,
+  parseAparteEventStream as S,
+  parseMarkdownToSegments as T,
+  populateBubbleFromMessage as U,
+  readableToAsyncIterable as V,
+  registerDefaultRenderers as W,
+  registerSegmentRenderer as X,
+  requestUserInput as Y,
+  resolveConfig as Z,
+  revokeAttachmentUrls as _,
   APARTE_CONVERSATION_SCHEMA_VERSION as a,
-  revokeAttachmentUrls as a0,
-  runWithConfig as a1,
-  segmentDuration as a2,
-  segmentTiming as a3,
-  subscribeConfigChange as a4,
-  unregisterSegmentRenderer as a5,
-  uuid as a6,
-  mergeSegmentUpdate as a7,
-  writeStreamedMarkdown as a8,
-  stampSegmentActivity as a9,
-  stampSegmentOnInsert as aa,
-  stampSegmentOnUpdate as ab,
-  renumberSegments as ac,
-  openSegmentIds as ad,
-  isTerminalStatus as ae,
-  adoptMessageSegments as af,
+  segmentDuration as a0,
+  segmentTiming as a1,
+  subscribeConfigChange as a2,
+  unregisterSegmentRenderer as a3,
+  uuid as a4,
+  mergeSegmentUpdate as a5,
+  writeStreamedMarkdown as a6,
+  stampSegmentActivity as a7,
+  stampSegmentOnInsert as a8,
+  stampSegmentOnUpdate as a9,
+  renumberSegments as aa,
+  openSegmentIds as ab,
+  isTerminalStatus as ac,
+  adoptMessageSegments as ad,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
   APARTE_DEFAULT_LOCALE as e,
-  APARTE_DEFAULT_SKELETON_FALLBACKS as f,
-  APARTE_DEFAULT_UI_EVENTS as g,
-  APARTE_HOST_ATTR as h,
-  AparteBackendTransport as i,
-  AparteChatHost as j,
-  AparteClient as k,
-  AparteConfig as l,
-  AparteConversationController as m,
-  AparteConversationManager as n,
-  AparteDirectTransport as o,
-  AparteElicitationAbortError as p,
-  AparteError as q,
-  AparteErrorCode as r,
-  AparteMessageRepository as s,
-  AparteStreamParser as t,
-  aparteGlobalConfig as u,
-  applyElementProps as v,
-  attachConfig as w,
-  buildApprovalPanel as x,
-  buildElicitationPanel as y,
-  collectRendererStyles as z
+  APARTE_DEFAULT_UI_EVENTS as f,
+  APARTE_HOST_ATTR as g,
+  AparteBackendTransport as h,
+  AparteChatHost as i,
+  AparteClient as j,
+  AparteConfig as k,
+  AparteConversationController as l,
+  AparteConversationManager as m,
+  AparteDirectTransport as n,
+  AparteElicitationAbortError as o,
+  AparteError as p,
+  AparteErrorCode as q,
+  AparteMessageRepository as r,
+  AparteStreamParser as s,
+  aparteGlobalConfig as t,
+  applyElementProps as u,
+  attachConfig as v,
+  buildApprovalPanel as w,
+  buildElicitationPanel as x,
+  collectRendererStyles as y,
+  contentToText as z
 };
-//# sourceMappingURL=is-awaiting-reply-DrO_oR32.js.map
+//# sourceMappingURL=is-awaiting-reply-BZ_iJ3s3.js.map