@aparte/core 0.25.0 → 0.26.0

package/dist/{defer-hydration-BwMqeRHq.js → defer-hydration-8vI8xNNx.js}

@@ -58,9 +58,14 @@ class AparteError extends Error {
     if (error instanceof AparteError) return error;
     const message = error instanceof Error ? error.message : String(error);
     const status = error?.status || error?.statusCode || defaultStatus;
-    const code = defaultCode !== "UNKNOWN_ERROR" ? defaultCode : AparteError.codeForStatus(status) ?? AparteError.codeForFailure(error) ?? defaultCode;
+    const carried = error?.code;
+    const code = defaultCode !== "UNKNOWN_ERROR" ? defaultCode : AparteError.carriedCode(carried) ?? AparteError.codeForStatus(status) ?? AparteError.codeForFailure(error) ?? defaultCode;
     return new AparteError(message, code, void 0, error, status);
   }
+  /** The value as an {@link AparteErrorCode}, when it is one — a Node `ECONNRESET` or a vendor's own string is not. */
+  static carriedCode(value) {
+    return typeof value === "string" && Object.values(AparteErrorCode).includes(value) ? value : void 0;
+  }
   /**
    * What a thrown, statusless error says about itself. `fetch` rejects a network
    * failure with a TypeError whose message names the fetch ("Failed to fetch",
@@ -104,7 +109,26 @@ const APARTE_DEFAULT_LOCALE = {
   scrollToBottom: "Scroll to bottom",
   suggestionsLabel: "Suggested prompts",
   contextLabel: "Context window",
+  contextSystem: "System prompt",
+  contextTools: "Tools",
+  contextSummary: "Summary",
+  contextMessages: "Messages",
+  contextOther: "Other",
+  contextFree: "Free",
+  contextTotal: "Total",
+  contextReclaim: "Compacting now would free ~{n} tokens",
+  contextCompactNow: "Compact now",
   compactionSummaryTitle: "Conversation summary",
+  checkpointCount: "{n} messages summarised for the model",
+  checkpointCountOne: "1 message summarised for the model",
+  checkpointLegacy: "Earlier messages were summarised",
+  checkpointGroup: "Context summary",
+  checkpointShow: "Show summary",
+  checkpointHide: "Hide summary",
+  checkpointRestore: "Restore",
+  checkpointRestoreConfirm: "Send the original messages to the model again?",
+  checkpointPending: "Summarising the context…",
+  checkpointFailed: "Couldn't summarise the context",
   toolRunning: "Running",
   toolCompleted: "Done",
   toolRejected: "Rejected",
@@ -143,6 +167,7 @@ const APARTE_DEFAULT_LOCALE = {
   generating: "Generating…",
   rebuildingPreview: "Rebuilding preview…",
   typing: "Typing",
+  responseCutOff: "Cut off at the model's length limit.",
   error: "Error",
   running: "Running...",
   run: "Run",
@@ -199,15 +224,19 @@ function readAuth(auth) {
   if (auth && typeof auth === "object") return { key: auth["apiKey"], endpoint: auth["endpoint"] };
   return {};
 }
-async function vendorErrorMessage(response, label = "HTTP") {
-  const body = await response.json().catch(() => ({}));
+function messageOf(body, status, label) {
   const raw = body?.error;
   const msg = typeof raw === "object" ? raw?.message : raw;
-  return typeof msg === "string" && msg ? msg : `${label} ${response.status}`;
+  return typeof msg === "string" && msg ? msg : `${label} ${status}`;
+}
+function isAparteErrorCode(value) {
+  return typeof value === "string" && Object.values(AparteErrorCode).includes(value);
 }
-async function vendorError(response, label = "HTTP") {
-  const message = await vendorErrorMessage(response, label);
-  const code = AparteError.codeForStatus(response.status) ?? AparteErrorCode.UNKNOWN_ERROR;
+async function vendorError(response, label = "HTTP", adapter) {
+  const body = await response.json().catch(() => void 0);
+  const message = messageOf(body, response.status, label);
+  const forwarded = body?.error?.code;
+  const code = adapter?.classifyError?.(response.status, body) ?? (isAparteErrorCode(forwarded) ? forwarded : void 0) ?? AparteError.codeForStatus(response.status) ?? AparteErrorCode.UNKNOWN_ERROR;
   return new AparteError(message, code, void 0, void 0, response.status);
 }
 async function parseNonStreamText(provider, response, providerId) {
@@ -250,7 +279,7 @@ class AparteDirectTransport {
       signal: ctx.signal
     });
     if (!response.ok) {
-      throw await vendorError(response);
+      throw await vendorError(response, "HTTP", provider);
     }
     if (request.stream === false) {
       return parseNonStreamText(provider, response, ctx.providerId);
@@ -878,12 +907,18 @@ function createAparteChatHandler(options) {
       const raw = await vendor.text().catch(() => "");
       let code;
       let type;
+      let body;
       try {
-        const parsed = JSON.parse(raw);
+        body = JSON.parse(raw);
+        const parsed = body;
         code = parsed?.error?.code;
         type = parsed?.error?.type;
       } catch {
       }
+      try {
+        code = adapter.classifyError?.(vendor.status, body) ?? code;
+      } catch {
+      }
       return new Response(
         JSON.stringify({
           error: {
@@ -897,7 +932,12 @@ function createAparteChatHandler(options) {
     }
     if (request.stream === false) {
       const json = await vendor.json().catch(() => ({}));
-      const text = typeof adapter.parseText === "function" ? adapter.parseText(json) : "";
+      let text;
+      try {
+        text = typeof adapter.parseText === "function" ? adapter.parseText(json) : "";
+      } catch {
+        return jsonError$1(502, "The vendor answered with an error.");
+      }
       return new Response(JSON.stringify({ text }), {
         headers: { "Content-Type": "application/json" }
       });
@@ -915,7 +955,7 @@ function createAparteChatHandler(options) {
             controller.close();
             return;
           }
-          controller.enqueue(encoder2.encode(JSON.stringify(value) + "\n"));
+          controller.enqueue(encoder2.encode(JSON.stringify(relayable(value)) + "\n"));
         } catch (err) {
           controller.error(err);
         }
@@ -927,6 +967,13 @@ function createAparteChatHandler(options) {
     return new Response(ndjson, { headers: { "Content-Type": "application/x-ndjson" } });
   };
 }
+function relayable(event) {
+  const e = event;
+  if (e?.type !== "error") return event;
+  console.error("[aparte] the vendor streamed an error", event);
+  const code = typeof e.code === "string" && Object.values(AparteErrorCode).includes(e.code) ? e.code : void 0;
+  return { type: "error", message: "The vendor reported an error.", ...code ? { code } : {} };
+}
 function jsonError$1(status, message) {
   return new Response(JSON.stringify({ error: { message } }), {
     status,
@@ -1248,7 +1295,10 @@ function createStreamAdapter(opts) {
         break;
       }
       case "run-done":
-        target.updateMessage?.(messageId, { status: "completed" });
+        target.updateMessage?.(messageId, {
+          status: "completed",
+          ...e.finishReason ? { finishReason: e.finishReason } : {}
+        });
         if (e.usage) {
           try {
             target.setUsage?.(messageId, e.usage);
@@ -1519,10 +1569,11 @@ function createAparteAgentHandler(options) {
           console.error("[aparte] agent run failed", error);
           await pendingWrite?.catch(() => {
           });
+          const named = AparteError.from(error).code;
           write({
             type: "run-error",
             message: "The agent run failed.",
-            code: error instanceof AparteError ? error.code : "AGENT_RUN_FAILED"
+            code: named === AparteErrorCode.UNKNOWN_ERROR ? "AGENT_RUN_FAILED" : named
           });
           close();
         });
@@ -2023,6 +2074,8 @@ class AparteConfig {
   _modelPreferenceProvider;
   // Per-call approval policy (a mode: plan / ask / auto). `null` = the tools' own flags.
   _approvalPolicy = null;
+  // What makes the context smaller — `@aparte/plugin-compaction` registers itself here. `null` = nothing does.
+  _compactor = null;
   // Conversation persistence (optional, agnostic)
   _conversationManager;
   /*
@@ -2513,7 +2566,11 @@ class AparteConfig {
     try {
       const auth = await this.getKey(providerId);
       const models = await provider.fetchModels(auth);
+      const held = this._fetchedModels.get(providerId);
+      if (models.length === 0 && held?.length) return held;
+      const windowBefore = this.getCurrentModel()?.contextWindow;
       this._fetchedModels.set(providerId, models);
+      if (this.getCurrentModel()?.contextWindow !== windowBefore) this._notify();
       return models;
     } catch (error) {
       console.warn(`[AparteConfig] Failed to refresh models for ${providerId}`, error);
@@ -2637,6 +2694,26 @@ class AparteConfig {
   getApprovalPolicy() {
     return this._approvalPolicy;
   }
+  /**
+   * Register what makes the context smaller: the gauge's Compact now, a separator's
+   * Retry and the client's pre-flight and overflow retry call it. `null` removes it.
+   *
+   * `@aparte/plugin-compaction`'s `setupCompaction()` registers itself here; core never
+   * compacts on its own, so a page without a compactor has a gauge that measures and a
+   * separator whose Retry falls back to the `aparte-compact` event. A chat reads the one
+   * on ITS config first (`resolveConfig(chat).getCompactor()`), then the client's.
+   *
+   * Notifies like every other registration: a mounted gauge has to hear that "Compact
+   * now" became possible after it was drawn, or went away.
+   */
+  setCompactor(compactor) {
+    this._compactor = compactor;
+    this._notify();
+  }
+  /** The registered compactor, or `null`. */
+  getCompactor() {
+    return this._compactor;
+  }
   /**
    * What the policy says about one call, with the tool's own `needsApproval` as the
    * answer when it has no opinion. The one place the two are combined, so the client's
@@ -3377,6 +3454,7 @@ class AparteConfig {
     this._elicitationFieldRenderer = void 0;
     this._modelPreferenceProvider = void 0;
     this._approvalPolicy = null;
+    this._compactor = null;
     this._bubbleActionsConfig = { ...APARTE_DEFAULT_BUBBLE_ACTIONS };
     this._hostHandlers = { ...APARTE_DEFAULT_HOST_HANDLERS };
     this._notify();
@@ -4520,13 +4598,25 @@ function populateBubbleFromMessage(bubble, message, siblingInfo) {
   if (message.usage !== void 0) {
     bubble.setUsage?.(message.usage);
   }
+  bubble.setFinishReason?.(message.finishReason);
+  bubble.setContextSummary?.(message.contextSummary, { legacy: message.compaction === true });
 }
 const APARTE_CONVERSATION_SCHEMA_VERSION = 2;
 const APARTE_DERIVED_SEGMENTS = Symbol.for("aparte.derivedSegments");
 function applyRetention(messages, tree, maxMessages) {
   if (maxMessages <= 0 || messages.length <= maxMessages) return { messages, tree };
-  const trimmedFlat = messages.slice(messages.length - maxMessages);
-  const cutoffId = trimmedFlat[0]?.id;
+  const cutIndex = messages.length - maxMessages;
+  const trimmedFlat = messages.slice(cutIndex);
+  const first = trimmedFlat[0];
+  const cutoffId = first?.id;
+  let inherited;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const own = messages[i].contextSummary;
+    if (!own) continue;
+    if (i < cutIndex) inherited = { ...own, count: own.count + (cutIndex - i) };
+    break;
+  }
+  if (first && inherited) trimmedFlat[0] = { ...first, contextSummary: inherited };
   if (!cutoffId || !tree) return { messages: trimmedFlat, tree };
   const treeIds = new Set(tree.messages.map((m) => m.message.id));
   if (!treeIds.has(cutoffId)) return { messages: trimmedFlat, tree };
@@ -4548,7 +4638,7 @@ function applyRetention(messages, tree, maxMessages) {
   }
   const trimmedTree = {
     headId: tree.headId,
-    messages: tree.messages.filter((m) => keep.has(m.message.id)).map((m) => m.message.id === cutoffId ? { message: m.message, parentId: null } : m)
+    messages: tree.messages.filter((m) => keep.has(m.message.id)).map((m) => m.message.id === cutoffId ? { message: inherited ? { ...m.message, contextSummary: inherited } : m.message, parentId: null } : m)
   };
   return { messages: trimmedFlat, tree: trimmedTree };
 }
@@ -4579,6 +4669,7 @@ function treeContentOf(tree) {
   const byId = [...tree.messages].sort((a, b) => a.message.id < b.message.id ? -1 : a.message.id > b.message.id ? 1 : 0);
   return stableStringify(byId.map((entry) => ({ parentId: entry.parentId, message: asContent(entry.message) })));
 }
+const isTitleSource = (m) => m.role === "user" && !m.compaction;
 class AparteConversationManager {
   _adapter;
   _conversations = [];
@@ -4787,7 +4878,7 @@ class AparteConversationManager {
   async _append(convId, msg) {
     const conv = await this._full(convId);
     if (!conv) return;
-    const isFirstUserMsg = msg.role === "user" && conv.messages.every((m) => m.role !== "user");
+    const isFirstUserMsg = msg.role === "user" && !msg.compaction && conv.messages.every((m) => m.role !== "user" || m.compaction);
     const title = isFirstUserMsg ? await this._title(msg) : null;
     const fresh = this._find(convId);
     if (!fresh) return;
@@ -4815,7 +4906,7 @@ class AparteConversationManager {
       console.warn(`[AparteConversationManager] updateMessages('${convId}') before its messages were loaded: ignored.`);
       return;
     }
-    const firstUser = messages.find((m) => m.role === "user");
+    const firstUser = messages.find(isTitleSource);
     if (this._retention) {
       ({ messages, tree } = applyRetention(messages, tree, this._retention.maxMessages));
     }
@@ -4836,7 +4927,7 @@ class AparteConversationManager {
     }
     let title;
     if (conv.autoTitle) {
-      const before = conv.messages.find((m) => m.role === "user");
+      const before = conv.messages.find(isTitleSource);
       if (firstUser && (firstUser.content ?? "") !== (before?.content ?? "")) {
         title = await this._title(firstUser);
       }
@@ -5209,7 +5300,7 @@ class AparteConversationController {
     this._onCompactDone = (e) => {
       const detail = e.detail;
       if (detail?.targetId && detail.targetId !== this._binding.hostId) return;
-      queueMicrotask(() => this._persistOnceSummarised(detail?.summary, 0));
+      queueMicrotask(() => this._persistOnceSummarised(detail ?? {}, 0));
     };
     if (typeof window !== "undefined") {
       window.addEventListener("aparte-conversation-select", this._onSelectConversation);
@@ -5414,20 +5505,40 @@ class AparteConversationController {
    * that was partially written before a switch or component destruction.
    */
   /**
-   * Save once the binding holds the summary a compaction announced. A transcript kept in
-   * a framework store reaches the binding only when that framework renders, so a save on
-   * the microtask wrote the conversation as it stood before the compaction. Bounded: a
-   * run with no summary (skipped), or a binding that never shows it, is saved as it is.
-   */
-  _persistOnceSummarised(summary, waits) {
-    const holds = !summary || this._binding.getMessages().some(
-      (m) => m.compaction === true && typeof m.content === "string" && m.content.endsWith(summary)
-    );
+   * Save once the binding holds what a compaction (or a Restore) announced. A transcript
+   * kept in a framework store reaches the binding only when that framework renders, so a
+   * save on the microtask wrote the conversation as it stood before the change. Bounded:
+   * a run that changed nothing (skipped), or a binding that never shows the change, is
+   * saved as it is.
+   *
+   * What "holds" means follows what the run said it did:
+   * - a checkpoint — `messageId` names the message carrying it, and it holds once that
+   *   message carries a `contextSummary` with its `createdAt` (a summary without the
+   *   stamp is a half-written one);
+   * - a Restore — it holds once no message of the path carries a checkpoint any more;
+   * - an older host's summary MESSAGE (`compaction: true`, ending with the summary).
+   * A run that names none of these has nothing to wait for.
+   */
+  _persistOnceSummarised(detail, waits) {
+    const messages = this._binding.getMessages();
+    let holds = true;
+    if (detail.restored) {
+      holds = !messages.some((m) => m.contextSummary !== void 0);
+    } else if (detail.messageId || detail.summary) {
+      const { messageId, summary } = detail;
+      const checkpointed = !!messageId && messages.some(
+        (m) => m.id === messageId && typeof m.contextSummary?.createdAt === "number"
+      );
+      const summaryMessage = !!summary && messages.some(
+        (m) => m.compaction === true && typeof m.content === "string" && m.content.endsWith(summary)
+      );
+      holds = checkpointed || summaryMessage;
+    }
     if (holds || !this._binding.afterRender || waits >= MAX_COMPACTION_SAVE_WAITS) {
       this._persistActive();
       return;
     }
-    this._binding.afterRender(() => this._persistOnceSummarised(summary, waits + 1));
+    this._binding.afterRender(() => this._persistOnceSummarised(detail, waits + 1));
   }
   _persistActive() {
     if (!this._activeId) return;
@@ -5505,16 +5616,126 @@ function gateGlide(el2) {
   el2.addEventListener("aparte-send", lift);
   return off;
 }
+function chatIdOf(el2) {
+  let node = el2.parentElement;
+  while (node) {
+    const isHost = node.tagName.toLowerCase() === "aparte-chat" || node.hasAttribute("data-aparte-chat");
+    if (isHost && node.id) return node.id;
+    node = node.parentElement;
+  }
+  return void 0;
+}
+class CheckpointStateWatcher {
+  constructor(_options) {
+    this._options = _options;
+  }
+  _messageId = null;
+  _state = null;
+  _reason = "";
+  /** The bubble the attributes were last written to, so they can be taken off it even after it left the lookup. */
+  _marked = null;
+  /** Listen on `window` for the three events; returns the function that stops. */
+  start() {
+    const mine = (targetId) => {
+      if (this._options.active && !this._options.active()) return false;
+      return !targetId || targetId === this._options.ownId();
+    };
+    const mineMessage = (messageId) => !!messageId && this._options.owns(messageId);
+    const onStart = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || !mineMessage(detail?.messageId)) return;
+      this.clear();
+      this._set(detail.messageId, "pending", "");
+    };
+    const onDone = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || detail?.skipped) return;
+      if (detail?.messageId && detail.messageId === this._messageId) this.clear();
+    };
+    const onError = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || !mineMessage(detail?.messageId)) return;
+      if (detail.aborted) {
+        if (detail.messageId === this._messageId) this.clear();
+        return;
+      }
+      if (detail.messageId !== this._messageId) this.clear();
+      this._set(detail.messageId, "failed", detail.error ?? "");
+    };
+    window.addEventListener("aparte-compact-start", onStart);
+    window.addEventListener("aparte-compact-done", onDone);
+    window.addEventListener("aparte-compact-error", onError);
+    return () => {
+      window.removeEventListener("aparte-compact-start", onStart);
+      window.removeEventListener("aparte-compact-done", onDone);
+      window.removeEventListener("aparte-compact-error", onError);
+    };
+  }
+  /** Take the state off the bubble and forget it. */
+  clear() {
+    const bubble = this._marked ?? (this._messageId ? this._options.bubbleOf(this._messageId) : null);
+    this._messageId = null;
+    this._state = null;
+    this._reason = "";
+    this._marked = null;
+    bubble?.removeAttribute("data-checkpoint");
+    bubble?.removeAttribute("data-checkpoint-reason");
+  }
+  /** Write the remembered state onto the bubble, which may have been created since. */
+  reapply() {
+    if (!this._messageId || !this._state) return;
+    this._write(this._messageId, this._state, this._reason);
+  }
+  _set(messageId, state, reason) {
+    this._messageId = messageId;
+    this._state = state;
+    this._reason = reason;
+    this._write(messageId, state, reason);
+  }
+  _write(messageId, state, reason) {
+    const bubble = this._options.bubbleOf(messageId);
+    if (!bubble) return;
+    if (this._marked && this._marked !== bubble) {
+      this._marked.removeAttribute("data-checkpoint");
+      this._marked.removeAttribute("data-checkpoint-reason");
+    }
+    this._marked = bubble;
+    if (reason) bubble.setAttribute("data-checkpoint-reason", reason);
+    else bubble.removeAttribute("data-checkpoint-reason");
+    if (bubble.getAttribute("data-checkpoint") !== state) bubble.setAttribute("data-checkpoint", state);
+  }
+}
 const MAX_SIBLING_RETRIES = 6;
 const TREE_OWNED_FIELDS = /* @__PURE__ */ new Set(["id", "branches", "activeBranchIndex", "isStreaming"]);
 const ALWAYS_PRESENT_FIELDS = /* @__PURE__ */ new Set(["content", "segments", "status"]);
+const RENDERED_FIELDS = ["content", "segments", "attachments", "usage", "finishReason", "contextSummary", "compaction"];
 class AparteChatHost {
   binding;
   options;
   /** Id of the assistant message currently streaming (null when idle). */
   _streamingId = null;
-  /** Message ids already reconciled onto a bubble (skip-rerender cache). */
-  _renderedIds = /* @__PURE__ */ new Set();
+  /**
+   * The message object each bubble was last drawn from, by id (skip-rerender cache).
+   *
+   * An id alone could not say whether the list had changed under a bubble: a framework
+   * that owns the transcript (a controlled `messages` prop, a v-model, a store behind a
+   * compaction target) never goes through {@link updateMessage}, it hands over a list
+   * with a NEW object for the message it changed, and a checkpoint written that way to a
+   * message that was not the last never reached its bubble. Immutable updates always
+   * produce a new object, so the reference is the signal; the same object again means
+   * nothing changed and the bubble is left alone.
+   */
+  _renderedIds = /* @__PURE__ */ new Map();
+  /**
+   * Says on the bubble what a compaction is doing to the message it will sit on. The
+   * viewport answers for this in a chat with no framework; here the framework owns the
+   * list and the host is the one that knows which bubble is whose.
+   */
+  _checkpointState = new CheckpointStateWatcher({
+    ownId: () => this.binding.hostId,
+    bubbleOf: (id) => this._bubbleById(id),
+    owns: (id) => this.binding.getMessages().some((m) => m.id === id)
+  });
   /** Sibling info from the last path-change, applied after the next render. */
   _pendingSiblings;
   /** How many render passes the sibling write has waited for — see `_applyPendingSiblings`. */
@@ -5600,6 +5821,7 @@ class AparteChatHost {
     }
     this._installHostMethods(host2);
     this._installLifecycleListeners(host2);
+    this._teardown.push(this._checkpointState.start());
     this._teardown.push(gateGlide(host2));
     this._installViewportListeners();
     this._createController(host2);
@@ -5713,6 +5935,7 @@ class AparteChatHost {
     this._setStreamingId(null);
     this.binding.onTypingChange?.(false);
     this._renderedIds.clear();
+    this._checkpointState.clear();
     this.binding.resetComposer?.();
   }
   // ── host method surface (also installed on the host element) ───────────
@@ -5762,6 +5985,13 @@ class AparteChatHost {
     if (updates.status) {
       this._bubbleById(messageId)?.updateMessage?.({ status: updates.status });
     }
+    if (index !== msgs.length - 1 && RENDERED_FIELDS.some((key) => key in updates)) {
+      this._renderedIds.delete(messageId);
+      const bubble = this._bubbleById(messageId);
+      if (bubble && ("contextSummary" in updates || "compaction" in updates)) {
+        bubble.setContextSummary?.(merged.contextSummary, { legacy: merged.compaction === true });
+      }
+    }
     if (isTerminalStatus(merged.status) && merged.segments) {
       for (const id of openSegmentIds(merged.segments)) {
         this.updateSegment(id, { isStreaming: false });
@@ -6060,18 +6290,20 @@ class AparteChatHost {
   /**
    * Reconcile rendered bubbles with the current message list. The framework
    * calls this from its reactive message-change hook after rendering; the
-   * last message is always re-synced (streaming), others only once.
+   * last message is always re-synced (streaming), the others whenever the list
+   * holds a different object for them than the one they were drawn from.
    */
   syncBubbles() {
     const msgs = this.binding.getMessages();
     msgs.forEach((message, index) => {
       const isLast = index === msgs.length - 1;
-      if (this._renderedIds.has(message.id) && !isLast) return;
+      if (this._renderedIds.get(message.id) === message && !isLast) return;
       const bubble = this._bubbleById(message.id);
       if (!bubble) return;
       populateBubbleFromMessage(bubble, message);
-      this._renderedIds.add(message.id);
+      this._renderedIds.set(message.id, message);
     });
+    this._checkpointState.reapply();
   }
   /**
    * Rebuild the viewport's internal repo from the message list before branch
@@ -6190,6 +6422,7 @@ class AparteChatHost {
     host2["removeSegment"] = (id) => this.removeSegment(id);
     host2["appendToSegment"] = (id, c) => this.appendToSegment(id, c);
     host2["getMessages"] = () => this.getMessages();
+    host2["getMessage"] = (id) => this.binding.getMessages().find((m) => m.id === id);
     host2["addBranch"] = (id) => this.addBranch(id);
     host2["addSiblingOf"] = (id, m) => this.addSiblingOf(id, m);
     host2["truncateFrom"] = (id) => this.truncateFrom(id);
@@ -6264,6 +6497,37 @@ class AparteChatHost {
     });
   }
 }
+function historyFromCheckpoint(path) {
+  for (let i = path.length - 1; i >= 0; i--) {
+    const summary = path[i].contextSummary?.summary;
+    if (summary !== void 0) return { summary, messages: path.slice(i) };
+  }
+  return { messages: path };
+}
+const COMPACTION_PREAMBLE = "The earlier part of this conversation was compacted. This is a summary of what came before; continue from it.";
+const underPreamble = (text) => `${COMPACTION_PREAMBLE}
+
+${text}`;
+function mergeAdjacentUserMessages(messages) {
+  const asParts = (c) => typeof c === "string" ? [{ type: "text", text: c }] : c;
+  const out = [];
+  for (const m of messages) {
+    const prev = out[out.length - 1];
+    if (m.role !== "user" || prev?.role !== "user") {
+      out.push(m);
+    } else if (typeof prev.content === "string" && typeof m.content === "string") {
+      out[out.length - 1] = { ...prev, content: `${prev.content}
+
+${m.content}` };
+    } else {
+      out[out.length - 1] = {
+        ...prev,
+        content: [...asParts(prev.content), { type: "text", text: "\n\n" }, ...asParts(m.content)]
+      };
+    }
+  }
+  return out;
+}
 const STOPPED_TOOL_TEXT = "The tool call was stopped before it ran.";
 const EMPTY_TOOL_TEXT = "The tool returned no output.";
 function answerOf(segment) {
@@ -6314,6 +6578,139 @@ function wireTurns(message, textOf, options = {}) {
   flush();
   return out;
 }
+const isInFlight = (m) => m.status === "streaming" || m.status === "pending";
+function segmentsToWireText(segments) {
+  if (!segments?.length) return "";
+  const fence = "```";
+  const parts = [];
+  for (const segment of segments) {
+    const content = segment.content;
+    if (segment.type === "text") {
+      if (content) parts.push(content);
+    } else if (segment.type === "code") {
+      const lang = segment.language ?? "";
+      parts.push(`${fence}${lang}
+${content ?? ""}
+${fence}`);
+    } else if (segment.type === "thinking" || segment.type === "tool_call" || segment.type === "error") {
+      continue;
+    } else if (typeof content === "string" && content) {
+      parts.push(content);
+    } else {
+      const fallback = segment.fallback;
+      if (fallback) parts.push(fallback);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function extractWireText(message) {
+  const rendered = segmentsToWireText(message.segments);
+  if (rendered) return rendered;
+  if (typeof message.content === "string" && message.content) return message.content;
+  return "";
+}
+function messageWireText(message) {
+  const text = extractWireText(message);
+  return message.compaction ? underPreamble(text) : text;
+}
+function wireMessages(messages) {
+  return messages.filter((m) => {
+    if (m.role !== "user" && m.role !== "assistant") return false;
+    return m.status !== "error" && !isInFlight(m);
+  }).flatMap((m) => {
+    if (m.role === "assistant" && m.segments?.some((s) => s.type === "tool_call")) {
+      return wireTurns(m, segmentsToWireText);
+    }
+    const content = messageWireText(m);
+    return content ? [{ role: m.role, content }] : [];
+  });
+}
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 3.8);
+}
+const estimateJson = (value) => {
+  if (!value) return 0;
+  try {
+    return estimateTokens(JSON.stringify(value));
+  } catch {
+    return 0;
+  }
+};
+function estimateChatTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateTokens(contentToText(message.content));
+    if (message.toolCalls?.length) total += estimateJson(message.toolCalls);
+  }
+  return total;
+}
+function carriesNonTextParts(messages) {
+  return messages.some((m) => typeof m.content !== "string" && m.content.some((p) => p.type !== "text"));
+}
+function estimateRequestTokens(request) {
+  const declared = (request.tools ?? []).map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }));
+  return estimateChatTokens(request.messages) + (declared.length ? estimateJson(declared) : 0);
+}
+function estimateWireTokens(messages) {
+  return estimateChatTokens(wireMessages(messages));
+}
+const usageTokens = (usage) => usage.totalTokens ?? usage.inputTokens + usage.outputTokens;
+function toolsForCurrentModel(config) {
+  const capabilities = config.getCurrentModel()?.capabilities;
+  const declinesTools = capabilities ? !capabilities.includes("function_calling") : false;
+  return declinesTools ? [] : config.getTools();
+}
+function windowOf(config, windowOverride) {
+  if (typeof windowOverride === "number" && Number.isFinite(windowOverride) && windowOverride > 0) return windowOverride;
+  const declared = config.getCurrentModel()?.contextWindow;
+  return declared && declared > 0 ? declared : void 0;
+}
+const hasSegment = (message, type) => message.segments?.some((s) => s.type === type) === true;
+function calibration(reply) {
+  const sent = reply.usage?.inputTokens;
+  const recorded = reply.contextEstimate;
+  if (hasSegment(reply, "tool_call")) return 1;
+  return sent && recorded && sent > 0 && recorded > 0 ? Math.min(3, Math.max(0.5, sent / recorded)) : 1;
+}
+function nextRequestTokens(reply, k) {
+  const usage = reply.usage;
+  if (!hasSegment(reply, "thinking") || !(usage.inputTokens > 0)) return usageTokens(usage);
+  const segments = reply.segments ?? [];
+  const lastCall = segments.map((s) => s.type).lastIndexOf("tool_call");
+  const said = Math.round(k * estimateTokens(segmentsToWireText(segments.slice(lastCall + 1))));
+  return usage.inputTokens + (usage.outputTokens > 0 ? Math.min(said, usage.outputTokens) : said);
+}
+function measureContext(input) {
+  const { messages, config } = input;
+  const view = historyFromCheckpoint(messages);
+  const system = estimateTokens(config.resolveSystemPrompt()) + estimateTokens(config.resolveToolSystemPrompts());
+  const declared = toolsForCurrentModel(config).map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }));
+  const tools = declared.length ? estimateJson(declared) : 0;
+  const summary = view.summary === void 0 ? 0 : estimateTokens(underPreamble(view.summary));
+  const parts = { system, tools, summary, messages: estimateWireTokens(view.messages) };
+  const total = system + tools + summary + parts.messages;
+  let replyIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant" && messages[i].usage) {
+      replyIndex = i;
+      break;
+    }
+  }
+  const reply = replyIndex >= 0 ? messages[replyIndex] : void 0;
+  const window2 = windowOf(config, input.windowOverride);
+  const result = (used, estimated) => ({
+    ...window2 !== void 0 ? { window: window2 } : {},
+    used,
+    estimated,
+    parts,
+    other: Math.max(0, used - total)
+  });
+  const unchanged = reply !== void 0 && !input.viewChanged && replyIndex === messages.length - 1 && !messages.some((m) => m.contextSummary !== void 0 && m.contextSummary.createdAt > reply.timestamp);
+  const k = reply ? calibration(reply) : 1;
+  if (reply && unchanged) return result(nextRequestTokens(reply, k), false);
+  return result(Math.round(k * total), true);
+}
 function eventOrigin(e) {
   return e.composedPath?.()[0] ?? e.target;
 }
@@ -6850,7 +7247,6 @@ function buildApprovalPanel(message, options, onChange, details) {
 function requestUserInput(request) {
   return resolveConfig(request.target ?? null).requestUserInput(request);
 }
-const COMPACTION_PREAMBLE = "The earlier part of this conversation was compacted. This is a summary of what came before; continue from it.";
 const NOT_RUN_AFTER_A_REFUSAL = "Not run: an earlier call of the same step was refused.";
 const approvalKey = (call) => JSON.stringify([call.id, call.name, call.input]);
 const warnedUninlinedFiles = /* @__PURE__ */ new Set();
@@ -6879,6 +7275,28 @@ class AparteClient {
   _boundEditHandler = null;
   _releaseKeyResolver = null;
   _isAborted = false;
+  /** Provider and model pairs whose window was already read again after a turn (see `_readWindowAfterTurn`). */
+  _windowReadFor = /* @__PURE__ */ new Set();
+  /**
+   * The current model's window, read again once after a turn when it had none.
+   *
+   * A local server that loads a model on its first request — LM Studio's just-in-time
+   * loading, Ollama — has no loaded window to report when the model list is fetched at
+   * start-up, so the model comes without one, and the gauge and the compaction have
+   * nothing to measure against. After a reply the model is loaded, and the provider's
+   * own probe finds it. Once per provider and model: a server that never says costs one
+   * request, not one per turn. The config announces the window when it appears.
+   */
+  async _readWindowAfterTurn() {
+    const config = this._config;
+    const model = config.getCurrentModel();
+    const providerId = config.getModelConfig().defaultProvider;
+    if (!model || model.contextWindow || !providerId) return;
+    const key = `${providerId}\0${model.id}`;
+    if (this._windowReadFor.has(key)) return;
+    this._windowReadFor.add(key);
+    await config.refreshProviderModels(providerId);
+  }
   /**
    * Does this window event belong to this client?
    *
@@ -7160,19 +7578,23 @@ class AparteClient {
   async _streamTurn(targetElement, messageId, provider, messages, modelId, authConfig, opts) {
     const chatId = this._targetIdOf(targetElement);
     const registeredTools = this._toolsForCurrentModel();
-    let baseRequest = {
-      messages,
-      modelId,
-      stream: true,
-      tools: registeredTools.length ? registeredTools : void 0,
-      ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {}
+    const buildRequest = async (requestMessages2) => {
+      let built = {
+        messages: requestMessages2,
+        modelId,
+        stream: true,
+        tools: registeredTools.length ? registeredTools : void 0,
+        ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {}
+      };
+      if (this.options.requestInterceptor) {
+        built = await this.options.requestInterceptor(built);
+      }
+      if (built.toolChoice === "none") {
+        built = { ...built, tools: void 0 };
+      }
+      return built;
     };
-    if (this.options.requestInterceptor) {
-      baseRequest = await this.options.requestInterceptor(baseRequest);
-    }
-    if (baseRequest.toolChoice === "none") {
-      baseRequest = { ...baseRequest, tools: void 0 };
-    }
+    let baseRequest = await buildRequest(messages);
     if (this._isAborted) {
       dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
       this._updateMessage(targetElement, messageId, { status: "completed" });
@@ -7193,7 +7615,23 @@ class AparteClient {
     if (this._streamController !== streamController) this._streamController?.abort();
     this._streamController = streamController;
     this._turnsInFlight.add(messageId);
-    try {
+    const compactor = opts?.rebuild ? resolveConfig(targetElement).getCompactor() ?? this._config.getCompactor() : null;
+    const turnIds = () => {
+      const path = targetElement.getMessages?.() ?? [];
+      const at = path.findIndex((m) => m.id === messageId);
+      const asked = at > 0 ? path[at - 1] : void 0;
+      return asked?.role === "user" ? [asked.id, messageId] : [messageId];
+    };
+    const requestMessages = () => opts?.resume ? this._resumeMessages(targetElement, messageId, baseRequest.messages) : baseRequest.messages;
+    const requestEstimate = () => estimateRequestTokens({ messages: requestMessages(), tools: baseRequest.tools });
+    const recordedEstimate = () => carriesNonTextParts(requestMessages()) ? void 0 : requestEstimate();
+    const endStopped = () => {
+      this._closeOpenCalls(targetElement, messageId);
+      dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
+      this._updateMessage(targetElement, messageId, { status: "completed" });
+    };
+    const isStopped = () => this._isAborted || streamController.signal.aborted;
+    const runOnce = async () => {
       let result = opts?.resume ? { usage: void 0, suspended: opts.resume } : await this._streamLoop(targetElement, messageId, provider, baseRequest, authConfig, streamController);
       const maxResumes = this.options.maxTurns ?? 10;
       let resumes = 0;
@@ -7236,21 +7674,80 @@ class AparteClient {
         );
       }
       const usage = result.usage;
+      const finishReason = result.finishReason;
       if (this._isAborted || streamController.signal.aborted) {
         this._closeOpenCalls(targetElement, messageId);
         this._updateMessage(targetElement, messageId, { status: "completed" });
       } else {
-        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage }, chatId);
+        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage, ...finishReason ? { finishReason } : {} }, chatId);
+        void this._readWindowAfterTurn();
       }
-    } catch (error) {
-      this._closeOpenCalls(targetElement, messageId);
-      if (this._isAborted || streamController.signal.aborted) {
-        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
-        this._updateMessage(targetElement, messageId, { status: "completed" });
-        return;
+    };
+    const resendAfterOverflow = async (error) => {
+      if (error.code !== AparteErrorCode.USAGE_CONTEXT_EXCEEDED || !compactor || !opts?.rebuild) return "stands";
+      const segments = targetElement.getMessage?.(messageId)?.segments ?? targetElement.getMessages?.()?.find((m) => m.id === messageId)?.segments ?? [];
+      if (segments.some((s) => s.type === "text" || s.type === "tool_call")) return "stands";
+      try {
+        const outcome = await compactor.compact({
+          target: targetElement,
+          ...chatId ? { targetId: chatId } : {},
+          force: true,
+          reason: "overflow",
+          exclude: turnIds(),
+          signal: streamController.signal
+        });
+        if (isStopped()) return "stopped";
+        if (!outcome.ok || outcome.skipped) return "stands";
+        baseRequest = await buildRequest(await opts.rebuild());
+      } catch {
+        return "stands";
+      }
+      this._updateMessage(targetElement, messageId, { status: "pending" });
+      return "resend";
+    };
+    try {
+      for (let attempt = 0; ; attempt++) {
+        try {
+          if (attempt === 0 && compactor?.beforeSend && opts?.rebuild) {
+            let compacted = false;
+            try {
+              compacted = await compactor.beforeSend({
+                target: targetElement,
+                ...chatId ? { targetId: chatId } : {},
+                exclude: turnIds(),
+                requestTokens: requestEstimate(),
+                signal: streamController.signal
+              });
+            } catch (failure) {
+              console.warn("[AparteClient] The compactor threw before a send; sending the request as built.", failure);
+            }
+            if (isStopped()) {
+              endStopped();
+              return;
+            }
+            if (compacted) baseRequest = await buildRequest(await opts.rebuild());
+          }
+          this._updateMessage(targetElement, messageId, { contextEstimate: recordedEstimate() });
+          await runOnce();
+          return;
+        } catch (error) {
+          this._closeOpenCalls(targetElement, messageId);
+          if (isStopped()) {
+            dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
+            this._updateMessage(targetElement, messageId, { status: "completed" });
+            return;
+          }
+          const aparteError = AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR);
+          const next = attempt === 0 ? await resendAfterOverflow(aparteError) : "stands";
+          if (next === "resend") continue;
+          if (next === "stopped") {
+            endStopped();
+            return;
+          }
+          this._handleLifecycleError(targetElement, messageId, aparteError);
+          return;
+        }
       }
-      const aparteError = AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR);
-      this._handleLifecycleError(targetElement, messageId, aparteError);
     } finally {
       this._turnsInFlight.delete(messageId);
     }
@@ -7265,29 +7762,12 @@ class AparteClient {
    * using the same conversation history minus the retried reply.
    */
   /**
-   * The registered tools, unless the current model says it cannot call one.
-   *
-   * Single source for the gate, so send / retry / edit cannot drift.
-   *
-   * The question is "did this model say it cannot", not "did it say it can": the
-   * app sets a model id by hand (`setModelConfig`) or a selector sets it from a
-   * fetched list, and in both cases the model's declared capabilities are commonly
-   * unknown. `undefined` capabilities read as "can", or `tools: []` would go on
-   * the wire while `getTools()` held the tool the app had explicitly registered,
-   * and the model would answer that it had no such tool. Registering a tool is an explicit act by the app; silently dropping it
-   * because a `/models` listing is terse is the library second-guessing the
-   * developer. A model that declares its capabilities and omits function calling
-   * is still honoured — that is a statement, and it is respected.
-   *
-   * Failure modes, both ways round: over-sending means a model that cannot use
-   * tools does not call one, or its own endpoint rejects the array with an error
-   * the developer can read. Under-sending would be silent, total, and look like a
-   * lying model.
+   * The registered tools, unless the current model says it cannot call one — the gate
+   * lives in `toolsForCurrentModel` (with its reasoning), where the context measure reads
+   * the same rule, so send / retry / edit and the gauge cannot drift.
    */
   _toolsForCurrentModel() {
-    const capabilities = this._config.getCurrentModel()?.capabilities;
-    const declinesTools = capabilities ? !capabilities.includes("function_calling") : false;
-    return declinesTools ? [] : this._config.getTools();
+    return toolsForCurrentModel(this._config);
   }
   async _handleRetry(event) {
     const { messageId, targetId } = event.detail ?? {};
@@ -7322,10 +7802,16 @@ class AparteClient {
       targetElement,
       newMessageId,
       provider,
-      [...systemMessages, ...chatMessages],
+      [...systemMessages, ...mergeAdjacentUserMessages(chatMessages)],
       config.defaultModel || "",
       authConfig,
-      { temperature: 0.4 }
+      {
+        temperature: 0.4,
+        rebuild: async () => [
+          ...this._systemMessages(),
+          ...mergeAdjacentUserMessages(this._messagesToChatMessages(this._current(targetElement, historyMessages)))
+        ]
+      }
     );
   }
   /**
@@ -7388,11 +7874,27 @@ class AparteClient {
       targetElement,
       newMessageId,
       provider,
-      [...systemMessages, ...chatMessages],
+      [...systemMessages, ...mergeAdjacentUserMessages(chatMessages)],
       config.defaultModel || "",
-      authConfig
+      authConfig,
+      {
+        rebuild: async () => [
+          ...this._systemMessages(),
+          ...mergeAdjacentUserMessages(this._messagesToChatMessages(this._current(targetElement, historyMessages)))
+        ]
+      }
     );
   }
+  /**
+   * These messages as the transcript holds them NOW. A retry or an edit slices the path
+   * before it streams; a compaction that runs during the turn writes its checkpoint onto
+   * one of those messages in the transcript, and the slice still holds the objects as they
+   * were. Looked up by id, tree-wide, because a retry has moved the path since.
+   */
+  _current(target, messages) {
+    const live2 = new Map((target.getMessages?.() ?? []).map((m) => [m.id, m]));
+    return messages.map((m) => target.getMessage?.(m.id) ?? live2.get(m.id) ?? m);
+  }
   /**
    * The chain the gesture really came up, nearest node first.
    *
@@ -7526,29 +8028,17 @@ class AparteClient {
    * imitating.
    */
   _messagesToChatMessages(messages) {
-    return this._wireHistory(messages);
+    const { summary, messages: kept } = historyFromCheckpoint(messages);
+    return [...this._summaryMessage(summary), ...wireMessages(kept)];
   }
   /**
-   * The one rule for what a message contributes to the wire.
-   *
-   * Not the slice — the contribution: a role the wire has (`user`/`assistant`), a
-   * turn that neither failed nor is still in flight, and text that is not empty.
-   *
-   * `_wireText` (not `m.content`): assistant replies stream their text into
-   * `segments`, leaving `content` as '', so without flattening every reply would be
-   * empty here and the drop below would swallow the whole transcript.
-   */
-  _wireHistory(messages) {
-    return messages.filter((m) => {
-      if (m.role !== "user" && m.role !== "assistant") return false;
-      return m.status !== "error" && !AparteClient._inFlight(m);
-    }).flatMap((m) => {
-      if (m.role === "assistant" && m.segments?.some((s) => s.type === "tool_call")) {
-        return wireTurns(m, (segments) => this._segmentsToText(segments));
-      }
-      const content = this._wireText(m);
-      return content ? [{ role: m.role, content }] : [];
-    });
+   * What the model reads in place of everything before a checkpoint: the summary, as a
+   * `user` message under the same preamble a legacy compaction message gets, so it is
+   * context and not something the person said. It may sit right before a user turn;
+   * `mergeAdjacentUserMessages` joins the two where the history is assembled.
+   */
+  _summaryMessage(summary) {
+    return summary === void 0 ? [] : [{ role: "user", content: underPreamble(summary) }];
   }
   /** The "no model selected" warning is said once per client, not once per dropped send. */
   _warnedNoModel = false;
@@ -7638,12 +8128,14 @@ class AparteClient {
     });
     let authConfig;
     let messages;
+    let fileParts;
     try {
       authConfig = providerId ? await this._resolveAuth(providerId) : void 0;
       const rawFiles = Array.isArray(event.detail?.files) ? event.detail.files : [];
       const filesToInject = this._selectFilesToInject(rawFiles);
       const contentParts = filesToInject.length > 0 ? await this._filesToContentParts(filesToInject) : [];
-      messages = this._buildMessages(content, targetElement, contentParts.length > 0 ? contentParts : void 0);
+      fileParts = contentParts.length > 0 ? contentParts : void 0;
+      messages = this._buildMessages(content, targetElement, fileParts);
     } catch (error) {
       this._handleLifecycleError(targetElement, messageId, AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR));
       return;
@@ -7654,7 +8146,8 @@ class AparteClient {
       provider,
       messages,
       modelId || config.defaultModel || "",
-      authConfig
+      authConfig,
+      { rebuild: async () => this._buildMessages(content, targetElement, fileParts) }
     );
   }
   /**
@@ -7671,101 +8164,18 @@ class AparteClient {
     }
     const userMsg = parts && parts.length > 0 ? [{ type: "text", text: userContent }, ...parts] : userContent;
     messages.push({ role: "user", content: userMsg });
-    return messages;
+    return mergeAdjacentUserMessages(messages);
   }
-  /**
-   * A turn that has not finished yet. `status` is OPTIONAL on `AparteMessage`, so
-   * the question the history gates can ask is "is this still in flight?", never
-   * "is this completed?".
-   *
-   * The gates below ask the first, because a host that SEEDS a transcript
-   * — restoring a saved conversation, hydrating a server-rendered one — has no
-   * reason to invent a status for turns that are already over. Asking "is this
-   * completed?" would leave the cutoff at 0 and slice away the whole transcript: the
-   * model would get the new question with no context, and nothing in the UI would say
-   * so, because the viewport still shows every message.
-   */
-  static _inFlight(m) {
-    return m.status === "streaming" || m.status === "pending";
-  }
-  _toHistoryMessages(messages) {
+  _toHistoryMessages(path) {
+    const { summary, messages } = historyFromCheckpoint(path);
     let cutoff = 0;
     for (let i = 0; i < messages.length; i++) {
       const m = messages[i];
-      if (m.role === "assistant" && m.status !== "error" && !AparteClient._inFlight(m)) {
+      if (m.role === "assistant" && m.status !== "error" && !isInFlight(m)) {
         cutoff = i + 1;
       }
     }
-    return this._wireHistory(messages.slice(0, cutoff));
-  }
-  /**
-   * A message's text as the MODEL should read it — the one mapper both history
-   * paths use, so the compaction preamble cannot be applied on retry and edit and
-   * forgotten on the ordinary send, which is what the first review of this feature
-   * caught: the summary went out on every normal turn as something the user said.
-   */
-  _wireText(message) {
-    const text = this._extractText(message);
-    return message.compaction ? `${COMPACTION_PREAMBLE}
-
-${text}` : text;
-  }
-  /**
-   * What the model is told it said last turn — reconstructed from what was
-   * RENDERED, not from the raw-text field.
-   *
-   * The segments are what the reader saw, so they come first. `content` is the
-   * fallback, and that is not vestigial: a non-streaming transport writes the whole
-   * reply there and creates no segments at all.
-   */
-  _extractText(message) {
-    const rendered = this._segmentsToText(message.segments);
-    if (rendered) return rendered;
-    if (typeof message.content === "string" && message.content) return message.content;
-    return "";
-  }
-  /**
-   * Segments → the text a model can read back.
-   *
-   * Fences and the language tag are kept. Without them the model re-reads its own
-   * code as prose — which is how it starts explaining a snippet it believes it
-   * wrote in English.
-   *
-   * A type core does not know — a registered block grammar's (an artifact, a
-   * citation, a file), a consumer's custom segment — follows one rule: its
-   * `content` if it has one, else its `fallback`, else nothing. Dropping such a
-   * segment would make a document the model had just produced invisible on the very
-   * next turn, so it could not be asked to change the thing it had built. An artifact
-   * is a plugin's type like any other and follows this rule.
-   *
-   * `thinking` and `tool_call` stay out on purpose — the first is the model's own
-   * scratchpad, and most APIs neither want it back nor bill for it kindly; the
-   * second is not text: `_wireHistory` sends a reply's calls as the assistant's
-   * `toolCalls` and the `tool` messages answering them (`wire-history.ts`).
-   */
-  _segmentsToText(segments) {
-    if (!segments?.length) return "";
-    const fence = "```";
-    const parts = [];
-    for (const segment of segments) {
-      const content = segment.content;
-      if (segment.type === "text") {
-        if (content) parts.push(content);
-      } else if (segment.type === "code") {
-        const lang = segment.language ?? "";
-        parts.push(`${fence}${lang}
-${content ?? ""}
-${fence}`);
-      } else if (segment.type === "thinking" || segment.type === "tool_call" || segment.type === "error") {
-        continue;
-      } else if (typeof content === "string" && content) {
-        parts.push(content);
-      } else {
-        const fallback = segment.fallback;
-        if (fallback) parts.push(fallback);
-      }
-    }
-    return parts.join("\n").trim();
+    return [...this._summaryMessage(summary), ...wireMessages(messages.slice(0, cutoff))];
   }
   /**
    * Which of the send's pending files get inlined into the request: the
@@ -7872,8 +8282,10 @@ ${content}
     });
     const prefixSegments = baseRequest._meta?.["prefixSegments"];
     let suspended;
+    let finishReason;
     const emitter = (event) => {
       adapter(event);
+      if (event.type === "run-done") finishReason = event.finishReason;
       if (event.type === "run-suspended") {
         const ticket = event.ticket;
         suspended = { pending: event.pending, ...typeof ticket === "string" ? { ticket } : {} };
@@ -7926,7 +8338,11 @@ ${content}
       // BARE uuid for the synthetic tool (the adapter renders `tool-<id>`).
       idGen: (prefix) => prefix === "synthetic-tool" ? uuid() : `${prefix}-${uuid()}`
     });
-    return { usage: usage ?? void 0, ...suspended ? { suspended } : {} };
+    return {
+      usage: usage ?? void 0,
+      ...finishReason ? { finishReason } : {},
+      ...suspended ? { suspended } : {}
+    };
   }
   /**
    * The approval channel a run asks through — and the one a paused server run's calls
@@ -8077,7 +8493,7 @@ ${content}
    */
   _resumeMessages(targetElement, messageId, sent) {
     const reply = targetElement.getMessages?.().find((m) => m.id === messageId);
-    return [...sent, ...reply ? wireTurns(reply, (segments) => this._segmentsToText(segments), { openDeferred: true }) : []];
+    return [...sent, ...reply ? wireTurns(reply, segmentsToWireText, { openDeferred: true }) : []];
   }
   /**
    * What the send of a reloaded turn put before its reply, rebuilt the way
@@ -8092,7 +8508,11 @@ ${content}
     const askedAt = before.map((m) => m.role).lastIndexOf("user");
     const historyOption = this.options.history ?? "viewport";
     const history = historyOption === "viewport" ? this._toHistoryMessages(before) : typeof historyOption === "function" ? historyOption(before) : [];
-    return [...this._systemMessages(), ...history, ...askedAt >= 0 ? this._wireHistory([before[askedAt]]) : []];
+    return mergeAdjacentUserMessages([
+      ...this._systemMessages(),
+      ...history,
+      ...askedAt >= 0 ? wireMessages([before[askedAt]]) : []
+    ]);
   }
   /**
    * A new message closes a wait nobody answered. The paused calls of the last reply are
@@ -8153,6 +8573,11 @@ ${content}
       const base = this._resumeBase(messages, messages.indexOf(last));
       await this._streamTurn(targetElement, last.id, provider, base, recorded?.modelId ?? config.defaultModel ?? "", authConfig, {
         resume: { pending: pending2, ticket },
+        rebuild: async () => {
+          const now = targetElement.getMessages?.() ?? [];
+          const at = now.findIndex((m) => m.id === last.id);
+          return at >= 0 ? this._resumeBase(now, at) : base;
+        },
         ...recorded?.temperature !== void 0 ? { temperature: recorded.temperature } : {}
       });
     } finally {
@@ -8232,7 +8657,8 @@ function createAgentStreamRunner(options) {
     let ended = false;
     for await (const line of readNdjson(response.body, opts.signal)) {
       if (line.type === "run-error") {
-        throw new AparteError(line.message || "The agent run failed.", AparteErrorCode.PROVIDER_ERROR, line.code ? { code: line.code } : void 0);
+        const known2 = Object.values(AparteErrorCode).includes(line.code ?? "") ? line.code : void 0;
+        throw new AparteError(line.message || "The agent run failed.", known2 ?? AparteErrorCode.PROVIDER_ERROR, line.code ? { code: line.code } : void 0);
       }
       if (line.type === "run-done" || line.type === "run-suspended") {
         usage = line.usage;
@@ -8727,7 +9153,7 @@ function deferHydrationOf(ctor) {
   };
 }
 export {
-  parseMarkdownToSegments as $,
+  isSegmentSettled as $,
   APARTE_CONFIG_CHANGE as A,
   contextConfig as B,
   copyText as C,
@@ -8744,57 +9170,64 @@ export {
   detachConfig as N,
   escapeAttr as O,
   escapeHtml as P,
-  filesToAttachments as Q,
-  getAllRenderers as R,
-  getSegmentRenderer as S,
-  installDefaultRenderersOnce as T,
-  installDialogTriggersOnce as U,
-  isAwaitingReply as V,
-  isFormatAdapter as W,
-  isSafeUrl as X,
-  isSegmentSettled as Y,
-  overrideSegmentRenderer as Z,
-  parseAparteEventStream as _,
+  estimateTokens as Q,
+  estimateWireTokens as R,
+  filesToAttachments as S,
+  getAllRenderers as T,
+  getSegmentRenderer as U,
+  historyFromCheckpoint as V,
+  installDefaultRenderersOnce as W,
+  installDialogTriggersOnce as X,
+  isAwaitingReply as Y,
+  isFormatAdapter as Z,
+  isSafeUrl as _,
   APARTE_CONVERSATION_SCHEMA_VERSION as a,
-  populateBubbleFromMessage as a0,
-  readableToAsyncIterable as a1,
-  registerDefaultRenderers as a2,
-  registerSegmentRenderer as a3,
-  releaseDeferredHydration as a4,
-  requestUserInput as a5,
-  resolveConfig as a6,
-  revokeAttachmentUrls as a7,
-  runWithConfig as a8,
-  segmentDuration as a9,
-  conversationStatusOf as aA,
-  chatBoundaryOf as aB,
-  rootOf as aC,
-  segmentTiming as aa,
-  subscribeConfigChange as ab,
-  toToolCallView as ac,
-  toolRefusal as ad,
-  unregisterSegmentRenderer as ae,
-  uuid as af,
-  eventOrigin as ag,
-  activeElementIn as ah,
-  gateGlide as ai,
-  toolCallRenderer as aj,
-  toolRendererThatDrew as ak,
-  isMountedRenderer as al,
-  renderingVersionOf as am,
-  onRenderersChange as an,
-  mergeSegmentUpdate as ao,
-  writeStreamedMarkdown as ap,
-  stampSegmentActivity as aq,
-  stampSegmentOnInsert as ar,
-  stampSegmentOnUpdate as as,
-  renumberSegments as at,
-  openSegmentIds as au,
-  isTerminalStatus as av,
-  adoptMessageSegments as aw,
-  APARTE_DERIVED_SEGMENTS as ax,
-  rememberConversationStatus as ay,
-  tellConversationStatus as az,
+  measureContext as a0,
+  overrideSegmentRenderer as a1,
+  parseAparteEventStream as a2,
+  parseMarkdownToSegments as a3,
+  populateBubbleFromMessage as a4,
+  readableToAsyncIterable as a5,
+  registerDefaultRenderers as a6,
+  registerSegmentRenderer as a7,
+  releaseDeferredHydration as a8,
+  requestUserInput as a9,
+  renumberSegments as aA,
+  openSegmentIds as aB,
+  isTerminalStatus as aC,
+  adoptMessageSegments as aD,
+  APARTE_DERIVED_SEGMENTS as aE,
+  rememberConversationStatus as aF,
+  tellConversationStatus as aG,
+  conversationStatusOf as aH,
+  usageTokens as aI,
+  rootOf as aJ,
+  resolveConfig as aa,
+  revokeAttachmentUrls as ab,
+  runWithConfig as ac,
+  segmentDuration as ad,
+  segmentTiming as ae,
+  subscribeConfigChange as af,
+  toToolCallView as ag,
+  toolRefusal as ah,
+  unregisterSegmentRenderer as ai,
+  uuid as aj,
+  eventOrigin as ak,
+  activeElementIn as al,
+  gateGlide as am,
+  chatBoundaryOf as an,
+  toolCallRenderer as ao,
+  toolRendererThatDrew as ap,
+  isMountedRenderer as aq,
+  renderingVersionOf as ar,
+  onRenderersChange as as,
+  mergeSegmentUpdate as at,
+  writeStreamedMarkdown as au,
+  CheckpointStateWatcher as av,
+  chatIdOf as aw,
+  stampSegmentActivity as ax,
+  stampSegmentOnInsert as ay,
+  stampSegmentOnUpdate as az,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
@@ -8821,4 +9254,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=defer-hydration-BwMqeRHq.js.map
+//# sourceMappingURL=defer-hydration-8vI8xNNx.js.map