@aparte/plugin-subagents 0.0.0-stage → 1.6.0

package/dist/setup-CaTzFtu8.js

@@ -0,0 +1,1164 @@
+import { createSegmentList, createStreamAdapter, runWithConfig, getSegmentRenderer, installDefaultRenderersOnce, deferHydrationOf, subscribeConfigChange, resolveConfig, contextConfig, pluralize, formatDuration, segmentTiming, aparteGlobalConfig, registerSegmentRenderer, unregisterSegmentRenderer } from "@aparte/core";
+const SUBAGENT_SEGMENT_TYPE = "subagent";
+const STATUSES = /* @__PURE__ */ new Set(["running", "waiting", "done", "failed", "stopped"]);
+function subagentOf(segment) {
+  const value = segment.subagent;
+  if (!value || typeof value !== "object") return void 0;
+  const sub = value;
+  if (typeof sub.id !== "string") return void 0;
+  if (segment.type !== "tool_call" && segment.type !== SUBAGENT_SEGMENT_TYPE) return void 0;
+  return {
+    ...sub,
+    id: sub.id,
+    status: STATUSES.has(sub.status) ? sub.status : "stopped",
+    segments: Array.isArray(sub.segments) ? sub.segments : []
+  };
+}
+function anchorSettled(segment) {
+  if (segment.type === "tool_call") {
+    const status = segment.status;
+    return status !== "pending" && status !== "awaiting-approval";
+  }
+  return segment.isStreaming !== true;
+}
+function subagentStatus(segment) {
+  const sub = subagentOf(segment);
+  if (!sub) return "stopped";
+  if ((sub.status === "running" || sub.status === "waiting") && anchorSettled(segment)) return "stopped";
+  return sub.status;
+}
+function statusOfCall(status) {
+  switch (status ?? "pending") {
+    case "pending":
+      return "running";
+    case "awaiting-approval":
+      return "waiting";
+    case "resolved":
+      return "done";
+    case "failed":
+      return "failed";
+    default:
+      return "stopped";
+  }
+}
+function callStatusOf(status) {
+  switch (status) {
+    case "running":
+      return "pending";
+    case "waiting":
+      return "awaiting-approval";
+    case "done":
+      return "resolved";
+    case "failed":
+      return "failed";
+    default:
+      return "aborted";
+  }
+}
+const MAX_RUNS = 64;
+const MAX_LANES = 512;
+const MAX_EARLY = 2e3;
+const COALESCED = /* @__PURE__ */ new Set(["text-delta", "thinking-delta", "sources", "text-flush", "turn-start"]);
+const isOpen = (status) => (status ?? "pending") === "pending" || status === "awaiting-approval";
+const laneWatchers = /* @__PURE__ */ new Set();
+function watchLaneWrites(fn) {
+  laneWatchers.add(fn);
+  return () => {
+    laneWatchers.delete(fn);
+  };
+}
+const claims = /* @__PURE__ */ new WeakMap();
+function claim(target, messageId, owner) {
+  let byMessage = claims.get(target);
+  if (!byMessage) claims.set(target, byMessage = /* @__PURE__ */ new Map());
+  const holder2 = byMessage.get(messageId);
+  if (holder2) return holder2 === owner;
+  byMessage.set(messageId, owner);
+  return true;
+}
+function release(target, messageId, owner) {
+  const byMessage = claims.get(target);
+  if (byMessage?.get(messageId) === owner) byMessage.delete(messageId);
+}
+function nextFrame(fn) {
+  if (typeof requestAnimationFrame === "function") {
+    const handle2 = requestAnimationFrame(fn);
+    return () => cancelAnimationFrame(handle2);
+  }
+  const handle = setTimeout(fn, 16);
+  return () => clearTimeout(handle);
+}
+function stopFrame(run) {
+  const cancel = run.cancelFrame;
+  run.cancelFrame = null;
+  cancel?.();
+}
+const hostKey = (host, toolCallId) => `${host?.id ?? ""}\0${toolCallId}`;
+const ownSegmentId = (agentId) => `subagent-${agentId}`;
+function freeOwnId(segments, agentId) {
+  const base = ownSegmentId(agentId);
+  let id = base;
+  for (let n = 2; segments?.some((s) => s.id === id); n += 1) id = `${base}-${n}`;
+  return id;
+}
+function createLanes() {
+  const owner = {};
+  const runs = /* @__PURE__ */ new Map();
+  const over = /* @__PURE__ */ new Set();
+  const replySegments = (run) => {
+    const t = run.target;
+    try {
+      const message = t.getMessage?.(run.messageId) ?? t.getMessages?.()?.find((m) => m.id === run.messageId);
+      return message ? message.segments ?? [] : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const hostSegments = (run, host) => host ? host.list.segments : replySegments(run);
+  const anchorOf = (run, lane) => hostSegments(run, lane.host)?.find((s) => s.id === lane.anchorId);
+  const isWaiting = (run, lane) => {
+    if (lane.status === "waiting" || lane.asking.size > 0) return true;
+    for (const other of run.lanes.values()) {
+      if (other.host === lane && (other.status === "running" || other.status === "waiting") && isWaiting(run, other)) return true;
+    }
+    return false;
+  };
+  const snapshot = (run, lane) => ({
+    id: lane.id,
+    ...lane.name !== void 0 ? { name: lane.name } : {},
+    ...lane.description !== void 0 ? { description: lane.description } : {},
+    status: lane.status === "running" && isWaiting(run, lane) ? "waiting" : lane.status,
+    ...lane.result !== void 0 ? { result: lane.result } : {},
+    ...lane.error !== void 0 ? { error: lane.error } : {},
+    ...lane.parentId !== void 0 ? { parentId: lane.parentId } : {},
+    segments: lane.list.segments
+  });
+  const write = (run, host, segmentId, updates) => {
+    if (host) {
+      host.list.updateSegment?.(segmentId, updates);
+      return;
+    }
+    const segments = replySegments(run);
+    if (segments && !segments.some((s) => s.id === segmentId)) return;
+    run.target.updateSegment?.(segmentId, updates);
+  };
+  const writeAnchor = (run, lane) => {
+    const updates = { subagent: snapshot(run, lane) };
+    if (lane.anchorKind === "own") {
+      updates["isStreaming"] = lane.streaming;
+    } else {
+      const call = anchorOf(run, lane);
+      if (call && isOpen(call.status)) {
+        const waiting = isWaiting(run, lane);
+        if (waiting && call.status !== "awaiting-approval") {
+          updates["status"] = "awaiting-approval";
+          lane.holding = true;
+        } else if (!waiting && lane.holding && call.status === "awaiting-approval") {
+          updates["status"] = "pending";
+          lane.holding = false;
+        }
+      }
+    }
+    write(run, lane.host, lane.anchorId, updates);
+    if (laneWatchers.size === 0 || run.closed) return;
+    const anchor = anchorOf(run, lane) ?? {
+      id: lane.anchorId,
+      type: SUBAGENT_SEGMENT_TYPE,
+      subagent: updates["subagent"],
+      isStreaming: lane.streaming
+    };
+    const note = {
+      target: run.target,
+      ...run.targetId !== void 0 ? { targetId: run.targetId } : {},
+      messageId: run.messageId,
+      agentId: lane.id,
+      anchor
+    };
+    for (const fn of [...laneWatchers]) {
+      try {
+        fn(note);
+      } catch (err) {
+        console.error("[aparte] a sub-agent view threw", err);
+      }
+    }
+  };
+  const flush = (run) => {
+    if (run.closed) return;
+    stopFrame(run);
+    for (let guard = 0; run.dirty.size > 0 && guard < 1e4; guard += 1) {
+      let deepest;
+      for (const lane of run.dirty) if (!deepest || lane.depth > deepest.depth) deepest = lane;
+      run.dirty.delete(deepest);
+      if (deepest.ready) writeAnchor(run, deepest);
+    }
+    stopFrame(run);
+  };
+  const schedule = (run) => {
+    if (run.cancelFrame || run.closed) return;
+    run.cancelFrame = nextFrame(() => {
+      run.cancelFrame = null;
+      flush(run);
+    });
+  };
+  const dispatchLifecycleEvent = (run, name, detail) => {
+    if (typeof CustomEvent !== "function") return;
+    const id = run.targetId ?? (run.target.id || void 0);
+    try {
+      run.target.dispatchEvent(new CustomEvent(name, { bubbles: true, composed: true, detail: { targetId: id, ...detail } }));
+    } catch {
+    }
+  };
+  const dispatchEnd = (run, lane, status) => dispatchLifecycleEvent(run, "aparte-subagent-end", { messageId: run.messageId, agentId: lane.id, status });
+  const settleLane = (lane, calls) => {
+    for (const segment of lane.list.segments) {
+      if (segment.type === "tool_call") {
+        if (calls && isOpen(segment.status)) {
+          lane.list.updateSegment?.(segment.id, { status: "aborted" });
+        }
+      } else if (segment.isStreaming === true) {
+        lane.list.updateSegment?.(segment.id, { isStreaming: false });
+      }
+    }
+  };
+  const close = (run) => {
+    if (run.closed) return;
+    for (const lane of run.lanes.values()) {
+      const working = lane.status === "running" || lane.status === "waiting";
+      settleLane(lane, true);
+      lane.streaming = false;
+      run.dirty.add(lane);
+      if (working) dispatchEnd(run, lane, "stopped");
+    }
+    flush(run);
+    forget(run);
+  };
+  const forget = (run) => {
+    run.closed = true;
+    stopFrame(run);
+    run.unlisten();
+    release(run.target, run.messageId, owner);
+    if (runs.get(run.messageId) === run) runs.delete(run.messageId);
+    over.add(run.messageId);
+    if (over.size > MAX_RUNS) over.delete(over.values().next().value);
+  };
+  const markDirty = (run, lane, now) => {
+    run.dirty.add(lane);
+    if (now) flush(run);
+    else schedule(run);
+  };
+  const settleDueRows = (run) => {
+    if (run.rowsDue.length === 0) return;
+    const due = run.rowsDue;
+    run.rowsDue = [];
+    for (const lane of due) {
+      lane.ready = true;
+      run.dirty.add(lane);
+    }
+    flush(run);
+  };
+  const callStarted = (run, host, toolCallId) => {
+    const key = hostKey(host, toolCallId);
+    const held = run.awaitingRow.get(key);
+    if (!held) return;
+    run.awaitingRow.delete(key);
+    if (host) {
+      for (const lane of held) {
+        lane.ready = true;
+        run.dirty.add(lane);
+      }
+      flush(run);
+      return;
+    }
+    run.rowsDue.push(...held);
+    queueMicrotask(() => settleDueRows(run));
+  };
+  const listen = (run) => {
+    const target = run.target;
+    if (typeof target.addEventListener !== "function" || typeof target.removeEventListener !== "function") return () => {
+    };
+    const mine = (e) => e.detail?.messageId === run.messageId;
+    const onEnd = (e) => {
+      if (mine(e)) close(run);
+    };
+    const onPause = (e) => {
+      if (!mine(e)) return;
+      for (const lane of run.lanes.values()) run.dirty.add(lane);
+      flush(run);
+    };
+    const ends = ["aparte-message-done", "aparte-message-aborted", "aparte-message-error"];
+    for (const name of ends) target.addEventListener(name, onEnd, true);
+    target.addEventListener("aparte-message-paused", onPause, true);
+    return () => {
+      for (const name of ends) target.removeEventListener(name, onEnd, true);
+      target.removeEventListener("aparte-message-paused", onPause, true);
+    };
+  };
+  const openRun = (ctx) => {
+    if (!claim(ctx.target, ctx.messageId, owner)) return void 0;
+    if (runs.size >= MAX_RUNS) {
+      const oldest = runs.values().next().value;
+      if (oldest) forget(oldest);
+    }
+    const run = {
+      messageId: ctx.messageId,
+      target: ctx.target,
+      ...ctx.targetId !== void 0 ? { targetId: ctx.targetId } : {},
+      lanes: /* @__PURE__ */ new Map(),
+      callAgents: /* @__PURE__ */ new Map(),
+      early: /* @__PURE__ */ new Map(),
+      earlyCount: 0,
+      awaitingRow: /* @__PURE__ */ new Map(),
+      rowsDue: [],
+      dirty: /* @__PURE__ */ new Set(),
+      cancelFrame: null,
+      closed: false,
+      unlisten: () => {
+      }
+    };
+    run.unlisten = listen(run);
+    runs.set(ctx.messageId, run);
+    return run;
+  };
+  const savedAnchor = (segments, agentId, toolCallId) => {
+    if (!segments) return void 0;
+    return segments.find((s) => s.id === ownSegmentId(agentId) && subagentOf(s)?.id === agentId) ?? (toolCallId ? segments.find((s) => s.id === `tool-${toolCallId}` && subagentOf(s)?.id === agentId) : void 0);
+  };
+  const retire = (run, lane) => {
+    run.lanes.delete(lane.id);
+    if (lane.status === "running" || lane.status === "waiting") {
+      lane.status = "stopped";
+      settleLane(lane, true);
+      lane.streaming = false;
+      dispatchEnd(run, lane, "stopped");
+    }
+    markDirty(run, lane, true);
+  };
+  const startAgent = (run, e, ctx) => {
+    const known = run.lanes.get(e.agentId);
+    const reused = known !== void 0 && e.toolCallId !== void 0 && e.toolCallId !== known.toolCallId;
+    if (known && reused) retire(run, known);
+    if (known && !reused) {
+      known.status = "running";
+      delete known.result;
+      delete known.error;
+      if (e.name !== void 0) known.name = e.name;
+      if (e.description !== void 0) known.description = e.description;
+      known.streaming = true;
+      announce(run, known, e.toolCallId);
+      markDirty(run, known, true);
+      return;
+    }
+    if (run.lanes.size >= MAX_LANES) return;
+    const host = e.parentAgentId ? run.lanes.get(e.parentAgentId) ?? null : null;
+    const segments = hostSegments(run, host);
+    const saved = reused ? void 0 : savedAnchor(segments, e.agentId, e.toolCallId);
+    const callKey = e.toolCallId ? hostKey(host, e.toolCallId) : "";
+    const callId = e.toolCallId ? `tool-${e.toolCallId}` : "";
+    const callTaken = callKey !== "" && (run.callAgents.has(callKey) || !!segments?.some((s) => s.id === callId && subagentOf(s) && subagentOf(s).id !== e.agentId));
+    const onCall = saved ? saved.type === "tool_call" : callKey !== "" && !callTaken;
+    if (onCall) run.callAgents.set(callKey, e.agentId);
+    const previous = saved ? subagentOf(saved) : void 0;
+    const list = createSegmentList({ messageId: run.messageId, ...previous ? { segments: previous.segments } : {}, config: ctx.config });
+    const lane = {
+      id: e.agentId,
+      ...e.name !== void 0 ? { name: e.name } : previous?.name !== void 0 ? { name: previous.name } : {},
+      ...e.description !== void 0 ? { description: e.description } : previous?.description !== void 0 ? { description: previous.description } : {},
+      ...e.parentAgentId !== void 0 ? { parentId: e.parentAgentId } : {},
+      ...e.toolCallId !== void 0 ? { toolCallId: e.toolCallId } : {},
+      status: "running",
+      list,
+      // Not observed: every observer heard these events from the reply's adapter already.
+      emit: createStreamAdapter({ target: list, config: ctx.config, messageId: run.messageId, observe: false }),
+      host,
+      anchorId: onCall ? callId : saved ? saved.id : freeOwnId(segments, e.agentId),
+      anchorKind: onCall ? "call" : "own",
+      ready: true,
+      streaming: true,
+      asking: /* @__PURE__ */ new Set(),
+      holding: false,
+      depth: host ? host.depth + 1 : 0
+    };
+    run.lanes.set(lane.id, lane);
+    list.onChange(() => {
+      if (!run.closed) {
+        run.dirty.add(lane);
+        schedule(run);
+      }
+    });
+    if (lane.anchorKind === "call" && !saved && segments && !segments.some((s) => s.id === lane.anchorId)) {
+      lane.ready = false;
+      const key = callKey;
+      run.awaitingRow.set(key, [...run.awaitingRow.get(key) ?? [], lane]);
+    } else if (lane.anchorKind === "own" && !saved && !run.closed) {
+      const segment = {
+        id: lane.anchorId,
+        type: SUBAGENT_SEGMENT_TYPE,
+        subagent: snapshot(run, lane),
+        isStreaming: true
+      };
+      if (host) host.list.addSegment?.(segment);
+      else run.target.addSegment?.(segment);
+    }
+    announce(run, lane, e.toolCallId);
+    const early = run.early.get(lane.id);
+    if (early) {
+      run.early.delete(lane.id);
+      run.earlyCount -= early.length;
+      for (const event of early) feed(run, lane, event);
+    }
+    markDirty(run, lane, true);
+  };
+  const announce = (run, lane, toolCallId) => dispatchLifecycleEvent(run, "aparte-subagent-start", {
+    messageId: run.messageId,
+    agentId: lane.id,
+    ...lane.name !== void 0 ? { name: lane.name } : {},
+    ...lane.description !== void 0 ? { description: lane.description } : {},
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    ...lane.parentId !== void 0 ? { parentId: lane.parentId } : {}
+  });
+  const endAgent = (run, e) => {
+    const lane = run.lanes.get(e.agentId);
+    if (!lane) return;
+    lane.status = e.status;
+    if (e.result !== void 0) lane.result = e.result;
+    if (e.error !== void 0) lane.error = e.error;
+    if (e.status !== "waiting") {
+      settleLane(lane, false);
+      lane.streaming = false;
+    }
+    dispatchEnd(run, lane, e.status);
+    markDirty(run, lane, true);
+  };
+  const feed = (run, lane, e) => {
+    const { agentId: _owner, ...event } = e;
+    if ("toolCallId" in event && typeof event.toolCallId === "string") {
+      if (event.type === "tool-awaiting-approval") lane.asking.add(event.toolCallId);
+      else if (event.type !== "tool-start") lane.asking.delete(event.toolCallId);
+    }
+    const before = lane.list.segments.length;
+    lane.emit(event);
+    if (event.type === "tool-start") callStarted(run, lane, event.toolCallId);
+    const now = !COALESCED.has(event.type) || lane.list.segments.length !== before;
+    markDirty(run, lane, now);
+  };
+  const observe = (event, ctx) => {
+    const agentId = event.agentId;
+    const attributed = typeof agentId === "string" || event.type === "agent-start" || event.type === "agent-end";
+    let run = runs.get(ctx.messageId);
+    if (run && run.target !== ctx.target) return;
+    if (!run) {
+      if (!attributed || over.has(ctx.messageId)) return;
+      run = openRun(ctx);
+      if (!run) return;
+    }
+    settleDueRows(run);
+    if (!attributed) {
+      switch (event.type) {
+        case "tool-start":
+          callStarted(run, null, event.toolCallId);
+          break;
+        case "run-suspended":
+          for (const lane2 of run.lanes.values()) run.dirty.add(lane2);
+          flush(run);
+          break;
+        case "run-done":
+        case "run-aborted":
+          close(run);
+          break;
+      }
+      return;
+    }
+    if (event.type === "agent-start") {
+      startAgent(run, event, ctx);
+      return;
+    }
+    if (event.type === "agent-end") {
+      endAgent(run, event);
+      return;
+    }
+    if (event.type === "run-start" || event.type === "run-done" || event.type === "run-aborted" || event.type === "run-suspended") return;
+    const lane = run.lanes.get(agentId);
+    if (lane) {
+      feed(run, lane, event);
+      return;
+    }
+    if (run.earlyCount >= MAX_EARLY) return;
+    run.early.set(agentId, [...run.early.get(agentId) ?? [], event]);
+    run.earlyCount += 1;
+  };
+  return {
+    observe,
+    dispose: () => {
+      for (const run of [...runs.values()]) forget(run);
+    }
+  };
+}
+function rendererFor(type, config) {
+  const renderer = getSegmentRenderer(type, config);
+  if (renderer) return renderer;
+  installDefaultRenderersOnce(config);
+  return getSegmentRenderer(type, config);
+}
+function toElement(out, segment) {
+  let el;
+  if (typeof out === "string") {
+    const tpl = document.createElement("template");
+    tpl.innerHTML = out.trim();
+    el = tpl.content.firstElementChild;
+  } else {
+    el = out;
+  }
+  if (el && !el.hasAttribute("data-segment-id")) el.setAttribute("data-segment-id", segment.id);
+  return el;
+}
+function fallbackOf(segment) {
+  const text = segment.fallback;
+  if (typeof text !== "string" || !text.trim()) return null;
+  const el = document.createElement("div");
+  el.className = "aparte-segment aparte-segment-fallback";
+  el.setAttribute("data-segment-id", segment.id);
+  el.textContent = text;
+  return el;
+}
+function drawnAs(segment, live) {
+  if (!live || segment.type !== "text" && segment.type !== "thinking") return segment;
+  if (segment.isStreaming !== void 0) return segment;
+  return { ...segment, isStreaming: true };
+}
+class LaneDrawing {
+  constructor(container) {
+    this.container = container;
+  }
+  rows = /* @__PURE__ */ new Map();
+  /** How many rows are drawn. */
+  get size() {
+    return this.rows.size;
+  }
+  /**
+   * Draw `segments`, in order: a new segment gets a row, a changed one is patched, one that
+   * left loses its row. `live`: the sub-agent still works, so what it adds is arriving.
+   */
+  sync(segments, config, live) {
+    const seen = /* @__PURE__ */ new Set();
+    let previous = null;
+    for (const segment of segments) {
+      if (!segment || typeof segment.id !== "string" || seen.has(segment.id)) continue;
+      seen.add(segment.id);
+      const renderer = rendererFor(segment.type, config);
+      let row = this.rows.get(segment.id);
+      if (row && row.renderer !== renderer) {
+        this.release(segment.id, config);
+        row.el.remove();
+        row = void 0;
+      }
+      if (!row) row = this.draw(segment, renderer, config, live);
+      else if (row.segment !== segment) this.patch(row, segment, config);
+      if (!row) continue;
+      const expected = previous ? previous.nextSibling : this.container.firstChild;
+      if (row.el !== expected) this.container.insertBefore(row.el, expected);
+      previous = row.el;
+    }
+    for (const [id, row] of [...this.rows]) {
+      if (seen.has(id)) continue;
+      this.release(id, config);
+      row.el.remove();
+    }
+  }
+  /** Every row re-reads what it takes from the config (a language switch). */
+  relabel(config) {
+    for (const row of this.rows.values()) {
+      const relabel = row.renderer?.relabel;
+      if (!relabel) continue;
+      runWithConfig(config, () => relabel.call(row.renderer, row.el, row.segment));
+    }
+  }
+  /** Every row goes: each renderer cleans up what it drew. */
+  clear(config) {
+    for (const [id, row] of [...this.rows]) {
+      this.release(id, config);
+      row.el.remove();
+    }
+  }
+  draw(segment, renderer, config, live) {
+    const el = renderer ? toElement(runWithConfig(config, () => renderer.render(segment)), segment) : fallbackOf(segment);
+    if (!el) return void 0;
+    const row = { el, renderer, segment };
+    this.rows.set(segment.id, row);
+    if (renderer?.setup) {
+      const as = drawnAs(segment, live);
+      runWithConfig(config, () => renderer.setup(el, as));
+    }
+    return row;
+  }
+  patch(row, segment, config) {
+    const renderer = row.renderer;
+    row.segment = segment;
+    if (!renderer) {
+      const next2 = fallbackOf(segment);
+      if (next2) {
+        row.el.replaceWith(next2);
+        row.el = next2;
+      }
+      return;
+    }
+    if (renderer.update) {
+      const before = row.el;
+      runWithConfig(config, () => renderer.update(before, segment));
+      if (before.parentNode !== this.container) {
+        const now = this.childOf(segment.id);
+        if (now) row.el = now;
+      }
+      return;
+    }
+    const next = toElement(runWithConfig(config, () => renderer.render(segment)), segment);
+    if (!next) return;
+    this.cleanup(row, config);
+    row.el.replaceWith(next);
+    row.el = next;
+    if (renderer.setup) runWithConfig(config, () => renderer.setup(next, segment));
+  }
+  /** The row for `id` among the container's own children — never a decoy in a row's prose. */
+  childOf(id) {
+    for (const child of this.container.children) {
+      if (child.getAttribute("data-segment-id") === id) return child;
+    }
+    return null;
+  }
+  release(id, config) {
+    const row = this.rows.get(id);
+    if (!row) return;
+    this.rows.delete(id);
+    this.cleanup(row, config);
+  }
+  cleanup(row, config) {
+    const cleanup = row.renderer?.cleanup;
+    if (!cleanup) return;
+    try {
+      runWithConfig(config, () => cleanup.call(row.renderer, row.el, row.segment));
+    } catch (err) {
+      console.error("[aparte] a segment renderer's cleanup threw", err);
+    }
+  }
+}
+const styles = "/*\n * @aparte/plugin-subagents — a sub-agent's conversation.\n *\n * Only what is the plugin's own. The rows inside are core's (text, reasoning, tool rows,\n * a nested sub-agent's line) and wear core's sheets; under a line, the transcript sits in\n * core's tool detail, which already draws the rule and the indent a disclosure has. So\n * this sheet draws the task line, the spacing of the rows, and — for the standalone view\n * only — the same quiet rule down the leading edge, since nothing of core's is around it.\n *\n * Logical properties throughout, so a right-to-left locale puts the rule on its own\n * leading edge. No colour of its own: core's tokens. Nothing moves, so there is no motion\n * to reduce.\n */\naparte-subagent-view {\n    display: block;\n    min-inline-size: 0;\n}\n\n/* Standalone (a canvas, a pane, a dialog): outside any message, so the conversation's\n   type is set here, as core's segment container sets it in a reply. */\naparte-subagent-view:not([data-inline]) {\n    font-size: var(--aparte-content-font-size);\n    line-height: var(--aparte-content-line-height);\n    color: var(--aparte-content-color);\n    font-family: var(--aparte-font-family);\n}\n\n/* Nothing to show (an unknown sub-agent, or one not started yet): nothing drawn. */\naparte-subagent-view[data-empty] {\n    display: none;\n}\n\n.aparte-subagent-task {\n    margin: 0 0 var(--aparte-space-3);\n    color: var(--aparte-text-muted);\n    font-size: var(--aparte-font-size-sm);\n}\n\n.aparte-subagent-transcript {\n    display: flex;\n    flex-direction: column;\n    gap: var(--aparte-space-4);\n    min-inline-size: 0;\n}\n\n.aparte-subagent-transcript:empty {\n    display: none;\n}\n\naparte-subagent-view:not([data-inline]) > .aparte-subagent-transcript {\n    padding-inline-start: var(--aparte-subagent-indent, var(--aparte-space-6));\n    border-inline-start: var(--aparte-border-width) solid var(--aparte-border);\n}\n";
+const STYLE_ID = "aparte-subagent-styles";
+const MARK = ".aparte-subagent-transcript";
+let holder = null;
+function onPage() {
+  if (holder?.isConnected) return true;
+  holder = document.getElementById(STYLE_ID) ?? [...document.querySelectorAll("style")].find((sheet) => sheet.textContent?.includes(MARK)) ?? null;
+  return holder !== null;
+}
+function rendererStyles() {
+  return typeof document !== "undefined" && document.getElementById(STYLE_ID) ? "" : styles;
+}
+function ensureStyles() {
+  if (typeof document === "undefined" || onPage()) return;
+  const style = document.createElement("style");
+  style.id = STYLE_ID;
+  style.textContent = styles;
+  document.head.appendChild(style);
+  holder = style;
+}
+const CONVERSATION_EVENTS = [
+  "aparte-subagent-start",
+  "aparte-subagent-end",
+  "aparte-segment-update",
+  "aparte-message-done",
+  "aparte-message-aborted",
+  "aparte-message-error",
+  "aparte-message-paused",
+  "aparte-path-changed",
+  "aparte-reset-done",
+  "aparte-conversation-loaded"
+];
+const MAX_DEPTH = 16;
+const adopted = /* @__PURE__ */ new WeakMap();
+function laneOf(anchor) {
+  const sub = subagentOf(anchor);
+  if (!sub) return { segments: [], live: false };
+  const status = subagentStatus(anchor);
+  if (status === "running" || status === "waiting") return { segments: sub.segments, live: true };
+  let settled = adopted.get(sub.segments);
+  if (!settled) {
+    settled = createSegmentList({ messageId: anchor.messageId ?? "", segments: sub.segments }).segments;
+    adopted.set(sub.segments, settled);
+  }
+  return { segments: settled, live: false };
+}
+function findSubagent(segments, agentId, depth = 0) {
+  for (const segment of segments) {
+    const sub = subagentOf(segment);
+    if (!sub) continue;
+    if (sub.id === agentId) return segment;
+    if (depth >= MAX_DEPTH) continue;
+    const found = findSubagent(laneOf(segment).segments, agentId, depth + 1);
+    if (found) return found;
+  }
+  return void 0;
+}
+const fed = /* @__PURE__ */ new WeakMap();
+const ElementBase = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+class AparteSubagentView extends ElementBase {
+  static get observedAttributes() {
+    return ["for", "message-id", "agent-id"];
+  }
+  _chat = null;
+  _task = null;
+  _drawing = null;
+  /** The config the rows were drawn with, and the segment they were drawn from. */
+  _config = null;
+  _anchor = null;
+  _listening = null;
+  _stopConfig = null;
+  _stopWatching = null;
+  _queued = false;
+  _releaseQueued = false;
+  _warned = "";
+  _onConversation = () => this._schedule();
+  _onWrite = (write) => {
+    if (fed.has(this) || !this.isConnected) return;
+    if (write.messageId !== this.getAttribute("message-id") || write.agentId !== this.getAttribute("agent-id")) return;
+    if (!this._matches(write)) return;
+    this._draw(write.anchor, this._sourceConfig());
+  };
+  // ── What the app sets ──────────────────────────────────────────────────
+  /** The chat, when it has no `id` for the `for` attribute: an element, or anything with `getMessages()`. */
+  get chat() {
+    return this._chat;
+  }
+  set chat(value) {
+    this._chat = value;
+    if (!this.isConnected) return;
+    this._listen();
+    this.refresh();
+  }
+  /** Read the sub-agent again and draw it: what the element does on every change it hears. */
+  refresh() {
+    const feed = fed.get(this);
+    if (!feed && !this.isConnected) return;
+    const anchor = feed ? feed.anchor : this._find();
+    this._draw(anchor === null ? this._anchor : anchor, feed ? feed.config : this._sourceConfig());
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────
+  connectedCallback() {
+    ensureStyles();
+    this._build();
+    if (!fed.has(this)) {
+      this._listen();
+      this._stopWatching ??= watchLaneWrites(this._onWrite);
+    } else {
+      this._stopConfig?.();
+      this._stopConfig = subscribeConfigChange(this, () => this._onConfigChange());
+    }
+    this.refresh();
+  }
+  disconnectedCallback() {
+    this._unlisten();
+    this._stopWatching?.();
+    this._stopWatching = null;
+    this._stopConfig?.();
+    this._stopConfig = null;
+    if (this._releaseQueued) return;
+    this._releaseQueued = true;
+    queueMicrotask(() => {
+      this._releaseQueued = false;
+      if (this.isConnected) return;
+      this._release();
+    });
+  }
+  attributeChangedCallback(_name, previous, value) {
+    if (previous === value || !this.isConnected || fed.has(this)) return;
+    if (_name === "for") this._listen();
+    this.refresh();
+  }
+  // ── Reading the conversation ───────────────────────────────────────────
+  _source() {
+    if (this._chat) return this._chat;
+    const id = this.getAttribute("for");
+    return id ? this.ownerDocument.getElementById(id) : null;
+  }
+  _sourceConfig() {
+    const source = this._source();
+    return resolveConfig(typeof Element !== "undefined" && source instanceof Element ? source : this);
+  }
+  /** A write from this view's chat: the run's target is the chat, inside it, or named by its id. */
+  _matches(write) {
+    const source = this._source();
+    if (!source) return false;
+    if (source === write.target) return true;
+    if (typeof Node !== "undefined" && source instanceof Node && write.target instanceof Node && (source.contains(write.target) || write.target.contains(source))) return true;
+    return write.targetId !== void 0 && source.id === write.targetId;
+  }
+  /**
+   * The segment that stands for the sub-agent in the chat's reply; `undefined` when there is
+   * none, `null` when the chat cannot be read at all.
+   */
+  _find() {
+    const messageId = this.getAttribute("message-id");
+    const agentId = this.getAttribute("agent-id");
+    const source = this._source();
+    if (!messageId || !agentId || !source) return void 0;
+    const own = source;
+    const reader = typeof own.getMessage === "function" || typeof own.getMessages === "function" ? own : own.querySelector?.("aparte-chat-viewport") ?? null;
+    if (!reader || typeof reader.getMessage !== "function" && typeof reader.getMessages !== "function") return null;
+    let message;
+    try {
+      message = reader.getMessage?.(messageId) ?? reader.getMessages?.()?.find((m) => m.id === messageId);
+    } catch {
+      return null;
+    }
+    const anchor = message ? findSubagent(message.segments ?? [], agentId) : void 0;
+    const key = `${messageId}\0${agentId}`;
+    if (message && !anchor && !message.isStreaming && message.status !== "pending" && message.status !== "streaming" && this._warned !== key) {
+      this._warned = key;
+      console.warn(`[aparte] <aparte-subagent-view>: the reply "${messageId}" holds no sub-agent "${agentId}".`);
+    }
+    return anchor;
+  }
+  _listen() {
+    const source = this._source();
+    const target = source && typeof source.addEventListener === "function" ? source : null;
+    if (target !== this._listening) {
+      this._unlisten();
+      if (target) for (const name of CONVERSATION_EVENTS) target.addEventListener(name, this._onConversation);
+      this._listening = target;
+    }
+    this._stopConfig?.();
+    const holder2 = typeof Element !== "undefined" && source instanceof Element ? source : this;
+    this._stopConfig = subscribeConfigChange(holder2, () => this._onConfigChange());
+  }
+  _unlisten() {
+    if (this._listening) for (const name of CONVERSATION_EVENTS) this._listening.removeEventListener(name, this._onConversation);
+    this._listening = null;
+  }
+  /** Folds a burst of events (a whole run's end) into one read. */
+  _schedule() {
+    if (this._queued) return;
+    this._queued = true;
+    queueMicrotask(() => {
+      this._queued = false;
+      this.refresh();
+    });
+  }
+  _onConfigChange() {
+    this.refresh();
+    if (this._config) this._drawing?.relabel(this._config);
+  }
+  // ── Drawing ────────────────────────────────────────────────────────────
+  _build() {
+    if (this._drawing) {
+      if (this._task.parentNode !== this) this.prepend(this._task);
+      if (this._drawing.container.parentNode !== this) this.append(this._drawing.container);
+      return;
+    }
+    const task = this.ownerDocument.createElement("p");
+    task.className = "aparte-subagent-task";
+    task.hidden = true;
+    const list = this.ownerDocument.createElement("div");
+    list.className = "aparte-subagent-transcript";
+    this.append(task, list);
+    this._task = task;
+    this._drawing = new LaneDrawing(list);
+  }
+  /** Draw `anchor`'s conversation with `config`. */
+  _draw(anchor, config) {
+    this._build();
+    const drawing = this._drawing;
+    if (this._config && this._config !== config) drawing.clear(this._config);
+    this._config = config;
+    this._anchor = anchor ?? null;
+    this.toggleAttribute("data-inline", fed.has(this));
+    this.toggleAttribute("data-empty", !anchor);
+    const task = (anchor ? subagentOf(anchor)?.description?.trim() : "") ?? "";
+    if (this._task.textContent !== task) this._task.textContent = task;
+    this._task.hidden = !task;
+    const lane = anchor ? laneOf(anchor) : { segments: [], live: false };
+    runWithConfig(config, () => drawing.sync(lane.segments, config, lane.live));
+  }
+  /** Out of the page for good: every row's renderer cleans up, and the drawing goes. */
+  _release() {
+    if (this._config) this._drawing?.clear(this._config);
+    const feed = fed.get(this);
+    if (feed) {
+      fed.delete(this);
+      feed.onRelease?.();
+    }
+  }
+}
+function feedView(view, anchor, config, onRelease) {
+  const release2 = onRelease ?? fed.get(view)?.onRelease;
+  fed.set(view, { anchor, config, ...release2 ? { onRelease: release2 } : {} });
+  view._draw(anchor, config);
+}
+if (typeof customElements !== "undefined" && !customElements.get("aparte-subagent-view")) {
+  deferHydrationOf(AparteSubagentView);
+  customElements.define("aparte-subagent-view", AparteSubagentView);
+}
+const views = /* @__PURE__ */ new WeakMap();
+const MAX_VIEWS = 500;
+const subagentTranscript = (segment) => {
+  if (typeof document === "undefined") return "";
+  const sub = subagentOf(segment);
+  if (!sub) return "";
+  if (!sub.description?.trim() && sub.segments.length === 0) return "";
+  const config = contextConfig();
+  let byKey = views.get(config);
+  if (!byKey) views.set(config, byKey = /* @__PURE__ */ new Map());
+  const key = `${segment.messageId ?? ""}\0${segment.id}\0${sub.id}`;
+  let view = byKey.get(key);
+  if (!view) {
+    view = document.createElement("aparte-subagent-view");
+    const held = view;
+    const map = byKey;
+    feedView(view, segment, config, () => {
+      if (map.get(key) === held) map.delete(key);
+    });
+    map.set(key, view);
+    if (map.size > MAX_VIEWS) {
+      for (const [k, v] of map) {
+        if (map.size <= MAX_VIEWS) break;
+        if (!v.isConnected) map.delete(k);
+      }
+    }
+    return view;
+  }
+  feedView(view, segment, config);
+  return view;
+};
+const WORDS = {
+  /** How many tool calls a sub-agent made, on its line: "3 tools". */
+  subagentsTools: {
+    en: "one:{n} tool|other:{n} tools",
+    fr: "one:{n} outil|other:{n} outils",
+    de: "one:{n} Tool|other:{n} Tools",
+    es: "one:{n} herramienta|other:{n} herramientas",
+    it: "one:{n} strumento|other:{n} strumenti",
+    ja: "other:{n} 個のツール",
+    ko: "other:도구 {n}개",
+    pt: "one:{n} ferramenta|other:{n} ferramentas",
+    ru: "one:{n} инструмент|few:{n} инструмента|many:{n} инструментов|other:{n} инструмента",
+    zh: "other:{n} 个工具"
+  },
+  /** What a sub-agent's second line says before its first call. */
+  subagentsStarting: {
+    en: "Starting…",
+    fr: "Démarrage…",
+    de: "Wird gestartet…",
+    es: "Iniciando…",
+    it: "Avvio…",
+    ja: "開始しています…",
+    ko: "시작하는 중…",
+    pt: "Iniciando…",
+    ru: "Запуск…",
+    zh: "正在启动…"
+  },
+  /** The name of a sub-agent that was given none, when no call names its line either. */
+  subagentsUnnamed: {
+    en: "Sub-agent",
+    fr: "Sous-agent",
+    de: "Subagent",
+    es: "Subagente",
+    it: "Sottoagente",
+    ja: "サブエージェント",
+    ko: "하위 에이전트",
+    pt: "Subagente",
+    ru: "Субагент",
+    zh: "子智能体"
+  }
+};
+function languageOf(config) {
+  const tag = config.getLocale().tag;
+  return typeof tag === "string" && tag ? tag.split("-")[0].toLowerCase() : "en";
+}
+function word(config, key) {
+  const fromApp = config.getLocale()[key];
+  const table = WORDS[key];
+  return typeof fromApp === "string" && fromApp || table[languageOf(config)] || table.en;
+}
+function toolCount(config, n) {
+  const tag = config.getLocale().tag;
+  return pluralize(word(config, "subagentsTools"), n, typeof tag === "string" && tag ? tag : void 0);
+}
+const standIns = /* @__PURE__ */ new WeakSet();
+function markStandIn(segment) {
+  standIns.add(segment);
+  return segment;
+}
+const isOpenCall = (segment) => segment.type === "tool_call" && ["pending", "awaiting-approval"].includes(segment.status ?? "pending");
+const textOf = (read) => {
+  try {
+    const value = read();
+    return typeof value === "string" ? value.trim() : "";
+  } catch {
+    return "";
+  }
+};
+function callLine(call, config) {
+  const name = call.toolCall?.name ?? "";
+  const nested = subagentOf(call);
+  const label = config.getToolDisplay(name)?.label;
+  const shown = (label !== void 0 ? textOf(() => typeof label === "function" ? label(call) : label) : "") || nested?.name?.trim() || name;
+  const summary = config.getToolSummary(name);
+  const target = (summary ? textOf(() => summary(call)) : "") || nested?.description?.trim() || "";
+  return [shown, target].filter(Boolean).join(" ");
+}
+function activityOf(sub, config) {
+  let latest;
+  for (let i = sub.segments.length - 1; i >= 0; i -= 1) {
+    const segment = sub.segments[i];
+    if (segment.type !== "tool_call") continue;
+    if (isOpenCall(segment)) return callLine(segment, config);
+    latest ??= segment;
+  }
+  return latest ? callLine(latest, config) : "";
+}
+function durationOf(anchor, sub) {
+  const start = segmentTiming(anchor)?.startedAt;
+  if (start === void 0) return void 0;
+  let end;
+  for (const segment of sub.segments) {
+    const timing = segmentTiming(segment);
+    const at = timing?.endedAt ?? timing?.startedAt;
+    if (at !== void 0 && (end === void 0 || at > end)) end = at;
+  }
+  end ??= segmentTiming(anchor)?.endedAt;
+  return end === void 0 || end < start ? void 0 : end - start;
+}
+function stateWord(config, status) {
+  switch (status) {
+    case "running":
+      return config.t("toolRunning");
+    case "waiting":
+      return config.t("approvalWaiting");
+    case "done":
+      return config.t("toolCompleted");
+    case "failed":
+      return config.t("toolFailed");
+    default:
+      return config.t("toolStopped");
+  }
+}
+function createLineProvider(options = {}) {
+  return (segment) => {
+    const sub = subagentOf(segment);
+    if (!sub) return void 0;
+    const config = contextConfig();
+    const standIn = standIns.has(segment);
+    const status = subagentStatus(segment);
+    const live = status === "running" || status === "waiting";
+    const line = {};
+    const name = sub.name?.trim();
+    if (name) line.label = name;
+    else if (standIn) line.label = word(config, "subagentsUnnamed");
+    const task = sub.description?.trim();
+    if (task) line.target = task;
+    const summary = () => {
+      if (options.counts === false) return "";
+      const parts = [];
+      const tools = sub.segments.filter((s) => s.type === "tool_call").length;
+      if (tools > 0) parts.push(toolCount(config, tools));
+      const ms = durationOf(segment, sub);
+      if (ms !== void 0) {
+        const tag = config.getLocale().tag;
+        parts.push(formatDuration(ms, typeof tag === "string" && tag ? tag : void 0));
+      }
+      return parts.join(" · ");
+    };
+    const note = [];
+    if (!standIn && statusOfCall(segment.status) !== status) note.push(stateWord(config, status));
+    if (options.activity !== false) {
+      line.activity = live ? activityOf(sub, config) || word(config, "subagentsStarting") : summary() || stateWord(config, status);
+    } else if (!live) {
+      const done = summary();
+      if (done) note.push(done);
+    }
+    if (note.length > 0) line.note = note.join(" · ");
+    const details = options.details;
+    line.details = typeof details === "function" ? details : details === "transcript" ? subagentTranscript : false;
+    return line;
+  };
+}
+const UNNAMED_AGENT = "subagent";
+function standInCall(segment) {
+  const sub = subagentOf(segment);
+  const status = subagentStatus(segment);
+  const call = {
+    id: segment.id,
+    type: "tool_call",
+    ...segment.messageId !== void 0 ? { messageId: segment.messageId } : {},
+    ...segment.index !== void 0 ? { index: segment.index } : {},
+    // Its timing is the segment's: the line's duration reads it.
+    ...segment.meta !== void 0 ? { meta: segment.meta } : {},
+    ...segment.collapsed !== void 0 ? { collapsed: segment.collapsed } : {},
+    toolCall: { id: sub?.id ?? segment.id, name: sub?.name?.trim() || UNNAMED_AGENT, input: {} },
+    status: callStatusOf(status),
+    // A failure reads as a failed call's does.
+    ...status === "failed" && sub?.error ? { result: sub.error } : {},
+    subagent: segment.subagent
+  };
+  return markStandIn(call);
+}
+const toolRow = () => getSegmentRenderer("tool_call", contextConfig());
+function replace(element, out, segment) {
+  const tpl = document.createElement("template");
+  tpl.innerHTML = typeof out === "string" ? out.trim() : "";
+  const next = typeof out === "string" ? tpl.content.firstElementChild : out;
+  if (!next) return null;
+  if (!next.hasAttribute("data-segment-id")) next.setAttribute("data-segment-id", segment.id);
+  element.replaceWith(next);
+  return next;
+}
+const subagentRenderer = {
+  type: SUBAGENT_SEGMENT_TYPE,
+  render: (segment) => toolRow()?.render(standInCall(segment)) ?? "",
+  setup: (element, segment) => toolRow()?.setup?.(element, standInCall(segment)),
+  update: (element, segment) => {
+    const row = toolRow();
+    if (!row) return;
+    const call = standInCall(segment);
+    if (row.update) {
+      row.update(element, call);
+      return;
+    }
+    row.cleanup?.(element, call);
+    const next = replace(element, row.render(call), segment);
+    if (next) row.setup?.(next, call);
+  },
+  relabel: (element, segment) => toolRow()?.relabel?.(element, standInCall(segment)),
+  cleanup: (element, segment) => toolRow()?.cleanup?.(element, standInCall(segment)),
+  // The plugin's sheet (the transcript's, the view's): core puts it on the page with the
+  // renderers' own, once, unless a view already did.
+  getStyles: rendererStyles
+};
+const installed = /* @__PURE__ */ new WeakMap();
+function setupSubagents(options = {}, config = aparteGlobalConfig) {
+  installed.get(config)?.();
+  const lanes = createLanes();
+  const provider = createLineProvider({ ...options });
+  const stopObserving = config.observeRunEvents(lanes.observe);
+  config.setToolLineProvider(provider);
+  registerSegmentRenderer(subagentRenderer, config);
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    stopObserving();
+    lanes.dispose();
+    if (config.getToolLineProvider() === provider) config.setToolLineProvider(null);
+    if (getSegmentRenderer(SUBAGENT_SEGMENT_TYPE, config) === subagentRenderer) unregisterSegmentRenderer(SUBAGENT_SEGMENT_TYPE, config);
+    if (installed.get(config) === dispose) installed.delete(config);
+  };
+  installed.set(config, dispose);
+  return dispose;
+}
+export {
+  AparteSubagentView as A,
+  SUBAGENT_SEGMENT_TYPE as S,
+  subagentOf as a,
+  subagentStatus as b,
+  subagentTranscript as c,
+  setupSubagents as s
+};
+//# sourceMappingURL=setup-CaTzFtu8.js.map