@aparte/core 0.17.3 → 0.18.0

package/dist/{dialog-triggers-DwTGKWeU.js → dialog-triggers-Dad9V_ag.js}

@@ -1,5 +1,5 @@
+import { unansweredTail, runStreamAgent } from "@aparte/engine";
 import { A as APARTE_ICON_GLYPHS } from "./glyphs-C8z2oJUg.js";
-import { 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("");
@@ -725,40 +725,53 @@ function parseMarkdownToSegments(content, options) {
   const finalSegments = parser.finalize();
   return [...result.segments, ...finalSegments];
 }
-function parseAparteEventStream(stream) {
+async function* readNdjson(stream, signal) {
+  const reader = stream.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
-  let sawDone = false;
+  const parse = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return void 0;
+    try {
+      const value = JSON.parse(trimmed);
+      return value && typeof value.type === "string" ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  try {
+    while (!signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (signal?.aborted) return;
+        const event = parse(line);
+        if (event) yield event;
+      }
+    }
+    if (signal?.aborted) return;
+    const last = parse(buffer + decoder.decode());
+    if (last) yield last;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseAparteEventStream(stream) {
   return new ReadableStream({
     async start(controller) {
-      const reader = stream.getReader();
-      const emit = (line) => {
-        const trimmed = line.trim();
-        if (!trimmed) return;
-        try {
-          const event = JSON.parse(trimmed);
-          if (event && typeof event.type === "string") {
-            controller.enqueue(event);
-            if (event.type === "done") sawDone = true;
-          }
-        } catch {
-        }
-      };
+      let sawDone = false;
       try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          for (const line of lines) emit(line);
+        for await (const event of readNdjson(stream)) {
+          controller.enqueue(event);
+          if (event.type === "done") sawDone = true;
         }
-        if (buffer.trim()) emit(buffer);
         if (!sawDone) controller.enqueue({ type: "done" });
       } catch (err) {
         controller.enqueue({ type: "error", message: err?.message ?? "Stream error" });
       } finally {
-        reader.releaseLock();
         controller.close();
       }
     }
@@ -795,29 +808,29 @@ function createAparteChatHandler(options) {
   return async function handler(req) {
     const verdict = await options.authorize(req);
     if (verdict instanceof Response) return verdict;
-    if (!verdict) return jsonError(401, "Unauthorized.");
+    if (!verdict) return jsonError$1(401, "Unauthorized.");
     let providerId;
     let request;
     try {
       const parsed = await req.json();
       if (typeof parsed?.providerId !== "string" || !parsed?.request || typeof parsed.request !== "object") {
-        return jsonError(400, "Body must be { providerId: string, request: AparteChatRequest }.");
+        return jsonError$1(400, "Body must be { providerId: string, request: AparteChatRequest }.");
       }
       providerId = parsed.providerId;
       request = parsed.request;
     } catch {
-      return jsonError(400, "Invalid JSON body.");
+      return jsonError$1(400, "Invalid JSON body.");
     }
     const adapter = Object.hasOwn(options.providers, providerId) ? options.providers[providerId] : void 0;
     if (!adapter) {
-      return jsonError(400, `Unknown providerId "${providerId}". Register it in the handler's providers map.`);
+      return jsonError$1(400, `Unknown providerId "${providerId}". Register it in the handler's providers map.`);
     }
     if (!isFormatAdapter(adapter)) {
-      return jsonError(500, `Provider "${providerId}" is not a format adapter (needs buildRequest + parseStream).`);
+      return jsonError$1(500, `Provider "${providerId}" is not a format adapter (needs buildRequest + parseStream).`);
     }
     const built = adapter.buildRequest(request);
     if (!built.path.startsWith("/") || built.path.startsWith("//")) {
-      return jsonError(500, `Provider "${providerId}" produced a non-rooted request path.`);
+      return jsonError$1(500, `Provider "${providerId}" produced a non-rooted request path.`);
     }
     const key = await options.resolveKey?.(providerId);
     let url = `${adapter.defaultEndpoint}${built.path}`;
@@ -838,7 +851,7 @@ function createAparteChatHandler(options) {
       });
     } catch (err) {
       console.error("[aparte] vendor request failed", err);
-      return jsonError(502, "Vendor request failed.");
+      return jsonError$1(502, "Vendor request failed.");
     }
     if (!vendor.ok) {
       const raw = await vendor.text().catch(() => "");
@@ -869,10 +882,10 @@ function createAparteChatHandler(options) {
       });
     }
     if (!vendor.body) {
-      return jsonError(502, "Vendor returned no response body for a streaming request.");
+      return jsonError$1(502, "Vendor returned no response body for a streaming request.");
     }
     const events = adapter.parseStream(vendor.body).getReader();
-    const encoder = new TextEncoder();
+    const encoder2 = new TextEncoder();
     const ndjson = new ReadableStream({
       async pull(controller) {
         try {
@@ -881,7 +894,7 @@ function createAparteChatHandler(options) {
             controller.close();
             return;
           }
-          controller.enqueue(encoder.encode(JSON.stringify(value) + "\n"));
+          controller.enqueue(encoder2.encode(JSON.stringify(value) + "\n"));
         } catch (err) {
           controller.error(err);
         }
@@ -893,6 +906,584 @@ function createAparteChatHandler(options) {
     return new Response(ndjson, { headers: { "Content-Type": "application/x-ndjson" } });
   };
 }
+function jsonError$1(status, message) {
+  return new Response(JSON.stringify({ error: { message } }), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+const OPEN_TOOL_STATUSES = /* @__PURE__ */ new Set(["pending", "awaiting-approval"]);
+const ACTIVITY_KEYS = ["content", "output", "result"];
+function isActivity(updates) {
+  return ACTIVITY_KEYS.some((key) => key in updates);
+}
+function stampSegmentOnInsert(segments, segment, messageId, defaults) {
+  const base = applyDefaults(segment, defaults);
+  return {
+    ...base,
+    messageId: segment.messageId ?? messageId,
+    index: segment.index ?? segments.length,
+    // A start already present is kept — a segment a consumer rebuilt from their own
+    // storage keeps the number it was persisted with. `adoptSegment` is the path
+    // that never writes one at all.
+    ...timingPatch(base, { startedAt: segmentTiming(segment)?.startedAt ?? Date.now() })
+  };
+}
+function adoptSegment(segments, segment, messageId, live = false) {
+  return {
+    ...segment,
+    messageId,
+    index: segments.length,
+    isStreaming: false,
+    ...segment.type === "tool_call" && (segment.status === "awaiting-approval" || segment.status === "pending" && !live) && !segment.deferred?.ticket ? { status: "aborted" } : {}
+  };
+}
+const RESERVED = /* @__PURE__ */ new Set(["id", "type", "messageId", "index"]);
+function segmentTiming(segment) {
+  return segment.meta?.aparte;
+}
+function timingPatch(segment, timing) {
+  return { meta: { ...segment.meta, aparte: { ...segment.meta?.aparte, ...timing } } };
+}
+function applyDefaults(segment, defaults) {
+  if (!defaults) return segment;
+  const out = { ...segment };
+  for (const [key, value] of Object.entries(defaults)) {
+    if (RESERVED.has(key) || key in segment) continue;
+    if (key === "meta") {
+      const { aparte: _forged, ...rest } = value ?? {};
+      out.meta = rest;
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function isSegmentSettled(segment) {
+  if (segment.type === "tool_call") return !OPEN_TOOL_STATUSES.has(segment.status);
+  return segment.isStreaming === false;
+}
+function stampSegmentOnUpdate(segment, updates) {
+  if (isSegmentSettled(segment)) return updates;
+  const merged = { ...segment, ...updates };
+  if (isSegmentSettled(merged)) {
+    const ended = segmentTiming(segment)?.endedAt;
+    return { ...updates, ...timingPatch(segment, { endedAt: ended ?? Date.now() }) };
+  }
+  return isActivity(updates) ? { ...updates, ...timingPatch(segment, { endedAt: Date.now() }) } : updates;
+}
+function mergeSegmentUpdate(segment, updates) {
+  const merged = { ...segment, ...updates };
+  if (!("meta" in updates)) return merged;
+  return {
+    ...merged,
+    meta: {
+      ...segment.meta,
+      ...updates.meta,
+      // Neither side's timing wins by accident: whichever one carries it, wins,
+      // and a consumer writing `meta` without an `aparte` key keeps ours.
+      ...segment.meta?.aparte || updates.meta?.aparte ? { aparte: { ...segment.meta?.aparte, ...updates.meta?.aparte } } : {}
+    }
+  };
+}
+function segmentDuration(segment) {
+  const { startedAt, endedAt } = segmentTiming(segment) ?? {};
+  if (startedAt == null || endedAt == null) return void 0;
+  return endedAt - startedAt;
+}
+function stampSegmentActivity(segment) {
+  return isSegmentSettled(segment) ? {} : timingPatch(segment, { endedAt: Date.now() });
+}
+function segmentContentUpdate(segment) {
+  const content = segment.content;
+  return {
+    content,
+    ...segment.isStreaming === false ? { isStreaming: false } : {}
+  };
+}
+function isTerminalStatus(status) {
+  return status != null && status !== "streaming" && status !== "pending";
+}
+function openSegmentIds(segments) {
+  return segments.filter((segment) => !isSegmentSettled(segment)).map((segment) => segment.id);
+}
+function adoptMessageSegments(message) {
+  if (!message.segments?.length) return { ...message };
+  const live = message.status === "streaming" || message.status === "pending";
+  return {
+    ...message,
+    segments: message.segments.reduce((acc, segment) => {
+      acc.push(adoptSegment(acc, segment, message.id, live));
+      return acc;
+    }, [])
+  };
+}
+function renumberSegments(segments) {
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment.index === i) continue;
+    segments[i] = { ...segment, index: i };
+  }
+}
+function dispatchLifecycleEvent(target, name, detail, targetId) {
+  const id = targetId ?? (target.id || void 0);
+  const stamped = detail && typeof detail === "object" ? { targetId: id, ...detail } : detail;
+  target.dispatchEvent(new CustomEvent(name, { bubbles: true, composed: true, detail: stamped }));
+}
+function createStreamAdapter(opts) {
+  const { target, config, messageId, targetId } = opts;
+  let parser = new AparteStreamParser({ blocks: config.getStreamBlocks() });
+  let streaming = /* @__PURE__ */ new Set();
+  let thinkingId = null;
+  const toolSegments = /* @__PURE__ */ new Map();
+  const addedTools = /* @__PURE__ */ new Set();
+  const settle = (toolCallId, update) => {
+    const id = `tool-${toolCallId}`;
+    target.updateSegment?.(id, toolSegments.has(id) ? update : { ...update, deferred: void 0 });
+  };
+  let thinkingContent = "";
+  let thinkingCollapsed = false;
+  return (e) => {
+    switch (e.type) {
+      case "run-start":
+        target.updateMessage?.(messageId, { status: "streaming" });
+        break;
+      case "turn-start":
+        parser = new AparteStreamParser({ blocks: config.getStreamBlocks() });
+        streaming = /* @__PURE__ */ new Set();
+        thinkingId = null;
+        thinkingContent = "";
+        thinkingCollapsed = false;
+        break;
+      case "thinking-delta": {
+        thinkingContent += e.delta;
+        if (!thinkingId) {
+          const seg = {
+            id: `think-${uuid()}`,
+            type: "thinking",
+            content: thinkingContent,
+            collapsed: true,
+            label: "Thinking"
+          };
+          thinkingId = seg.id;
+          streaming.add(seg.id);
+          target.addSegment?.(seg);
+        } else {
+          target.updateSegment?.(thinkingId, { content: thinkingContent });
+        }
+        break;
+      }
+      case "text-delta": {
+        if (thinkingId && !thinkingCollapsed) {
+          target.updateSegment?.(thinkingId, { collapsed: true, isStreaming: false });
+          thinkingCollapsed = true;
+        }
+        const result = parser.parse(e.delta);
+        for (const segment of result.segments) {
+          if (!streaming.has(segment.id)) {
+            target.addSegment?.(segment);
+            streaming.add(segment.id);
+          } else if ("content" in segment) {
+            target.updateSegment?.(segment.id, segmentContentUpdate(segment));
+          }
+        }
+        const active = parser.getState().activeSegment;
+        if (active) {
+          if (!streaming.has(active.id)) {
+            target.addSegment?.(active);
+            streaming.add(active.id);
+          } else {
+            target.updateSegment?.(active.id, segmentContentUpdate(active));
+          }
+        } else if (result.segments.length === 0) ;
+        break;
+      }
+      case "text-flush": {
+        const finals = parser.finalize();
+        for (const s of finals) {
+          if (!streaming.has(s.id)) target.addSegment?.(s);
+          else if ("content" in s) target.updateSegment?.(s.id, segmentContentUpdate(s));
+        }
+        break;
+      }
+      case "tool-start": {
+        const toolSeg = {
+          id: `tool-${e.toolCallId}`,
+          type: "tool_call",
+          toolCall: { id: e.toolCallId, name: e.name, input: e.input },
+          status: "pending"
+        };
+        toolSegments.set(toolSeg.id, toolSeg);
+        const renderer = config.getToolRenderer(e.name);
+        if (renderer) {
+          injectToolRendererStyles(e.name, renderer);
+          const html = renderer.render(toolSeg);
+          if (html) {
+            target.addSegment?.(toolSeg);
+            addedTools.add(toolSeg.id);
+          }
+        } else {
+          target.addSegment?.(toolSeg);
+          addedTools.add(toolSeg.id);
+        }
+        break;
+      }
+      case "tool-awaiting-approval":
+        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "awaiting-approval" });
+        dispatchLifecycleEvent(target, "aparte-tool-approval-request", { toolCallId: e.toolCallId, toolName: e.name, input: e.input }, targetId);
+        break;
+      case "tool-approved":
+        settle(e.toolCallId, { status: "pending" });
+        break;
+      case "tool-rejected":
+        settle(e.toolCallId, { status: "rejected", result: e.reason });
+        break;
+      case "tool-resolved":
+        settle(e.toolCallId, {
+          status: "resolved",
+          result: e.result,
+          ...e.structuredResult !== void 0 ? { structuredResult: e.structuredResult } : {}
+        });
+        break;
+      case "tool-aborted":
+        settle(e.toolCallId, { status: "aborted" });
+        break;
+      case "tool-failed":
+        settle(e.toolCallId, { status: "failed", result: e.error });
+        break;
+      case "turn-limit-exceeded":
+        if (e.scope === "global") {
+          target.addSegment?.({
+            id: `max-turns-${uuid()}`,
+            type: "error",
+            content: `Stopped after ${e.limit} tool calls to prevent an infinite loop.`,
+            details: "MAX_TURNS_EXCEEDED"
+          });
+        } else if (e.toolCallId) {
+          settle(e.toolCallId, { status: "aborted" });
+        }
+        break;
+      case "run-aborted":
+        dispatchLifecycleEvent(target, "aparte-message-aborted", { messageId }, targetId);
+        break;
+      case "run-suspended": {
+        const ticket = e.ticket;
+        for (const p of e.pending) {
+          const id = `tool-${p.toolCallId}`;
+          const deferred = { reason: p.reason, ...typeof ticket === "string" ? { ticket } : {} };
+          if (addedTools.has(id) || !toolSegments.has(id)) {
+            target.updateSegment?.(id, { deferred });
+          } else {
+            const seg = toolSegments.get(id);
+            if (seg) {
+              target.addSegment?.({ ...seg, deferred });
+              addedTools.add(id);
+            }
+          }
+        }
+        target.updateMessage?.(messageId, { status: "completed" });
+        if (e.usage) {
+          try {
+            target.setUsage?.(messageId, e.usage);
+          } catch {
+          }
+        }
+        dispatchLifecycleEvent(target, "aparte-message-paused", { messageId }, targetId);
+        break;
+      }
+      case "run-done":
+        target.updateMessage?.(messageId, { status: "completed" });
+        if (e.usage) {
+          try {
+            target.setUsage?.(messageId, e.usage);
+          } catch {
+          }
+        }
+        break;
+    }
+  };
+}
+function readableToAsyncIterable(stream, signal) {
+  return {
+    [Symbol.asyncIterator]() {
+      const reader = stream.getReader();
+      const onAbort = () => {
+        try {
+          reader.cancel().catch(() => {
+          });
+        } catch {
+        }
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+      return {
+        async next() {
+          const { done, value } = await reader.read();
+          if (done) return { done: true, value: void 0 };
+          return { done: false, value };
+        },
+        async return() {
+          signal.removeEventListener("abort", onAbort);
+          try {
+            await reader.cancel();
+          } catch {
+          }
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+}
+const encoder = new TextEncoder();
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map((v) => canonicalJson(v === void 0 ? null : v)).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value ?? null);
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(text) {
+  if (!/^[A-Za-z0-9_-]*$/.test(text)) throw new Error("not base64url");
+  const binary = atob(text.replace(/-/g, "+").replace(/_/g, "/"));
+  return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+function hmacKey(secret, subtle) {
+  return subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+}
+async function signTicket(payload, secret, subtle) {
+  const body = encoder.encode(canonicalJson(payload));
+  const signature = new Uint8Array(await subtle.sign("HMAC", await hmacKey(secret, subtle), body));
+  return `${toBase64Url(body)}.${toBase64Url(signature)}`;
+}
+async function verifyTicket(ticket, secrets, subtle, maxAgeMs, now = Date.now()) {
+  const parts = ticket.split(".");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+  let body;
+  let signature;
+  try {
+    body = fromBase64Url(parts[0]);
+    signature = fromBase64Url(parts[1]);
+  } catch {
+    return null;
+  }
+  let valid = false;
+  for (const secret of secrets) {
+    if (await subtle.verify("HMAC", await hmacKey(secret, subtle), signature, body)) {
+      valid = true;
+      break;
+    }
+  }
+  if (!valid) return null;
+  let payload;
+  try {
+    payload = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    return null;
+  }
+  if (payload?.v !== 1 || typeof payload.iat !== "number" || typeof payload.messageId !== "string" || !Array.isArray(payload.calls)) {
+    return null;
+  }
+  if (now - payload.iat > maxAgeMs) return null;
+  return payload;
+}
+function sameCalls(a, b) {
+  return a.length === b.length && a.every((call, i) => {
+    const other = b[i];
+    return call.id === other.id && call.name === other.name && canonicalJson(call.input) === canonicalJson(other.input);
+  });
+}
+const DEFAULT_TICKET_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function createAparteAgentHandler(options) {
+  const secrets = typeof options.secret === "string" ? [options.secret] : [...options.secret];
+  if (secrets.length === 0 || secrets.some((s) => typeof s !== "string" || s.length < 32)) {
+    throw new Error("createAparteAgentHandler: `secret` must be at least 32 characters — it signs the pending tool calls of a suspended run.");
+  }
+  const tools = new Map((options.tools ?? []).map((t) => [t.tool.name, t]));
+  const transport = options.transport ?? new AparteDirectTransport({ byok: true });
+  const maxAge = options.ticketMaxAgeMs ?? DEFAULT_TICKET_MAX_AGE_MS;
+  return async function handler(req) {
+    const verdict = await options.authorize(req);
+    if (verdict instanceof Response) return verdict;
+    if (!verdict) return jsonError(401, "Unauthorized.");
+    const subtle = options.crypto ?? globalThis.crypto?.subtle;
+    if (!subtle) {
+      return jsonError(500, "No Web Crypto here: pass `crypto` (on Node 18, the `webcrypto.subtle` of the built-in crypto module).");
+    }
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return jsonError(400, "Invalid JSON body.");
+    }
+    if (body?.v !== 1) return jsonError(400, "Unsupported agent wire version: expected v 1.");
+    if (typeof body.providerId !== "string" || typeof body.messageId !== "string" || !Array.isArray(body.request?.messages)) {
+      return jsonError(400, "Body must be { v: 1, providerId, messageId, request: { messages } }.");
+    }
+    if (body.request.toolChoice && typeof body.request.toolChoice === "object") {
+      return jsonError(400, "A forced tool call cannot come from the browser.");
+    }
+    const provider = Object.hasOwn(options.providers, body.providerId) ? options.providers[body.providerId] : void 0;
+    if (!provider) {
+      return jsonError(400, `Unknown providerId "${body.providerId}". Register it in the handler's providers map.`);
+    }
+    const clientTools = Array.isArray(body.clientTools) ? body.clientTools : [];
+    for (const t of clientTools) {
+      if (typeof t?.name !== "string") return jsonError(400, "A browser tool needs a name.");
+      if (options.clientTools === false) return jsonError(400, "This endpoint accepts no browser tools.");
+      if (tools.has(t.name)) return jsonError(400, `Browser tool "${t.name}" has the name of a server tool.`);
+      if (Array.isArray(options.clientTools) && !options.clientTools.includes(t.name)) {
+        return jsonError(400, `Browser tool "${t.name}" is not allowed here.`);
+      }
+    }
+    let request = {
+      ...body.request,
+      tools: [...[...tools.values()].map((t) => t.tool), ...clientTools]
+    };
+    if (options.prepareRequest) request = await options.prepareRequest(request, req);
+    const tail = unansweredTail(request.messages);
+    if (!body.resume && tail.length > 0) {
+      return jsonError(400, "The history ends on unanswered tool calls: a resume needs its ticket.");
+    }
+    let outcomes = {};
+    if (body.resume) {
+      const payload = typeof body.resume.ticket === "string" ? await verifyTicket(body.resume.ticket, secrets, subtle, maxAge) : null;
+      if (!payload || payload.messageId !== body.messageId) {
+        return jsonError(400, "Invalid or expired continuation ticket.");
+      }
+      if (!sameCalls(payload.calls, tail.map((c) => ({ id: c.id, name: c.name, input: c.input })))) {
+        return jsonError(400, "The pending tool calls do not match the ticket.");
+      }
+      const ids = new Set(payload.calls.map((c) => c.id));
+      const given = body.resume.outcomes && typeof body.resume.outcomes === "object" ? body.resume.outcomes : {};
+      for (const id of Object.keys(given)) {
+        if (!ids.has(id)) return jsonError(400, `No pending call "${id}" in the ticket.`);
+      }
+      if (options.onTicket && !await options.onTicket(body.resume.ticket.split(".")[1])) {
+        return jsonError(409, "This continuation ticket was already used.");
+      }
+      outcomes = withoutUnacceptedPayloads(given, payload.calls, tools);
+    }
+    const key = await options.resolveKey?.(body.providerId);
+    const external = new Set(clientTools.map((t) => t.name));
+    const rule = (call) => options.approvalPolicy?.(call, tools.get(call.name)?.tool);
+    const run = new AbortController();
+    if (req.signal.aborted) run.abort();
+    else req.signal.addEventListener("abort", () => run.abort(), { once: true });
+    const encoder2 = new TextEncoder();
+    let pendingWrite;
+    const stream = new ReadableStream({
+      start(controller) {
+        let open = true;
+        const write = (line) => {
+          if (!open) return;
+          try {
+            controller.enqueue(encoder2.encode(JSON.stringify(line) + "\n"));
+          } catch {
+            open = false;
+          }
+        };
+        const close = () => {
+          if (!open) return;
+          open = false;
+          try {
+            controller.close();
+          } catch {
+          }
+        };
+        const emitter = (event) => {
+          if (event.type === "tool-failed") {
+            console.error(`[aparte] tool call ${event.toolCallId} failed:`, event.error);
+            write({ ...event, error: "The tool failed." });
+            return;
+          }
+          if (event.type !== "run-suspended") {
+            write(event);
+            return;
+          }
+          const calls = event.pending.map((p) => ({ id: p.toolCallId, name: p.name, input: p.input }));
+          pendingWrite = signTicket({ v: 1, iat: Date.now(), messageId: body.messageId, calls }, secrets[0], subtle).then((ticket) => write({ ...event, ticket }));
+        };
+        void runStreamAgent({
+          messageId: body.messageId,
+          providerId: body.providerId,
+          baseRequest: request,
+          transportCall: async (r) => {
+            const response = await transport.chat(provider, r, key, { providerId: body.providerId, signal: run.signal });
+            return typeof response === "string" ? response : readableToAsyncIterable(response, run.signal);
+          },
+          toolLookup: (name) => {
+            const t = tools.get(name);
+            return t ? (call, signal) => t.handler(call, signal, { request: req }) : void 0;
+          },
+          toolConfigLookup: (name) => {
+            if (external.has(name)) return { external: true };
+            const t = tools.get(name);
+            if (!t) return void 0;
+            return {
+              ...t.tool.maxTurns !== void 0 ? { maxTurns: t.tool.maxTurns } : {},
+              needsApproval: (call) => {
+                const ruling = rule(call);
+                if (ruling?.verdict === "allow") return false;
+                if (ruling?.verdict) return ruling.verdict;
+                return Boolean(t.tool.needsApproval);
+              }
+            };
+          },
+          // Reached only for a server `deny`: an `ask` is deferred to the page.
+          approvalResolver: async (call) => ({
+            approved: false,
+            reason: rule(call)?.reason?.trim() || "Tool execution was refused by the server policy."
+          }),
+          deferral: { outcomes },
+          emitter,
+          signal: run.signal,
+          ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+          ...options.toolTimeoutMs !== void 0 ? { toolTimeoutMs: options.toolTimeoutMs } : {}
+        }).then(async () => {
+          await pendingWrite;
+          close();
+        }, async (error) => {
+          console.error("[aparte] agent run failed", error);
+          await pendingWrite?.catch(() => {
+          });
+          write({
+            type: "run-error",
+            message: "The agent run failed.",
+            code: error instanceof AparteError ? error.code : "AGENT_RUN_FAILED"
+          });
+          close();
+        });
+      },
+      cancel() {
+        run.abort();
+      }
+    });
+    return new Response(stream, { headers: { "Content-Type": "application/x-ndjson" } });
+  };
+}
+function withoutUnacceptedPayloads(outcomes, calls, tools) {
+  const out = {};
+  for (const [id, outcome] of Object.entries(outcomes)) {
+    const name = calls.find((c) => c.id === id)?.name;
+    if (outcome?.kind === "decision" && outcome.payload !== void 0 && !(name && tools.get(name)?.acceptsApprovalPayload)) {
+      const { payload: _dropped, ...rest } = outcome;
+      out[id] = rest;
+    } else {
+      out[id] = outcome;
+    }
+  }
+  return out;
+}
 function jsonError(status, message) {
   return new Response(JSON.stringify({ error: { message } }), {
     status,
@@ -3135,118 +3726,6 @@ const DEFAULT_RENDERERS = [
   errorRenderer,
   toolCallRenderer
 ];
-const OPEN_TOOL_STATUSES = /* @__PURE__ */ new Set(["pending", "awaiting-approval"]);
-const ACTIVITY_KEYS = ["content", "output", "result"];
-function isActivity(updates) {
-  return ACTIVITY_KEYS.some((key) => key in updates);
-}
-function stampSegmentOnInsert(segments, segment, messageId, defaults) {
-  const base = applyDefaults(segment, defaults);
-  return {
-    ...base,
-    messageId: segment.messageId ?? messageId,
-    index: segment.index ?? segments.length,
-    // A start already present is kept — a segment a consumer rebuilt from their own
-    // storage keeps the number it was persisted with. `adoptSegment` is the path
-    // that never writes one at all.
-    ...timingPatch(base, { startedAt: segmentTiming(segment)?.startedAt ?? Date.now() })
-  };
-}
-function adoptSegment(segments, segment, messageId) {
-  return {
-    ...segment,
-    messageId,
-    index: segments.length,
-    isStreaming: false,
-    ...segment.type === "tool_call" && segment.status === "awaiting-approval" ? { status: "aborted" } : {}
-  };
-}
-const RESERVED = /* @__PURE__ */ new Set(["id", "type", "messageId", "index"]);
-function segmentTiming(segment) {
-  return segment.meta?.aparte;
-}
-function timingPatch(segment, timing) {
-  return { meta: { ...segment.meta, aparte: { ...segment.meta?.aparte, ...timing } } };
-}
-function applyDefaults(segment, defaults) {
-  if (!defaults) return segment;
-  const out = { ...segment };
-  for (const [key, value] of Object.entries(defaults)) {
-    if (RESERVED.has(key) || key in segment) continue;
-    if (key === "meta") {
-      const { aparte: _forged, ...rest } = value ?? {};
-      out.meta = rest;
-      continue;
-    }
-    out[key] = value;
-  }
-  return out;
-}
-function isSegmentSettled(segment) {
-  if (segment.type === "tool_call") return !OPEN_TOOL_STATUSES.has(segment.status);
-  return segment.isStreaming === false;
-}
-function stampSegmentOnUpdate(segment, updates) {
-  if (isSegmentSettled(segment)) return updates;
-  const merged = { ...segment, ...updates };
-  if (isSegmentSettled(merged)) {
-    const ended = segmentTiming(segment)?.endedAt;
-    return { ...updates, ...timingPatch(segment, { endedAt: ended ?? Date.now() }) };
-  }
-  return isActivity(updates) ? { ...updates, ...timingPatch(segment, { endedAt: Date.now() }) } : updates;
-}
-function mergeSegmentUpdate(segment, updates) {
-  const merged = { ...segment, ...updates };
-  if (!("meta" in updates)) return merged;
-  return {
-    ...merged,
-    meta: {
-      ...segment.meta,
-      ...updates.meta,
-      // Neither side's timing wins by accident: whichever one carries it, wins,
-      // and a consumer writing `meta` without an `aparte` key keeps ours.
-      ...segment.meta?.aparte || updates.meta?.aparte ? { aparte: { ...segment.meta?.aparte, ...updates.meta?.aparte } } : {}
-    }
-  };
-}
-function segmentDuration(segment) {
-  const { startedAt, endedAt } = segmentTiming(segment) ?? {};
-  if (startedAt == null || endedAt == null) return void 0;
-  return endedAt - startedAt;
-}
-function stampSegmentActivity(segment) {
-  return isSegmentSettled(segment) ? {} : timingPatch(segment, { endedAt: Date.now() });
-}
-function segmentContentUpdate(segment) {
-  const content = segment.content;
-  return {
-    content,
-    ...segment.isStreaming === false ? { isStreaming: false } : {}
-  };
-}
-function isTerminalStatus(status) {
-  return status != null && status !== "streaming" && status !== "pending";
-}
-function openSegmentIds(segments) {
-  return segments.filter((segment) => !isSegmentSettled(segment)).map((segment) => segment.id);
-}
-function adoptMessageSegments(message) {
-  if (!message.segments?.length) return { ...message };
-  return {
-    ...message,
-    segments: message.segments.reduce((acc, segment) => {
-      acc.push(adoptSegment(acc, segment, message.id));
-      return acc;
-    }, [])
-  };
-}
-function renumberSegments(segments) {
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i];
-    if (segment.index === i) continue;
-    segments[i] = { ...segment, index: i };
-  }
-}
 function populateBubbleFromMessage(bubble, message, siblingInfo) {
   if (message.segments && message.segments.length > 0) {
     const existing = bubble.getSegments?.() ?? [];
@@ -3740,6 +4219,7 @@ class AparteConversationController {
   _onMessageDone = null;
   _onMessageError = null;
   _onMessageAborted = null;
+  _onMessagePaused = null;
   _onSelectConversation = null;
   _unsubscribeManager = null;
   /** The manager the subscription above is on, so a replaced manager is re-subscribed. */
@@ -3864,10 +4344,14 @@ class AparteConversationController {
       this._isStreaming = false;
       queueMicrotask(() => this._persistActive());
     };
+    this._onMessagePaused = () => {
+      queueMicrotask(() => this._persistActive());
+    };
     host.addEventListener("aparte-message-start", this._onMessageStart);
     host.addEventListener("aparte-message-done", this._onMessageDone);
     host.addEventListener("aparte-message-error", this._onMessageError);
     host.addEventListener("aparte-message-aborted", this._onMessageAborted);
+    host.addEventListener("aparte-message-paused", this._onMessagePaused);
     this._onSelectConversation = (e) => {
       const evt = e;
       const targetId = evt.detail?.targetId;
@@ -3915,6 +4399,10 @@ class AparteConversationController {
       host.removeEventListener("aparte-message-aborted", this._onMessageAborted);
       this._onMessageAborted = null;
     }
+    if (this._onMessagePaused) {
+      host.removeEventListener("aparte-message-paused", this._onMessagePaused);
+      this._onMessagePaused = null;
+    }
     if (this._onSelectConversation && typeof window !== "undefined") {
       window.removeEventListener("aparte-conversation-select", this._onSelectConversation);
       this._onSelectConversation = null;
@@ -4028,6 +4516,11 @@ class AparteConversationController {
       this._isLoadingConversation = false;
       this._showWait(false);
     }
+    this._binding.host.dispatchEvent(new CustomEvent("aparte-conversation-loaded", {
+      bubbles: true,
+      composed: true,
+      detail: { targetId: this._binding.hostId, conversationId: id }
+    }));
   }
   /**
    * The binding's wait, owned here: whoever runs `setConversationId` last clears it
@@ -4812,181 +5305,55 @@ class AparteChatHost {
     });
   }
 }
-function dispatchLifecycleEvent(target, name, detail, targetId) {
-  const id = targetId ?? (target.id || void 0);
-  const stamped = detail && typeof detail === "object" ? { targetId: id, ...detail } : detail;
-  target.dispatchEvent(new CustomEvent(name, { bubbles: true, composed: true, detail: stamped }));
+const STOPPED_TOOL_TEXT = "The tool call was stopped before it ran.";
+const EMPTY_TOOL_TEXT = "The tool returned no output.";
+function answerOf(segment) {
+  const result = segment.result?.trim();
+  if (segment.status === "resolved") return result || EMPTY_TOOL_TEXT;
+  if (segment.status === "failed") return result || "The tool failed.";
+  if (segment.status === "rejected") return result || STOPPED_TOOL_TEXT;
+  return STOPPED_TOOL_TEXT;
 }
-function createStreamAdapter(opts) {
-  const { target, config, messageId, targetId } = opts;
-  let parser = new AparteStreamParser({ blocks: config.getStreamBlocks() });
-  let streaming = /* @__PURE__ */ new Set();
-  let thinkingId = null;
-  let thinkingContent = "";
-  let thinkingCollapsed = false;
-  return (e) => {
-    switch (e.type) {
-      case "run-start":
-        target.updateMessage?.(messageId, { status: "streaming" });
-        break;
-      case "turn-start":
-        parser = new AparteStreamParser({ blocks: config.getStreamBlocks() });
-        streaming = /* @__PURE__ */ new Set();
-        thinkingId = null;
-        thinkingContent = "";
-        thinkingCollapsed = false;
-        break;
-      case "thinking-delta": {
-        thinkingContent += e.delta;
-        if (!thinkingId) {
-          const seg = {
-            id: `think-${uuid()}`,
-            type: "thinking",
-            content: thinkingContent,
-            collapsed: true,
-            label: "Thinking"
-          };
-          thinkingId = seg.id;
-          streaming.add(seg.id);
-          target.addSegment?.(seg);
-        } else {
-          target.updateSegment?.(thinkingId, { content: thinkingContent });
-        }
-        break;
-      }
-      case "text-delta": {
-        if (thinkingId && !thinkingCollapsed) {
-          target.updateSegment?.(thinkingId, { collapsed: true, isStreaming: false });
-          thinkingCollapsed = true;
-        }
-        const result = parser.parse(e.delta);
-        for (const segment of result.segments) {
-          if (!streaming.has(segment.id)) {
-            target.addSegment?.(segment);
-            streaming.add(segment.id);
-          } else if ("content" in segment) {
-            target.updateSegment?.(segment.id, segmentContentUpdate(segment));
-          }
-        }
-        const active = parser.getState().activeSegment;
-        if (active) {
-          if (!streaming.has(active.id)) {
-            target.addSegment?.(active);
-            streaming.add(active.id);
-          } else {
-            target.updateSegment?.(active.id, segmentContentUpdate(active));
-          }
-        } else if (result.segments.length === 0) ;
-        break;
-      }
-      case "text-flush": {
-        const finals = parser.finalize();
-        for (const s of finals) {
-          if (!streaming.has(s.id)) target.addSegment?.(s);
-          else if ("content" in s) target.updateSegment?.(s.id, segmentContentUpdate(s));
-        }
-        break;
-      }
-      case "tool-start": {
-        const toolSeg = {
-          id: `tool-${e.toolCallId}`,
-          type: "tool_call",
-          toolCall: { id: e.toolCallId, name: e.name, input: e.input },
-          status: "pending"
-        };
-        const renderer = config.getToolRenderer(e.name);
-        if (renderer) {
-          injectToolRendererStyles(e.name, renderer);
-          const html = renderer.render(toolSeg);
-          if (html) target.addSegment?.(toolSeg);
-        } else {
-          target.addSegment?.(toolSeg);
-        }
-        break;
+const isOpenDeferred = (segment) => segment.type === "tool_call" && Boolean(segment.deferred) && (segment.status === "awaiting-approval" || segment.status === "pending");
+function wireTurns(message, textOf, options = {}) {
+  const segments = message.segments ?? [];
+  if (message.role !== "assistant" || !segments.some((s) => s.type === "tool_call")) {
+    const content = textOf(segments) || (typeof message.content === "string" ? message.content : "");
+    return content ? [{ role: message.role, content }] : [];
+  }
+  const out = [];
+  let texts = [];
+  let calls = [];
+  const flush = () => {
+    const content = textOf(texts);
+    if (calls.length === 0) {
+      if (content) out.push({ role: "assistant", content });
+    } else {
+      out.push({
+        role: "assistant",
+        content,
+        toolCalls: calls.map((c) => ({ id: c.toolCall.id, name: c.toolCall.name, input: c.toolCall.input }))
+      });
+      for (const c of calls) {
+        if (options.openDeferred && isOpenDeferred(c)) continue;
+        out.push({ role: "tool", content: answerOf(c), toolCallId: c.toolCall.id, toolName: c.toolCall.name });
       }
-      case "tool-awaiting-approval":
-        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "awaiting-approval" });
-        dispatchLifecycleEvent(target, "aparte-tool-approval-request", { toolCallId: e.toolCallId, toolName: e.name, input: e.input }, targetId);
-        break;
-      case "tool-approved":
-        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "pending" });
-        break;
-      case "tool-rejected":
-        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "rejected", result: e.reason });
-        break;
-      case "tool-resolved":
-        target.updateSegment?.(`tool-${e.toolCallId}`, {
-          status: "resolved",
-          result: e.result,
-          ...e.structuredResult !== void 0 ? { structuredResult: e.structuredResult } : {}
-        });
-        break;
-      case "tool-aborted":
-        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "aborted" });
-        break;
-      case "tool-failed":
-        target.updateSegment?.(`tool-${e.toolCallId}`, { status: "failed", result: e.error });
-        break;
-      case "turn-limit-exceeded":
-        if (e.scope === "global") {
-          target.addSegment?.({
-            id: `max-turns-${uuid()}`,
-            type: "error",
-            content: `Stopped after ${e.limit} tool calls to prevent an infinite loop.`,
-            details: "MAX_TURNS_EXCEEDED"
-          });
-        } else if (e.toolCallId) {
-          target.updateSegment?.(`tool-${e.toolCallId}`, { status: "aborted" });
-        }
-        break;
-      case "run-aborted":
-        dispatchLifecycleEvent(target, "aparte-message-aborted", { messageId }, targetId);
-        break;
-      case "run-done":
-        target.updateMessage?.(messageId, { status: "completed" });
-        if (e.usage) {
-          try {
-            target.setUsage?.(messageId, e.usage);
-          } catch {
-          }
-        }
-        break;
     }
+    texts = [];
+    calls = [];
   };
-}
-function readableToAsyncIterable(stream, signal) {
-  return {
-    [Symbol.asyncIterator]() {
-      const reader = stream.getReader();
-      const onAbort = () => {
-        try {
-          void reader.cancel();
-        } catch {
-        }
-      };
-      if (signal.aborted) onAbort();
-      else signal.addEventListener("abort", onAbort, { once: true });
-      return {
-        async next() {
-          const { done, value } = await reader.read();
-          if (done) return { done: true, value: void 0 };
-          return { done: false, value };
-        },
-        async return() {
-          signal.removeEventListener("abort", onAbort);
-          try {
-            await reader.cancel();
-          } catch {
-          }
-          try {
-            reader.releaseLock();
-          } catch {
-          }
-          return { done: true, value: void 0 };
-        }
-      };
+  let open = false;
+  for (const segment of segments) {
+    if (segment.type === "tool_call") {
+      calls.push(segment);
+      if (options.openDeferred && isOpenDeferred(segment)) open = true;
+    } else {
+      if (calls.length > 0 && !open) flush();
+      texts.push(segment);
     }
-  };
+  }
+  flush();
+  return out;
 }
 function eventOrigin(e) {
   return e.composedPath?.()[0] ?? e.target;
@@ -5523,6 +5890,7 @@ const CHAT_SELECTOR = "aparte-chat, aparte-chat-viewport, [data-aparte-chat]";
 class AparteClient {
   _boundHandler = null;
   _boundAbortHandler = null;
+  _boundLoadedHandler = null;
   _boundRetryHandler = null;
   _boundEditHandler = null;
   _releaseKeyResolver = null;
@@ -5650,6 +6018,14 @@ class AparteClient {
       };
     }
     window.addEventListener("aparte-edit", this._boundEditHandler);
+    if (!this._boundLoadedHandler) {
+      this._boundLoadedHandler = (e) => {
+        if (!this._isForThisInstance(e)) return;
+        const host = e.target instanceof HTMLElement ? e.target : void 0;
+        void this.resumeDeferred(host ?? e.detail?.targetId);
+      };
+    }
+    window.addEventListener("aparte-conversation-loaded", this._boundLoadedHandler);
   }
   /**
    * Stop listening.
@@ -5665,6 +6041,10 @@ class AparteClient {
       window.removeEventListener("aparte-abort", this._boundAbortHandler);
       this._boundAbortHandler = null;
     }
+    if (this._boundLoadedHandler) {
+      window.removeEventListener("aparte-conversation-loaded", this._boundLoadedHandler);
+      this._boundLoadedHandler = null;
+    }
     if (this._boundRetryHandler) {
       window.removeEventListener("aparte-retry", this._boundRetryHandler);
       this._boundRetryHandler = null;
@@ -5800,14 +6180,54 @@ class AparteClient {
     }
     dispatchLifecycleEvent(targetElement, "aparte-message-start", { messageId, role: "assistant" }, chatId);
     const streamController = new AbortController();
+    if (this._streamController !== streamController) this._streamController?.abort();
+    this._streamController = streamController;
     try {
-      const usage = await this._streamLoop(targetElement, messageId, provider, baseRequest, authConfig, streamController);
+      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;
+      while (result.suspended) {
+        const stopped = this._isAborted || streamController.signal.aborted;
+        if (!stopped && ++resumes > maxResumes) {
+          this._closeOpenCalls(targetElement, messageId);
+          createStreamAdapter({ target: targetElement, config: this._config, messageId, ...chatId ? { targetId: chatId } : {} })(
+            { type: "turn-limit-exceeded", scope: "global", limit: maxResumes }
+          );
+          break;
+        }
+        const outcomes = stopped ? void 0 : await this._answerDeferred(targetElement, result.suspended.pending, streamController.signal);
+        if (!outcomes) {
+          this._closeOpenCalls(targetElement, messageId);
+          if (this._isAborted || streamController.signal.aborted) {
+            dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
+          }
+          break;
+        }
+        const deferral = {
+          outcomes,
+          ...result.suspended.ticket ? { token: result.suspended.ticket } : {}
+        };
+        const messages2 = this._resumeMessages(targetElement, messageId, baseRequest.messages);
+        this._spendPause(targetElement, messageId);
+        result = await this._streamLoop(
+          targetElement,
+          messageId,
+          provider,
+          { ...baseRequest, messages: messages2 },
+          authConfig,
+          streamController,
+          deferral
+        );
+      }
+      const usage = result.usage;
       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);
       }
     } 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" });
@@ -6110,10 +6530,13 @@ class AparteClient {
     return messages.filter((m) => {
       if (m.role !== "user" && m.role !== "assistant") return false;
       return m.status !== "error" && !AparteClient._inFlight(m);
-    }).map((m) => ({
-      role: m.role,
-      content: this._wireText(m)
-    })).filter((m) => m.content.length > 0);
+    }).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 }] : [];
+    });
   }
   /** The "no model selected" warning is said once per client, not once per dropped send. */
   _warnedNoModel = false;
@@ -6157,6 +6580,7 @@ class AparteClient {
       console.warn("[AparteClient] ⚠️ No target element found with appendMessage support. Provide a targetResolver in AparteClientOptions or ensure the composer has a `target` attribute.");
       return;
     }
+    this._closeDeferred(targetElement);
     if (this.options.echoUserMessage !== false && event.detail?.echoed !== true) {
       const echoFiles = Array.isArray(event.detail?.files) ? event.detail.files : [];
       targetElement.appendMessage?.({
@@ -6319,8 +6743,8 @@ ${text}` : text;
    *
    * `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 was already carried, within the turn, as the assistant's calls and the
-   * `tool` messages answering them.
+   * 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 "";
@@ -6424,11 +6848,12 @@ ${content}
    * 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, streamController = new AbortController()) {
-    this._streamController?.abort();
+  /** One run of the loop: its usage, and whether it paused (a server loop). */
+  async _streamLoop(targetElement, messageId, provider, baseRequest, authConfig, streamController = new AbortController(), deferral) {
+    if (this._streamController !== streamController) this._streamController?.abort();
     this._streamController = streamController;
     const runner = this.options.streamRunner ?? runStreamAgent;
-    return this._runViaStreamRunner(runner, targetElement, messageId, provider, baseRequest, authConfig, streamController);
+    return this._runViaStreamRunner(runner, targetElement, messageId, provider, baseRequest, authConfig, streamController, deferral);
   }
   /**
    * Run the loop through a {@link AparteStreamRunner} — the engine's by default —
@@ -6439,7 +6864,7 @@ ${content}
    * 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) {
+  async _runViaStreamRunner(streamRunner, targetElement, messageId, provider, baseRequest, authConfig, streamController, deferral) {
     const signal = streamController.signal;
     const chatId = this._targetIdOf(targetElement);
     const adapter = createStreamAdapter({
@@ -6449,9 +6874,14 @@ ${content}
       ...chatId ? { targetId: chatId } : {}
     });
     const prefixSegments = baseRequest._meta?.["prefixSegments"];
+    let suspended;
     const emitter = (event) => {
       adapter(event);
-      if (event.type === "run-start" && prefixSegments?.length) {
+      if (event.type === "run-suspended") {
+        const ticket = event.ticket;
+        suspended = { pending: event.pending, ...typeof ticket === "string" ? { ticket } : {} };
+      }
+      if (event.type === "run-start" && prefixSegments?.length && !deferral) {
         for (const seg of prefixSegments) targetElement.addSegment?.(seg);
       }
     };
@@ -6477,16 +6907,11 @@ ${content}
         }
       };
     };
-    const approvalResolver = this.options.approvalResolver ?? (async (call, sig) => {
-      const ruling = this._config.ruleOnToolCall(call);
-      if (ruling.verdict === "allow") return { approved: true };
-      if (ruling.verdict === "deny") {
-        return { approved: false, reason: ruling.reason?.trim() || "Tool execution was refused by the approval policy." };
-      }
-      return this._askForApproval(call, sig, targetElement);
-    });
+    const approvalResolver = this._approvalResolverFor(targetElement);
     const usage = await streamRunner({
       messageId,
+      providerId: provider.id,
+      ...deferral ? { deferral } : {},
       baseRequest,
       transportCall,
       toolLookup,
@@ -6504,8 +6929,196 @@ ${content}
       // BARE uuid for the synthetic tool (the adapter renders `tool-<id>`).
       idGen: (prefix) => prefix === "synthetic-tool" ? uuid() : `${prefix}-${uuid()}`
     });
-    return usage ?? void 0;
+    return { usage: usage ?? void 0, ...suspended ? { suspended } : {} };
+  }
+  /**
+   * The approval channel a run asks through — and the one a paused server run's calls
+   * are answered through, so the page asks the same way whichever loop paused.
+   *
+   * `gatedElsewhere`: a server already decided this call needs a person. The page's
+   * policy may still answer it when it has an opinion (`auto` mode allows, a plan
+   * refuses), but with none the person is asked. `ruleOnToolCall`'s own fallback —
+   * the tool's `needsApproval` — reads a tool the page does not have, and said
+   * "allow": the page approved, silently, what the server wanted a person to decide.
+   */
+  _approvalResolverFor(targetElement, gatedElsewhere = false) {
+    return this.options.approvalResolver ?? (async (call, sig) => {
+      const ruling = gatedElsewhere ? this._config.getApprovalPolicy()?.(call, this._config.getTools().find((t) => t.name === call.name)) ?? { verdict: "ask" } : this._config.ruleOnToolCall(call);
+      if (ruling.verdict === "allow") return { approved: true };
+      if (ruling.verdict === "deny") {
+        return { approved: false, reason: ruling.reason?.trim() || "Tool execution was refused by the approval policy." };
+      }
+      return this._askForApproval(call, sig, targetElement);
+    });
+  }
+  /**
+   * The answers a paused server run waits for, asked HERE because only the page can: an
+   * approval through the same channel a run in the page uses (the panel, the policy, a
+   * host's own resolver), a browser tool through the handler `registerTool` gave it.
+   * A `queued` call needs nothing — the server runs it on resume. `undefined` when
+   * nobody answered — the turn was stopped, or the channel gave up — and there is no
+   * resume. A channel that CRASHES fails the turn, as it does for a run in the page.
+   */
+  async _answerDeferred(targetElement, pending, signal) {
+    const outcomes = {};
+    const resolver = this._approvalResolverFor(targetElement, true);
+    for (const p of pending) {
+      if (signal.aborted) break;
+      const call = { id: p.toolCallId, name: p.name, input: p.input ?? {} };
+      if (p.reason === "approval") {
+        let decision;
+        try {
+          decision = await resolver(call, signal);
+        } catch (error) {
+          if (!signal.aborted && error?.name !== "AbortError") throw error;
+        }
+        if (!decision || signal.aborted) return void 0;
+        outcomes[p.toolCallId] = { kind: "decision", ...decision };
+      } else if (p.reason === "external") {
+        const handler = this._config.getToolHandler(p.name);
+        try {
+          if (!handler) throw new Error(`No browser handler is registered for "${p.name}".`);
+          const result = await handler(call, signal, { target: targetElement, config: this._config });
+          outcomes[p.toolCallId] = {
+            kind: "result",
+            content: result.content,
+            ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
+          };
+        } catch (error) {
+          if (signal.aborted) break;
+          outcomes[p.toolCallId] = { kind: "failed", error: error instanceof Error ? error.message : String(error) };
+        }
+      }
+    }
+    return signal.aborted ? void 0 : outcomes;
+  }
+  /**
+   * The ticket is spent the moment the resume leaves: the server answers these calls
+   * now, so a pause saved from here on — the conversation manager saves before it cuts a
+   * switch — would be resumed a second time, against a server that has moved on. The
+   * history that resumes them is built first; a new pause marks what still waits.
+   */
+  _spendPause(targetElement, messageId) {
+    const segments = targetElement.getMessage?.(messageId)?.segments ?? targetElement.getMessages?.()?.find((m) => m.id === messageId)?.segments;
+    const paused = (segment) => segment.type === "tool_call" && Boolean(segment.deferred);
+    if (!segments?.some(paused)) return;
+    targetElement.updateMessage?.(messageId, {
+      segments: segments.map((segment) => {
+        if (!paused(segment)) return segment;
+        const { deferred: _spent, ...rest } = segment;
+        return rest;
+      })
+    });
+  }
+  /**
+   * Close the reply's calls that can no longer finish — paused, queued, or running on a
+   * server the page stopped listening to: each says it stopped, and forgets the pause.
+   * A cut connection carries none of their last events, so nothing else would: the rows
+   * spun, and a queued call kept its ticket, which a reload then resumed against a
+   * server that had moved on. By the reply's id, not the chat's head — a retry during
+   * the wait moves the head. A run in the page ends every call itself: nothing to do.
+   */
+  _closeOpenCalls(targetElement, messageId) {
+    const segments = targetElement.getMessage?.(messageId)?.segments ?? targetElement.getMessages?.()?.find((m) => m.id === messageId)?.segments;
+    const unfinished = (segment) => segment.type === "tool_call" && (segment.status === "pending" || segment.status === "awaiting-approval");
+    if (!segments?.some(unfinished)) return;
+    targetElement.updateMessage?.(messageId, {
+      segments: segments.map((segment) => {
+        if (!unfinished(segment)) return segment;
+        const { deferred: _spent, ...rest } = segment;
+        return { ...rest, status: "aborted" };
+      })
+    });
+  }
+  /**
+   * The history a resume sends: the request the turn was sent with — interceptor and
+   * `history` option included, not rebuilt from the transcript — then the reply so
+   * far, its paused calls left open for the server to answer.
+   */
+  _resumeMessages(targetElement, messageId, sent) {
+    const reply = targetElement.getMessages?.().find((m) => m.id === messageId);
+    return [...sent, ...reply ? wireTurns(reply, (segments) => this._segmentsToText(segments), { openDeferred: true }) : []];
+  }
+  /**
+   * What the send of a reloaded turn put before its reply, rebuilt the way
+   * `_buildMessages` builds it: the system prompts, the history `options.history`
+   * asks for — given the transcript before the reply, where the send also saw the
+   * reply's empty shell; handing over the paused reply would send it twice — and the
+   * message that asked.
+   * That message goes as its text: the files a send read are not in a transcript.
+   */
+  _resumeBase(all, replyIndex) {
+    const before = all.slice(0, replyIndex);
+    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]]) : []];
+  }
+  /**
+   * A new message closes a wait nobody answered. The paused calls of the last reply are
+   * marked stopped, so the history the new turn sends answers them ("stopped before it
+   * ran") — a provider rejects a request that declares a call with no answer.
+   */
+  _closeDeferred(targetElement) {
+    const messages = targetElement.getMessages?.() ?? [];
+    const last = [...messages].reverse().find((m) => m.role === "assistant");
+    if (!last?.segments?.some(isOpenDeferred)) return;
+    const segments = last.segments.map((segment) => {
+      if (!isOpenDeferred(segment)) return segment;
+      const { deferred: _closed, ...rest } = segment;
+      return { ...rest, status: "aborted" };
+    });
+    targetElement.updateMessage?.(last.id, { segments });
+  }
+  /**
+   * Answer a turn a server loop paused, when the conversation comes back — a reload, a
+   * conversation reopened days later. The last reply's paused calls (they carry the
+   * server's ticket) are put to the person again, or run in the page, and the loop
+   * resumes on the server, into the same bubble.
+   *
+   * Called on its own when a conversation manager loads a conversation
+   * (`aparte-conversation-loaded`); call it yourself after `setMessages` if you load
+   * conversations another way. Resolves `true` when a resume ran, `false` when there
+   * was nothing to resume.
+   *
+   * @param target The chat — an element, or its id. Defaults to the one `targetResolver` names, else the first on the page.
+   */
+  async resumeDeferred(target) {
+    const host = typeof target === "string" ? this._byId(target) : target ?? this.options.targetResolver?.() ?? null;
+    const targetElement = host ? this._asRenderTarget(host) : this._scanForTarget();
+    if (!targetElement) return false;
+    const messages = targetElement.getMessages?.() ?? [];
+    const last = [...messages].reverse().find((m) => m.role === "assistant");
+    const open = (last?.segments ?? []).filter(isOpenDeferred);
+    const ticket = open.find((s) => s.deferred?.ticket)?.deferred?.ticket;
+    if (!last || open.length === 0 || !ticket || this._resuming.has(last.id)) return false;
+    const config = this._config.getModelConfig();
+    const provider = config.defaultProvider ? this._config.getAIProvider(config.defaultProvider) : void 0;
+    if (!provider) {
+      console.warn("[AparteClient] Cannot resume the paused turn: no provider is selected.");
+      return false;
+    }
+    this._beginUserTurn();
+    this._resuming.add(last.id);
+    try {
+      const authConfig = await this._resolveAuth(provider.id);
+      const pending = open.map((s) => ({
+        toolCallId: s.toolCall.id,
+        name: s.toolCall.name,
+        input: s.toolCall.input,
+        reason: s.deferred.reason
+      }));
+      const base = this._resumeBase(messages, messages.indexOf(last));
+      await this._streamTurn(targetElement, last.id, provider, base, config.defaultModel || "", authConfig, {
+        resume: { pending, ticket }
+      });
+    } finally {
+      this._resuming.delete(last.id);
+    }
+    return true;
   }
+  /** Replies being resumed, so a second load of the same conversation does not ask twice. */
+  _resuming = /* @__PURE__ */ new Set();
   /**
    * Updates an existing message or appends a new error if ID lookup fails
    */
@@ -6542,6 +7155,54 @@ ${content}
     dispatchLifecycleEvent(target, "aparte-message-error", { messageId, error }, this._targetIdOf(target));
   }
 }
+function createAgentStreamRunner(options) {
+  return async (opts) => {
+    const doFetch = options.fetch ?? fetch;
+    const headers = typeof options.headers === "function" ? await options.headers() : options.headers ?? {};
+    const { tools, ...request } = opts.baseRequest;
+    const body = {
+      v: 1,
+      providerId: opts.providerId,
+      messageId: opts.messageId,
+      request,
+      clientTools: tools ?? [],
+      ...opts.deferral?.token ? { resume: { ticket: opts.deferral.token, outcomes: opts.deferral.outcomes ?? {} } } : {}
+    };
+    const response = await doFetch(options.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: opts.signal,
+      ...options.credentials ? { credentials: options.credentials } : {}
+    });
+    if (!response.ok || !response.body) {
+      const message = await response.json().then((json) => json?.error?.message).catch(() => void 0);
+      throw new AparteError(
+        message || `The agent endpoint answered HTTP ${response.status}.`,
+        AparteError.codeForStatus(response.status) ?? AparteErrorCode.PROVIDER_ERROR,
+        void 0,
+        void 0,
+        response.status
+      );
+    }
+    let usage;
+    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);
+      }
+      if (line.type === "run-done" || line.type === "run-suspended") {
+        usage = line.usage;
+        ended = true;
+      }
+      opts.emitter(line);
+    }
+    if (!ended && !opts.signal.aborted) {
+      throw new AparteError("The agent stream ended unexpectedly.", AparteErrorCode.PROVIDER_ERROR);
+    }
+    return usage;
+  };
+}
 function findHead(node) {
   if (node.next) return findHead(node.next);
   if ("current" in node) return node;
@@ -6848,6 +7509,8 @@ const APARTE_DEFAULT_UI_EVENTS = [
   "aparte-conversation-rename",
   "aparte-conversation-pin",
   "aparte-conversation-unpin",
+  // The conversation controller, on the chat host: a conversation's messages are on screen.
+  "aparte-conversation-loaded",
   // the select primitives
   "aparte-select-change",
   "aparte-select-open",
@@ -6864,6 +7527,7 @@ const APARTE_DEFAULT_UI_EVENTS = [
   "aparte-message-done",
   "aparte-message-error",
   "aparte-message-aborted",
+  "aparte-message-paused",
   "aparte-tool-approval-request"
 ];
 function applyElementProps(el2, props, transformValue = (value) => value) {
@@ -6939,56 +7603,58 @@ function installDialogTriggersOnce(doc = document) {
   doc.addEventListener("click", onClick);
 }
 export {
-  resolveConfig as $,
+  registerSegmentRenderer as $,
   APARTE_CONFIG_CHANGE as A,
   contextConfig as B,
   copyText as C,
-  createAparteChatHandler as D,
-  createStreamAdapter as E,
-  cssEscape as F,
-  declineDefaultRenderers as G,
-  defaultSanitizer as H,
-  detachConfig as I,
-  escapeAttr as J,
-  escapeHtml as K,
-  filesToAttachments as L,
-  getAllRenderers as M,
-  getSegmentRenderer as N,
-  installDefaultRenderersOnce as O,
-  installDialogTriggersOnce 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 _,
+  createAgentStreamRunner as D,
+  createAparteAgentHandler as E,
+  createAparteChatHandler as F,
+  createStreamAdapter as G,
+  cssEscape as H,
+  declineDefaultRenderers as I,
+  defaultSanitizer as J,
+  detachConfig as K,
+  escapeAttr as L,
+  escapeHtml as M,
+  filesToAttachments as N,
+  getAllRenderers as O,
+  getSegmentRenderer as P,
+  installDefaultRenderersOnce as Q,
+  installDialogTriggersOnce as R,
+  isAwaitingReply as S,
+  isFormatAdapter as T,
+  isSafeUrl as U,
+  isSegmentSettled as V,
+  parseAparteEventStream as W,
+  parseMarkdownToSegments as X,
+  populateBubbleFromMessage as Y,
+  readableToAsyncIterable as Z,
+  registerDefaultRenderers 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,
-  eventOrigin as a7,
-  activeElementIn as a8,
-  mergeSegmentUpdate as a9,
-  writeStreamedMarkdown as aa,
-  stampSegmentActivity as ab,
-  stampSegmentOnInsert as ac,
-  stampSegmentOnUpdate as ad,
-  renumberSegments as ae,
-  openSegmentIds as af,
-  isTerminalStatus as ag,
-  adoptMessageSegments as ah,
-  APARTE_DERIVED_SEGMENTS as ai,
-  chatBoundaryOf as aj,
-  rootOf as ak,
+  requestUserInput as a0,
+  resolveConfig as a1,
+  revokeAttachmentUrls as a2,
+  runWithConfig as a3,
+  segmentDuration as a4,
+  segmentTiming as a5,
+  subscribeConfigChange as a6,
+  unregisterSegmentRenderer as a7,
+  uuid as a8,
+  eventOrigin as a9,
+  activeElementIn as aa,
+  mergeSegmentUpdate as ab,
+  writeStreamedMarkdown as ac,
+  stampSegmentActivity as ad,
+  stampSegmentOnInsert as ae,
+  stampSegmentOnUpdate as af,
+  renumberSegments as ag,
+  openSegmentIds as ah,
+  isTerminalStatus as ai,
+  adoptMessageSegments as aj,
+  APARTE_DERIVED_SEGMENTS as ak,
+  chatBoundaryOf as al,
+  rootOf as am,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
@@ -7015,4 +7681,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=dialog-triggers-DwTGKWeU.js.map
+//# sourceMappingURL=dialog-triggers-Dad9V_ag.js.map