@athenaintel/react 0.41.2 → 0.42.1

package/dist/agent-runtime/src/subagent-transcripts.js

@@ -0,0 +1,209 @@
+import { createExternalMessageConversionCache } from "@assistant-ui/core/react";
+import { DEEP_AGENT_REPEATS_RESULT_KEY } from "./generated/runconfig-contract.js";
+import { getMessageText } from "./message-text.js";
+import { sanitizeLangChainMessages, createDeepAgentMessageConversionCache } from "./messages.js";
+import { TASK_TOOL_NAME } from "./tool-names.js";
+function laneTranscriptOf(artifact) {
+  if (typeof artifact !== "object" || artifact === null) return void 0;
+  const state = artifact.subgraph_state;
+  if (typeof state !== "object" || state === null) return void 0;
+  const messages = state.messages;
+  return Array.isArray(messages) ? messages : void 0;
+}
+const restoredTranscripts = /* @__PURE__ */ new WeakMap();
+function withRepeatedResult(transcript, content) {
+  const last = transcript[transcript.length - 1];
+  if (last === void 0 || last[DEEP_AGENT_REPEATS_RESULT_KEY] !== true || typeof content !== "string" && !Array.isArray(content)) {
+    return transcript;
+  }
+  const cached = restoredTranscripts.get(transcript);
+  if (cached !== void 0 && cached.content === content) return cached.transcript;
+  const restored = [...transcript.slice(0, -1), { ...last, content }];
+  restoredTranscripts.set(transcript, { content, transcript: restored });
+  return restored;
+}
+const convertibleChunkTurns = /* @__PURE__ */ new WeakMap();
+function asConvertibleTurn(message) {
+  const type = message.type;
+  if (type !== "AIMessageChunk") return message;
+  const cached = convertibleChunkTurns.get(message);
+  if (cached !== void 0) return cached;
+  const turn = { ...message, type: "ai" };
+  convertibleChunkTurns.set(message, turn);
+  return turn;
+}
+function answeringTurn(step) {
+  var _a;
+  const turn = asConvertibleTurn(step);
+  return turn.type === "ai" && (((_a = turn.tool_calls) == null ? void 0 : _a.length) ?? 0) === 0 ? turn : null;
+}
+const isTextBlock = (block) => typeof block === "object" && block !== null && "type" in block && block.type === "text";
+function shownText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let text = "";
+  for (const block of content) {
+    if (isTextBlock(block) && typeof block.text === "string") text += block.text;
+  }
+  return text;
+}
+function blankTurn(step) {
+  const turn = answeringTurn(step);
+  if (turn === null || shownText(turn.content).trim() !== "") return null;
+  return typeof turn.content === "string" || turn.content.every(isTextBlock) ? turn : null;
+}
+const reportedLanes = /* @__PURE__ */ new WeakMap();
+function withLaneReport(transcript, report) {
+  if (report === void 0 || report.trim() === "" || transcript.length === 0) return transcript;
+  let at = transcript.length - 1;
+  let closing = transcript[at];
+  while (closing !== void 0 && blankTurn(closing) !== null) {
+    at -= 1;
+    closing = transcript[at];
+  }
+  const answered = closing !== void 0 && answeringTurn(closing) !== null && shownText(closing.content).trim() !== "";
+  if (answered) return transcript;
+  const cached = reportedLanes.get(transcript);
+  if (cached !== void 0 && cached.report === report) return cached.transcript;
+  const last = transcript[transcript.length - 1];
+  const blank = last === void 0 ? null : blankTurn(last);
+  const closed = blank !== null ? [...transcript.slice(0, -1), { ...blank, content: report }] : [...transcript, { id: `${(last == null ? void 0 : last.id) ?? "lane"}:report`, type: "ai", content: report }];
+  reportedLanes.set(transcript, { report, transcript: closed });
+  return closed;
+}
+function transcriptSources(transcript) {
+  return sanitizeLangChainMessages(transcript.map(asConvertibleTurn));
+}
+const reportedTranscripts = /* @__PURE__ */ new WeakSet();
+function reportUnconvertibleTranscript(transcript, error) {
+  if (reportedTranscripts.has(transcript)) return;
+  reportedTranscripts.add(transcript);
+  console.warn("[agent-runtime] a subagent transcript could not be converted", error);
+}
+function sameJson(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  const left = a;
+  const right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(right, key) && sameJson(left[key], right[key])
+  );
+}
+function steadyStepObjects() {
+  let held = /* @__PURE__ */ new Map();
+  return (transcript) => {
+    const next = /* @__PURE__ */ new Map();
+    let kept = false;
+    const steadied = transcript.map((entry) => {
+      const id = entry.id;
+      if (typeof id !== "string") return entry;
+      const before = held.get(id);
+      const step = before !== void 0 && sameJson(before, entry) ? before : entry;
+      next.set(id, step);
+      if (step !== entry) kept = true;
+      return step;
+    });
+    held = next;
+    return kept ? steadied : transcript;
+  };
+}
+function createSubagentLaneConversion() {
+  const memory = createSubagentTranscriptConversionCache();
+  const steady = steadyStepObjects();
+  let last = null;
+  return (transcript, running) => {
+    if (last !== null && last.transcript === transcript && last.running === running) {
+      return last.messages;
+    }
+    let messages;
+    try {
+      messages = memory.convert(transcriptSources(steady(transcript)), running);
+    } catch (error) {
+      reportUnconvertibleTranscript(transcript, error);
+    }
+    last = { transcript, running, messages };
+    return messages;
+  };
+}
+function subagentTranscriptAttacher() {
+  const lanes = /* @__PURE__ */ new Map();
+  const attachedRows = /* @__PURE__ */ new WeakMap();
+  const attachedParts = /* @__PURE__ */ new WeakMap();
+  const laneMessages = (toolCallId, transcript, running) => {
+    let lane = lanes.get(toolCallId);
+    if (lane === void 0) {
+      lane = createSubagentLaneConversion();
+      lanes.set(toolCallId, lane);
+    }
+    return lane(transcript, running);
+  };
+  const attach = (row) => {
+    if (row.role !== "assistant") return row;
+    const cached = attachedRows.get(row);
+    if (cached !== void 0) return cached;
+    let content = null;
+    for (const [index, part] of row.content.entries()) {
+      if (part.type !== "tool-call" || part.toolName !== TASK_TOOL_NAME) continue;
+      const nested = laneTranscriptOf(part.artifact);
+      if (nested === void 0) continue;
+      const running = part.isPreliminary === true;
+      const restored = withRepeatedResult(nested, part.result);
+      const transcript = running || part.isError === true ? restored : withLaneReport(restored, getMessageText({ content: part.result }));
+      const messages = laneMessages(part.toolCallId, transcript, running);
+      if (messages === void 0) continue;
+      const kept = attachedParts.get(part);
+      const attached = kept !== void 0 && kept.messages === messages ? kept.part : { ...part, messages };
+      attachedParts.set(part, { messages, part: attached });
+      content ?? (content = [...row.content]);
+      content[index] = attached;
+    }
+    const attachedRow = content === null ? row : { ...row, content };
+    attachedRows.set(row, attachedRow);
+    return attachedRow;
+  };
+  return (rows) => {
+    const attached = rows.map(attach);
+    if (lanes.size === 0) return attached;
+    const held = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      if (row.role !== "assistant") continue;
+      for (const part of row.content) {
+        if (part.type !== "tool-call" || part.toolName !== TASK_TOOL_NAME) continue;
+        held.add(part.toolCallId);
+      }
+    }
+    for (const toolCallId of lanes.keys()) {
+      if (!held.has(toolCallId)) lanes.delete(toolCallId);
+    }
+    return attached;
+  };
+}
+function createSubagentTranscriptConversionCache() {
+  const thread = createDeepAgentMessageConversionCache();
+  const attach = subagentTranscriptAttacher();
+  let previousRows = null;
+  let previous = [];
+  return {
+    convert(messages, isRunning) {
+      const rows = thread.convert(messages, isRunning);
+      if (rows === previousRows) return previous;
+      previousRows = rows;
+      const next = attach(rows);
+      const unchanged = next.length === previous.length && next.every((row, index) => row === previous[index]);
+      if (!unchanged) previous = next;
+      return previous;
+    }
+  };
+}
+createExternalMessageConversionCache();
+export {
+  createSubagentLaneConversion,
+  createSubagentTranscriptConversionCache,
+  withLaneReport,
+  withRepeatedResult
+};
+//# sourceMappingURL=subagent-transcripts.js.map

package/dist/agent-runtime/src/subagent-transcripts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-transcripts.js","sources":["../../../../agent-runtime/src/subagent-transcripts.ts"],"sourcesContent":["/**\n * A subagent's transcript as assistant-ui's native nested thread.\n *\n * The backend nests a `task` subagent's transcript in its card's ToolMessage,\n * at `artifact.subgraph_state.messages`: the newest steps on the running\n * placeholder, the whole transcript on the real result. The conversion cache\n * built here converts that transcript through the thread's own pipeline and\n * sets it as the `task` tool-call part's `messages`, assistant-ui's channel for\n * a tool call's nested conversation. `ReadonlyThreadProvider` (the provider\n * under `MessagePartPrimitive.Messages`) renders it as a read-only thread under\n * the parent's tool UIs, and `thread.tasks` derives child work from it.\n *\n * Hosts opt in (`useDeepAgentThread({ createConversionCache })`). It builds on\n * the shared conversion memory from outside, so the shared converter, which\n * ships in every surface's startup bundle (the Office pane's startup and total\n * budgets have no room to spare), stays as it is, and a surface that draws no\n * subagent transcript pays nothing for it.\n */\nimport type {\n  ThreadAssistantMessagePart,\n  ThreadMessage,\n  ToolCallMessagePart,\n} from '@assistant-ui/core';\nimport {\n  convertExternalMessages,\n  createExternalMessageConversionCache,\n} from '@assistant-ui/core/react';\nimport type { LangChainMessage } from '@assistant-ui/react-langgraph';\nimport { DEEP_AGENT_REPEATS_RESULT_KEY } from './generated/runconfig-contract';\nimport { getMessageText } from './message-text';\nimport {\n  convertDeepAgentLangChainMessage,\n  createDeepAgentMessageConversionCache,\n  type DeepAgentConversionMemory,\n  markPreliminaryToolResults,\n  sanitizeLangChainMessages,\n} from './messages';\nimport { TASK_TOOL_NAME } from './tool-names';\n\n/** The transcript nested on a `task` card's artifact, or `undefined` when it carries none. */\nfunction laneTranscriptOf(artifact: unknown): readonly LangChainMessage[] | undefined {\n  if (typeof artifact !== 'object' || artifact === null) return undefined;\n  const state: unknown = (artifact as { subgraph_state?: unknown }).subgraph_state;\n  if (typeof state !== 'object' || state === null) return undefined;\n  const messages: unknown = (state as { messages?: unknown }).messages;\n  return Array.isArray(messages) ? (messages as LangChainMessage[]) : undefined;\n}\n\nconst restoredTranscripts = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly content: unknown; readonly transcript: readonly LangChainMessage[] }\n>();\n\n/**\n * A card's nested transcript with its report restored. On a cut finished card\n * the last step can ride with empty content and `DEEP_AGENT_REPEATS_RESULT_KEY`:\n * its text is the subagent's report, the card's own `content`, which the card\n * carries anyway. The step gets that content back. Any other transcript comes\n * back as it is. Memoized per transcript, so a lane's conversion sees one array.\n */\nexport function withRepeatedResult(\n  transcript: readonly LangChainMessage[],\n  content: unknown\n): readonly LangChainMessage[] {\n  const last = transcript[transcript.length - 1];\n  if (\n    last === undefined ||\n    (last as Record<string, unknown>)[DEEP_AGENT_REPEATS_RESULT_KEY] !== true ||\n    (typeof content !== 'string' && !Array.isArray(content))\n  ) {\n    return transcript;\n  }\n  const cached = restoredTranscripts.get(transcript);\n  if (cached !== undefined && cached.content === content) return cached.transcript;\n  const restored = [...transcript.slice(0, -1), { ...last, content } as LangChainMessage];\n  restoredTranscripts.set(transcript, { content, transcript: restored });\n  return restored;\n}\n\ntype AssistantLangChainMessage = Extract<LangChainMessage, { type: 'ai' }>;\n\nconst convertibleChunkTurns = new WeakMap<LangChainMessage, LangChainMessage>();\n\n/**\n * A nested assistant turn stored under the chunk class name (the legacy\n * assistant-stream fold keeps `AIMessageChunk`) as the `ai` message it is: the\n * shipped converter maps only `ai`, and would drop the turn.\n */\nfunction asConvertibleTurn(message: LangChainMessage): LangChainMessage {\n  const type: string = message.type;\n  if (type !== 'AIMessageChunk') return message;\n  const cached = convertibleChunkTurns.get(message);\n  if (cached !== undefined) return cached;\n  const turn: LangChainMessage = { ...(message as AssistantLangChainMessage), type: 'ai' };\n  convertibleChunkTurns.set(message, turn);\n  return turn;\n}\n\n/** A lane step as the assistant turn it is when it calls nothing; `null` for any other step. */\nfunction answeringTurn(step: LangChainMessage): AssistantLangChainMessage | null {\n  const turn = asConvertibleTurn(step);\n  return turn.type === 'ai' && (turn.tool_calls?.length ?? 0) === 0 ? turn : null;\n}\n\nconst isTextBlock = (block: unknown): block is { type: 'text'; text?: unknown } =>\n  typeof block === 'object' && block !== null && 'type' in block && block.type === 'text';\n\n/** The text a step's content shows: the string, or its text blocks joined. */\nfunction shownText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  let text = '';\n  for (const block of content) {\n    if (isTextBlock(block) && typeof block.text === 'string') text += block.text;\n  }\n  return text;\n}\n\n/** A turn that calls nothing and shows nothing: no text, and no block of another kind. */\nfunction blankTurn(step: LangChainMessage): AssistantLangChainMessage | null {\n  const turn = answeringTurn(step);\n  if (turn === null || shownText(turn.content).trim() !== '') return null;\n  return typeof turn.content === 'string' || turn.content.every(isTextBlock) ? turn : null;\n}\n\nconst reportedLanes = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly report: string; readonly transcript: readonly LangChainMessage[] }\n>();\n\n/**\n * A finished lane's transcript, closed by its report. A `task` card's content\n * is its subagent's report, the text of the lane's last turn. A transcript\n * that ends on that turn (an assistant step that calls nothing and says\n * something, which {@link withRepeatedResult} restores when it rides marked)\n * comes back as it is, even when blank steps follow it. A lane stored without\n * it shows the report as its closing answer: a lane whose last step is a blank\n * assistant step (lanes that finished before the host marked a repeated\n * report) gets the report in that step, its id and stamps kept, and a lane\n * that ends on a tool result or a turn that calls tools gets a closing step\n * after its last one. An empty report or transcript changes nothing. For\n * display only: the wire and the stored lane are untouched. Memoized per\n * transcript, so a lane's conversion sees one array.\n */\nexport function withLaneReport(\n  transcript: readonly LangChainMessage[],\n  report: string | undefined\n): readonly LangChainMessage[] {\n  if (report === undefined || report.trim() === '' || transcript.length === 0) return transcript;\n  // The lane's closing turn: its last step past any blank ones.\n  let at = transcript.length - 1;\n  let closing = transcript[at];\n  while (closing !== undefined && blankTurn(closing) !== null) {\n    at -= 1;\n    closing = transcript[at];\n  }\n  const answered =\n    closing !== undefined &&\n    answeringTurn(closing) !== null &&\n    shownText(closing.content).trim() !== '';\n  if (answered) return transcript;\n  const cached = reportedLanes.get(transcript);\n  if (cached !== undefined && cached.report === report) return cached.transcript;\n  const last = transcript[transcript.length - 1];\n  const blank = last === undefined ? null : blankTurn(last);\n  const closed: readonly LangChainMessage[] =\n    blank !== null\n      ? [...transcript.slice(0, -1), { ...blank, content: report }]\n      : [...transcript, { id: `${last?.id ?? 'lane'}:report`, type: 'ai', content: report }];\n  reportedLanes.set(transcript, { report, transcript: closed });\n  return closed;\n}\n\n/** A nested transcript as the thread's own pipeline reads it (see {@link sanitizeLangChainMessages}). */\nfunction transcriptSources(transcript: readonly LangChainMessage[]): LangChainMessage[] {\n  return sanitizeLangChainMessages(transcript.map(asConvertibleTurn));\n}\n\nconst reportedTranscripts = new WeakSet<readonly LangChainMessage[]>();\n\n/**\n * A nested transcript the shipped converter refused (it throws on, e.g., a\n * result whose tool name differs from its call's): reported once, and its card\n * goes without a nested thread instead of taking the whole thread down.\n */\nfunction reportUnconvertibleTranscript(\n  transcript: readonly LangChainMessage[],\n  error: unknown\n): void {\n  if (reportedTranscripts.has(transcript)) return;\n  reportedTranscripts.add(transcript);\n  console.warn('[agent-runtime] a subagent transcript could not be converted', error);\n}\n\n/** Whether two values the wire carries (JSON: no functions, no cycles) are equal. */\nfunction sameJson(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  if (Array.isArray(a) || Array.isArray(b)) {\n    return (\n      Array.isArray(a) &&\n      Array.isArray(b) &&\n      a.length === b.length &&\n      a.every((item, index) => sameJson(item, b[index]))\n    );\n  }\n  const left = a as Record<string, unknown>;\n  const right = b as Record<string, unknown>;\n  const keys = Object.keys(left);\n  return (\n    keys.length === Object.keys(right).length &&\n    keys.every(\n      (key) =>\n        Object.prototype.hasOwnProperty.call(right, key) && sameJson(left[key], right[key])\n    )\n  );\n}\n\n/**\n * Keeps a lane's unchanged steps as the objects it already converted. The host\n * replaces a card's whole document whenever the card changes, so every step it\n * carries arrives as a new object, and the conversion memory, which tells the\n * steps a turn continues by object, would see a new turn each time the card's\n * cut drops its oldest step and the turn's first step changes. A step whose id\n * and content are unchanged is the object held for that id. O(the steps' size).\n */\nfunction steadyStepObjects(): (\n  transcript: readonly LangChainMessage[]\n) => readonly LangChainMessage[] {\n  let held = new Map<string, LangChainMessage>();\n  return (transcript) => {\n    const next = new Map<string, LangChainMessage>();\n    let kept = false;\n    const steadied = transcript.map((entry) => {\n      const id = entry.id;\n      if (typeof id !== 'string') return entry;\n      const before = held.get(id);\n      const step = before !== undefined && sameJson(before, entry) ? before : entry;\n      next.set(id, step);\n      if (step !== entry) kept = true;\n      return step;\n    });\n    held = next;\n    return kept ? steadied : transcript;\n  };\n}\n\n/** One lane's transcript, converted: `undefined` when the converter refused it. */\nexport type SubagentLaneConversion = (\n  transcript: readonly LangChainMessage[],\n  running: boolean\n) => readonly ThreadMessage[] | undefined;\n\n/**\n * One `task` lane's own conversion memory, for whatever converts that lane:\n * its unchanged steps keep their converted objects while it streams (a step the\n * wire sends again unchanged included, see {@link steadyStepObjects}), and its\n * turn keeps its row key (`deepAgentRowKey`) and part keys when the turn's head\n * moves — the oldest steps of a cut card falling off as the lane runs, or older\n * steps a transcript drawer pages in. A surface that keeps its disclosures under\n * that key keeps them open through both. A transcript array converted last time\n * is not converted again.\n */\nexport function createSubagentLaneConversion(): SubagentLaneConversion {\n  const memory = createSubagentTranscriptConversionCache();\n  const steady = steadyStepObjects();\n  let last: {\n    readonly transcript: readonly LangChainMessage[];\n    readonly running: boolean;\n    readonly messages: readonly ThreadMessage[] | undefined;\n  } | null = null;\n  return (transcript, running) => {\n    if (last !== null && last.transcript === transcript && last.running === running) {\n      return last.messages;\n    }\n    let messages: readonly ThreadMessage[] | undefined;\n    try {\n      messages = memory.convert(transcriptSources(steady(transcript)), running);\n    } catch (error) {\n      reportUnconvertibleTranscript(transcript, error);\n    }\n    last = { transcript, running, messages };\n    return messages;\n  };\n}\n\n/**\n * Sets each `task` part of a pass's converted rows to carry its nested\n * transcript as `messages`, for one attach. Each lane has its own conversion\n * memory, so its unchanged steps keep their converted objects while it\n * streams, as the thread's own messages do, and a lane whose transcript array\n * did not change is not converted again. A row, and a part whose lane did not\n * change, keep their identity: the same row always comes back as the same\n * object. A lane's memory lives only while a row of the pass holds its `task`\n * call: a lane a rewind removes, a branch switch hides or the window leaves\n * behind is let go with its transcript, and converted afresh if it returns.\n */\nfunction subagentTranscriptAttacher(): (rows: readonly ThreadMessage[]) => ThreadMessage[] {\n  const lanes = new Map<string, SubagentLaneConversion>();\n  const attachedRows = new WeakMap<ThreadMessage, ThreadMessage>();\n  const attachedParts = new WeakMap<\n    ToolCallMessagePart,\n    { readonly messages: readonly ThreadMessage[]; readonly part: ToolCallMessagePart }\n  >();\n\n  const laneMessages = (\n    toolCallId: string,\n    transcript: readonly LangChainMessage[],\n    running: boolean\n  ): readonly ThreadMessage[] | undefined => {\n    let lane = lanes.get(toolCallId);\n    if (lane === undefined) {\n      lane = createSubagentLaneConversion();\n      lanes.set(toolCallId, lane);\n    }\n    return lane(transcript, running);\n  };\n\n  const attach = (row: ThreadMessage): ThreadMessage => {\n    if (row.role !== 'assistant') return row;\n    const cached = attachedRows.get(row);\n    if (cached !== undefined) return cached;\n    let content: ThreadAssistantMessagePart[] | null = null;\n    for (const [index, part] of row.content.entries()) {\n      if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n      const nested = laneTranscriptOf(part.artifact);\n      if (nested === undefined) continue;\n      // A running lane's placeholder is preliminary: its newest nested turn streams.\n      const running = part.isPreliminary === true;\n      const restored = withRepeatedResult(nested, part.result);\n      const transcript =\n        running || part.isError === true\n          ? restored\n          : withLaneReport(restored, getMessageText({ content: part.result }));\n      const messages = laneMessages(part.toolCallId, transcript, running);\n      if (messages === undefined) continue;\n      const kept = attachedParts.get(part);\n      const attached =\n        kept !== undefined && kept.messages === messages ? kept.part : { ...part, messages };\n      attachedParts.set(part, { messages, part: attached });\n      content ??= [...row.content];\n      content[index] = attached;\n    }\n    const attachedRow: ThreadMessage = content === null ? row : { ...row, content };\n    attachedRows.set(row, attachedRow);\n    return attachedRow;\n  };\n\n  return (rows) => {\n    const attached = rows.map(attach);\n    if (lanes.size === 0) return attached;\n    const held = new Set<string>();\n    for (const row of rows) {\n      if (row.role !== 'assistant') continue;\n      for (const part of row.content) {\n        if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n        held.add(part.toolCallId);\n      }\n    }\n    for (const toolCallId of lanes.keys()) {\n      if (!held.has(toolCallId)) lanes.delete(toolCallId);\n    }\n    return attached;\n  };\n}\n\n/**\n * A conversion memory for one attach (see\n * `useDeepAgentThread({ createConversionCache })`): the shared one's rows, with\n * each `task` tool-call part carrying its subagent's converted transcript as\n * `messages`. A pass that changes no row hands back the previous list itself.\n */\nexport function createSubagentTranscriptConversionCache(): DeepAgentConversionMemory {\n  const thread = createDeepAgentMessageConversionCache();\n  const attach = subagentTranscriptAttacher();\n  let previousRows: ThreadMessage[] | null = null;\n  let previous: ThreadMessage[] = [];\n  return {\n    convert(messages, isRunning) {\n      const rows = thread.convert(messages, isRunning);\n      if (rows === previousRows) return previous;\n      previousRows = rows;\n      const next = attach(rows);\n      const unchanged =\n        next.length === previous.length && next.every((row, index) => row === previous[index]);\n      if (!unchanged) previous = next;\n      return previous;\n    },\n  };\n}\n\n/**\n * Shared by every in-eval transcript: entries are keyed by source message, so\n * none outlives the wire state holding it and threads cannot collide.\n */\nconst inEvalTranscriptCache = createExternalMessageConversionCache();\nconst IN_EVAL_TRANSCRIPT_METADATA = {};\nconst inEvalTranscripts = new WeakMap<\n  readonly LangChainMessage[],\n  { readonly running: boolean; readonly messages: readonly ThreadMessage[] }\n>();\n\nconst NO_MESSAGES: readonly ThreadMessage[] = [];\n\n/**\n * An in-eval dispatch's live transcript (a `ptc_subagents` entry's `messages`)\n * as a nested thread, converted like a `task` lane's. Memoized per transcript\n * array; a step the lane did not change keeps its converted object. A\n * transcript the converter refuses reads as empty.\n */\nexport function convertSubagentTranscript(\n  transcript: readonly LangChainMessage[],\n  running: boolean\n): readonly ThreadMessage[] {\n  const cached = inEvalTranscripts.get(transcript);\n  if (cached !== undefined && cached.running === running) return cached.messages;\n  let messages: readonly ThreadMessage[] = NO_MESSAGES;\n  try {\n    messages = convertExternalMessages(\n      transcriptSources(transcript),\n      convertDeepAgentLangChainMessage,\n      running,\n      IN_EVAL_TRANSCRIPT_METADATA,\n      inEvalTranscriptCache\n    ).map(markPreliminaryToolResults);\n  } catch (error) {\n    reportUnconvertibleTranscript(transcript, error);\n  }\n  inEvalTranscripts.set(transcript, { running, messages });\n  return messages;\n}\n"],"names":[],"mappings":"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"}

package/dist/agent-runtime/src/subagents.cjs

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@assistant-ui/core");
+const store = require("@assistant-ui/store");
+const react = require("react");
+const runconfigContract = require("./generated/runconfig-contract.cjs");
+const messageText = require("./message-text.cjs");
+const subagentTranscripts = require("./subagent-transcripts.cjs");
+const toolNames = require("./tool-names.cjs");
+function isTerminalSubagentStatus(status) {
+  return status === "complete" || status === "error";
+}
+function subagentNameFromArgs(args) {
+  if (!args) return "subagent";
+  return String(args.subagent_type ?? args.subagentType ?? args.subagent ?? "subagent");
+}
+function nestedMessagesFromArtifact(artifact) {
+  var _a;
+  const a = artifact;
+  return ((_a = a == null ? void 0 : a.subgraph_state) == null ? void 0 : _a.messages) ?? [];
+}
+const isCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+function readTruncatedLane(toolMessage) {
+  if (typeof toolMessage !== "object" || toolMessage === null) return null;
+  const marker = toolMessage[runconfigContract.DEEP_AGENT_TRUNCATED_LANE_KEY];
+  if (typeof marker !== "object" || marker === null) return null;
+  const { messages, tool_calls: toolCalls, finished } = marker;
+  return isCount(messages) && isCount(toolCalls) ? { messages, toolCalls, finished: finished === true } : null;
+}
+function readLaneUsage(wire) {
+  if (typeof wire !== "object" || wire === null) return null;
+  const usage = wire[runconfigContract.DEEP_AGENT_LANE_USAGE_KEY];
+  if (typeof usage !== "object" || usage === null) return null;
+  const { input_tokens: inputTokens, output_tokens: outputTokens } = usage;
+  return isCount(inputTokens) && isCount(outputTokens) ? { inputTokens, outputTokens } : null;
+}
+function laneTokenUsage(wire, steps, status, cut) {
+  const settled = isTerminalSubagentStatus(status);
+  const whole = readLaneUsage(wire);
+  if (whole !== null) return { ...whole, partial: !settled };
+  return steps === void 0 ? void 0 : { ...steps, partial: !settled || cut };
+}
+const transcriptStepUsageCache = /* @__PURE__ */ new WeakMap();
+function transcriptStepUsage(messages) {
+  const cached = transcriptStepUsageCache.get(messages);
+  if (cached !== void 0) return cached ?? void 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let counted = false;
+  for (const message of messages) {
+    for (const step of message.metadata.steps ?? []) {
+      if (step.usage === void 0) continue;
+      inputTokens += step.usage.inputTokens;
+      outputTokens += step.usage.outputTokens;
+      counted = true;
+    }
+  }
+  const usage = counted ? { inputTokens, outputTokens } : null;
+  transcriptStepUsageCache.set(messages, usage);
+  return usage ?? void 0;
+}
+function nestedTodosFromArtifact(artifact) {
+  var _a;
+  const a = artifact;
+  const todos = (_a = a == null ? void 0 : a.subgraph_state) == null ? void 0 : _a.todos;
+  return Array.isArray(todos) ? todos : void 0;
+}
+const EMPTY_TRANSCRIPT_DERIVATION = {
+  currentText: "",
+  model: void 0,
+  lastToolCall: void 0,
+  toolCallCount: 0,
+  todos: void 0
+};
+const transcriptDerivationCache = /* @__PURE__ */ new WeakMap();
+function deriveTranscript(transcript) {
+  var _a, _b;
+  if (transcript.length === 0) return EMPTY_TRANSCRIPT_DERIVATION;
+  const cached = transcriptDerivationCache.get(transcript);
+  if (cached !== void 0) return cached;
+  let currentText = "";
+  let model;
+  let lastToolCall;
+  let toolCallCount = 0;
+  let todos;
+  for (const message of transcript) {
+    if (message.role !== "assistant") continue;
+    const turnModel = (_b = (_a = message.metadata) == null ? void 0 : _a.custom) == null ? void 0 : _b.model;
+    if (typeof turnModel === "string" && turnModel) model = turnModel;
+    for (const part of message.content) {
+      if (part.type === "text") {
+        if (part.text) currentText = part.text;
+        continue;
+      }
+      if (part.type !== "tool-call") continue;
+      toolCallCount += 1;
+      lastToolCall = { id: part.toolCallId, name: part.toolName, args: part.args };
+      if (part.toolName !== "write_todos") continue;
+      const list = part.args.todos;
+      if (Array.isArray(list)) todos = list;
+    }
+  }
+  const derivation = {
+    currentText,
+    model,
+    lastToolCall,
+    toolCallCount,
+    todos
+  };
+  transcriptDerivationCache.set(transcript, derivation);
+  return derivation;
+}
+const NO_TRANSCRIPT = [];
+function taskSubagent(part, toolMessage) {
+  const args = part.args;
+  const transcript = part.messages ?? NO_TRANSCRIPT;
+  const derived = deriveTranscript(transcript);
+  const messageCount = nestedMessagesFromArtifact(part.artifact).length;
+  const lane = readTruncatedLane(toolMessage);
+  const todos = nestedTodosFromArtifact(part.artifact);
+  const status = part.result === void 0 ? "queued" : part.isPreliminary === true ? "running" : part.isError === true ? "error" : "complete";
+  const usage = laneTokenUsage(
+    toolMessage,
+    transcriptStepUsage(transcript),
+    status,
+    lane !== null && lane.messages > messageCount
+  );
+  return {
+    id: part.toolCallId,
+    name: subagentNameFromArgs(args),
+    description: typeof args.description === "string" ? args.description : "",
+    status,
+    ...part.result !== void 0 && { output: messageText.getMessageText({ content: part.result }) },
+    toolCallCount: Math.max(derived.toolCallCount, (lane == null ? void 0 : lane.toolCalls) ?? 0),
+    messages: transcript,
+    messageCount,
+    ...lane !== null && { omittedMessageCount: Math.max(0, lane.messages - messageCount) },
+    ...typeof (toolMessage == null ? void 0 : toolMessage.id) === "string" && {
+      source: {
+        messageId: toolMessage.id,
+        transcript: subagentTranscripts.withRepeatedResult(nestedMessagesFromArtifact(part.artifact), part.result),
+        ...lane !== null && { truncated: lane }
+      }
+    },
+    ...todos !== void 0 && { todos },
+    ...derived.lastToolCall !== void 0 && { lastToolCall: derived.lastToolCall },
+    currentText: derived.currentText,
+    ...derived.model !== void 0 && { model: derived.model },
+    ...usage !== void 0 && { usage }
+  };
+}
+function toolMessagesOfTurn(message) {
+  const byCall = /* @__PURE__ */ new Map();
+  for (const source of core.getExternalStoreMessages(message)) {
+    if (source.type === "tool") byCall.set(source.tool_call_id, source);
+  }
+  return byCall;
+}
+const taskSubagentByPart = /* @__PURE__ */ new WeakMap();
+const taskSubagentsByTurn = /* @__PURE__ */ new WeakMap();
+function taskSubagentsOfTurn(message) {
+  const cached = taskSubagentsByTurn.get(message);
+  if (cached !== void 0) return cached;
+  const lanes = /* @__PURE__ */ new Map();
+  if (message.role === "assistant") {
+    let toolMessages = null;
+    for (const part of message.content) {
+      if (part.type !== "tool-call" || part.toolName !== toolNames.TASK_TOOL_NAME) continue;
+      let lane = taskSubagentByPart.get(part);
+      if (lane === void 0) {
+        toolMessages ?? (toolMessages = toolMessagesOfTurn(message));
+        lane = taskSubagent(part, toolMessages.get(part.toolCallId));
+        taskSubagentByPart.set(part, lane);
+      }
+      lanes.set(part.toolCallId, lane);
+    }
+  }
+  taskSubagentsByTurn.set(message, lanes);
+  return lanes;
+}
+function findToolCall({
+  messages,
+  toolCallIds
+}) {
+  if (messages === void 0) return void 0;
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    for (const part of message.content) {
+      if (part.type === "tool-call" && toolCallIds.has(part.toolCallId)) return part;
+    }
+  }
+  return void 0;
+}
+function subagentAwaitingApproval({
+  lane,
+  toolCallIds
+}) {
+  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return false;
+  return toolCallIds.has(lane.id) || findToolCall({ messages: lane.messages, toolCallIds }) !== void 0;
+}
+function subagentToolCallAwaitingApproval({
+  lane,
+  toolCallIds
+}) {
+  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return void 0;
+  const part = findToolCall({ messages: lane.messages, toolCallIds });
+  return part === void 0 ? void 0 : { id: part.toolCallId, name: part.toolName, args: part.args };
+}
+function turnToolCallsAwaitingApproval({
+  message,
+  toolCallIds
+}) {
+  if (toolCallIds.size === 0 || message.role !== "assistant") return [];
+  const ids = [];
+  for (const part of message.content) {
+    if (part.type !== "tool-call") continue;
+    if (toolCallIds.has(part.toolCallId)) {
+      ids.push(part.toolCallId);
+      continue;
+    }
+    if (part.toolName !== toolNames.TASK_TOOL_NAME) continue;
+    const settled = part.result !== void 0 && part.isPreliminary !== true;
+    if (!settled && findToolCall({ messages: part.messages, toolCallIds }) !== void 0) {
+      ids.push(part.toolCallId);
+    }
+  }
+  return ids;
+}
+const NO_WAITING_TOOL_CALLS = /* @__PURE__ */ new Set();
+const TOOL_CALL_ID_SEPARATOR = "\n";
+function useTurnToolCallsAwaitingApproval(toolCallIds) {
+  const key = store.useAuiState(
+    (s) => toolCallIds.size === 0 ? "" : turnToolCallsAwaitingApproval({ message: s.message, toolCallIds }).join(
+      TOOL_CALL_ID_SEPARATOR
+    )
+  );
+  return react.useMemo(
+    () => key === "" ? NO_WAITING_TOOL_CALLS : new Set(key.split(TOOL_CALL_ID_SEPARATOR)),
+    [key]
+  );
+}
+exports.isTerminalSubagentStatus = isTerminalSubagentStatus;
+exports.nestedMessagesFromArtifact = nestedMessagesFromArtifact;
+exports.nestedTodosFromArtifact = nestedTodosFromArtifact;
+exports.readLaneUsage = readLaneUsage;
+exports.readTruncatedLane = readTruncatedLane;
+exports.subagentAwaitingApproval = subagentAwaitingApproval;
+exports.subagentToolCallAwaitingApproval = subagentToolCallAwaitingApproval;
+exports.taskSubagentsOfTurn = taskSubagentsOfTurn;
+exports.transcriptStepUsage = transcriptStepUsage;
+exports.turnToolCallsAwaitingApproval = turnToolCallsAwaitingApproval;
+exports.useTurnToolCallsAwaitingApproval = useTurnToolCallsAwaitingApproval;
+//# sourceMappingURL=subagents.cjs.map

package/dist/agent-runtime/src/subagents.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.cjs","sources":["../../../../agent-runtime/src/subagents.ts"],"sourcesContent":["/**\n * Subagent discovery: every subagent lane a deep-agent thread has spawned, as\n * the card view model the surfaces that draw subagent lanes render. Two\n * dispatch paths feed lanes keyed by dispatch id:\n *\n * - top-level `task` tool calls, read from the call's own tool-call part\n *   ({@link taskSubagentsOfTurn}): the part's result and `isPreliminary` say\n *   where the lane is, and its `messages` (the nested thread\n *   `createSubagentTranscriptConversionCache` converts) are the transcript;\n * - in-eval `task()` dispatches ({@link deriveEvalSubagents}), whose only\n *   signals are the live `ptc_subagents` state channel and the summaries a\n *   finished `eval` ToolMessage persists in `artifact.ptc_subagents`.\n */\nimport {\n  getExternalStoreMessages,\n  type ThreadMessage,\n  type ToolCallMessagePart,\n} from '@assistant-ui/core';\nimport type { LangChainMessage, LangChainToolCall } from '@assistant-ui/react-langgraph';\nimport { useAuiState } from '@assistant-ui/store';\nimport { useMemo } from 'react';\nimport {\n  DEEP_AGENT_LANE_USAGE_KEY,\n  DEEP_AGENT_TRUNCATED_LANE_KEY,\n} from './generated/runconfig-contract';\nimport { getMessageText } from './message-text';\nimport { convertSubagentTranscript, withRepeatedResult } from './subagent-transcripts';\nimport { EVAL_TOOL_NAME, TASK_TOOL_NAME } from './tool-names';\nimport type { PtcSubagentEntry, Todo } from './types';\n\n/**\n * Where a subagent lane is:\n *\n * - `queued` — the dispatch has not started: a `task` call with no result yet\n *   (waiting for a dispatch slot or an approval; the backend shows the running\n *   card once the dispatch holds its slot), or an in-eval dispatch waiting for\n *   one of the bridge's concurrency slots.\n * - `running` — a `task` call's result is still the backend's running\n *   placeholder (its part is `isPreliminary`), and the nested transcript fills\n *   in live; or an in-eval dispatch's lifecycle says it runs.\n * - `complete` / `error` — the real result replaced the placeholder; `error`\n *   when it is an error result.\n */\nexport type SubagentStatus = 'queued' | 'running' | 'complete' | 'error';\n\n/** True for the settled lifecycle states (`complete` / `error`). */\nexport function isTerminalSubagentStatus(status: SubagentStatus): boolean {\n  return status === 'complete' || status === 'error';\n}\n\n/** Aggregate lane lifecycle counts for one fan-out (orchestration strip + header chip). */\nexport interface SubagentStatusCounts {\n  total: number;\n  queued: number;\n  running: number;\n  complete: number;\n  failed: number;\n  /** complete + failed — the settled count progress displays use. */\n  terminal: number;\n}\n\nexport function countSubagentStatuses(\n  snapshots: readonly SubagentDiscoverySnapshot[]\n): SubagentStatusCounts {\n  const counts: SubagentStatusCounts = {\n    total: snapshots.length,\n    queued: 0,\n    running: 0,\n    complete: 0,\n    failed: 0,\n    terminal: 0,\n  };\n  for (const snapshot of snapshots) {\n    if (snapshot.status === 'queued') counts.queued += 1;\n    else if (snapshot.status === 'running') counts.running += 1;\n    else if (snapshot.status === 'complete') counts.complete += 1;\n    else counts.failed += 1;\n  }\n  counts.terminal = counts.complete + counts.failed;\n  return counts;\n}\n\n/**\n * Discovery snapshot for one subagent invocation. Mirrors LangChain's\n * `SubagentDiscoverySnapshot`: `id` is the `task` tool-call id that spawned the\n * subagent (the dispatch id for an in-eval dispatch), so cards nest under the\n * coordinator turn that delegated the work.\n */\nexport interface SubagentDiscoverySnapshot {\n  /** The `task` tool-call id that spawned the subagent. */\n  id: string;\n  /** Subagent type/name, from the `task` call's `subagent_type` arg. */\n  name: string;\n  /** The one-line task brief from the `task` call's `description` arg. */\n  description: string;\n  /** Lifecycle state — see {@link SubagentStatus}. */\n  status: SubagentStatus;\n  /** The call's result text (empty while it is the running placeholder). */\n  output?: string;\n  /** Number of nested tool calls the subagent made. */\n  toolCallCount: number;\n  /**\n   * The subagent's transcript as a nested thread: a `task` part's native\n   * `messages`, or an in-eval dispatch's live transcript converted the same way.\n   */\n  messages: readonly ThreadMessage[];\n  /** Messages in the transcript as the wire carries them, before conversion joins a turn's steps. */\n  messageCount: number;\n  /**\n   * Nested messages the wire left off: a cut card carries its newest steps\n   * ({@link readTruncatedLane}) — a running card always, a finished one on a\n   * version-2 view — and the rest pages in through `history/lane`; an in-eval\n   * dispatch's streamed transcript is cut the same way, running or finished.\n   * Absent when the transcript rides whole.\n   */\n  omittedMessageCount?: number;\n  /**\n   * Where the lane's steps ride, what `history/lane` pages the rest of the lane\n   * under (`useDeepAgentLaneHistory`): a `task` lane's card, an in-eval lane's\n   * registry entry while it streams its steps, or, once they no longer ride,\n   * its subagent checkpoint (`checkpointed`), when agora recorded where that is\n   * (`ns`). Absent for any other in-eval lane with no streamed steps (a summary\n   * written before agora recorded the namespace, an older host).\n   */\n  source?: SubagentLaneSource;\n  /** The subagent's own plan, nested by the backend on the task artifact (`subgraph_state.todos`). */\n  todos?: Todo[];\n  /** The newest tool call in the transcript — the card's \"last action\" ticker. */\n  lastToolCall?: LangChainToolCall;\n  /** The newest assistant text in the transcript — the card's thought preview. */\n  currentText: string;\n  /**\n   * The `eval` tool-call id that dispatched this subagent, when it was spawned\n   * from INSIDE the code interpreter (`task()` in the REPL) rather than by a\n   * top-level `task` tool call. The eval card uses it to render lanes for its\n   * own dispatches.\n   */\n  evalId?: string;\n  /**\n   * Backend-reported runtime for a finished in-eval dispatch (from the terminal\n   * lifecycle event). Authoritative over client-side timing — it survives a page\n   * refresh, where local first-seen timestamps are gone.\n   */\n  durationMs?: number;\n  /** The model that produced the transcript, from its newest assistant turn's model stamp. */\n  model?: string;\n  /**\n   * The lane's token use: the whole lane's as the host counts it\n   * (`DEEP_AGENT_LANE_USAGE_KEY`), else the sum of the native step usage\n   * (`metadata.steps[].usage`) of the steps the transcript holds. Absent while\n   * no step reports any.\n   */\n  usage?: SubagentTokenUsage;\n}\n\n/** A subagent lane's token use. */\nexport interface SubagentTokenUsage {\n  /** Input tokens, the prompt cache's reads and writes included. */\n  readonly inputTokens: number;\n  readonly outputTokens: number;\n  /**\n   * Less than the lane will have used: the lane still runs (its newest step may\n   * not have reported yet), or no host total arrived and the sum covers only\n   * the steps held of a lane cut to its newest ones.\n   */\n  readonly partial: boolean;\n}\n\n/** Input and output tokens of some model calls. */\nexport interface TokenCounts {\n  readonly inputTokens: number;\n  readonly outputTokens: number;\n}\n\nfunction subagentNameFromArgs(args: Readonly<Record<string, unknown>> | undefined): string {\n  if (!args) return 'subagent';\n  return String(args.subagent_type ?? args.subagentType ?? args.subagent ?? 'subagent');\n}\n\n/**\n * The subagent's streamed transcript as the wire carries it, read from a task\n * ToolMessage's `artifact.subgraph_state.messages` (the shape the backend nests\n * it under — see the route's `_subagent_subgraph_state`).\n */\nexport function nestedMessagesFromArtifact(artifact: unknown): LangChainMessage[] {\n  const a = artifact as { subgraph_state?: { messages?: LangChainMessage[] } } | undefined;\n  return a?.subgraph_state?.messages ?? [];\n}\n\n/** What the wire left off a cut `task` card's nested transcript. */\nexport interface TruncatedLane {\n  /** Nested messages the host holds for the lane. */\n  messages: number;\n  /** Tool calls across all of them. */\n  toolCalls: number;\n  /**\n   * The card is a finished lane's, cut for a version-2 view. Only a host that\n   * serves `history/lane` cuts a finished card.\n   */\n  finished: boolean;\n}\n\n/**\n * Where a lane's steps ride, and what `history/lane` pages the rest of them\n * under: a `task` lane's card, by its message id, or an in-eval dispatch's\n * `ptc_subagents` registry entry, by its dispatch id.\n */\nexport type SubagentLaneSource = {\n  /** The steps as the wire carries them (a card's report restored, {@link withRepeatedResult}). */\n  readonly transcript: readonly LangChainMessage[];\n  /** The cut marker; absent while every step rides. */\n  readonly truncated?: TruncatedLane;\n  /**\n   * No steps ride, and `history/lane {lane}` pages the subagent's own steps\n   * from its checkpoint: an in-eval lane a later run in this activation left\n   * only its summary and `ns`, or a reopened session's lane (its registry gone,\n   * the summary its eval persisted records `ns`).\n   */\n  readonly checkpointed?: true;\n} & (\n  | {\n      /** The card's message id: the running placeholder's, then the result's. */\n      readonly messageId: string;\n      readonly lane?: undefined;\n    }\n  | {\n      /** The dispatch id: the in-eval lane's registry key. */\n      readonly lane: string;\n      readonly messageId?: undefined;\n    }\n);\n\nconst isCount = (value: unknown): value is number =>\n  typeof value === 'number' && Number.isInteger(value) && value >= 0;\n\n/**\n * The cut marker off a `task` card's raw wire message: the host carries only\n * the lane's newest nested steps and names the whole transcript here\n * (`DEEP_AGENT_TRUNCATED_LANE_KEY`), on a running card and, for a version-2\n * view, on a finished one. `null` when the transcript rides whole.\n */\nexport function readTruncatedLane(toolMessage: unknown): TruncatedLane | null {\n  if (typeof toolMessage !== 'object' || toolMessage === null) return null;\n  const marker = (toolMessage as Record<string, unknown>)[DEEP_AGENT_TRUNCATED_LANE_KEY];\n  if (typeof marker !== 'object' || marker === null) return null;\n  const { messages, tool_calls: toolCalls, finished } = marker as Record<string, unknown>;\n  return isCount(messages) && isCount(toolCalls)\n    ? { messages, toolCalls, finished: finished === true }\n    : null;\n}\n\n/**\n * The whole lane's token use the host carries on a `task` card's raw wire\n * message or an in-eval lane's `ptc_subagents` entry\n * (`DEEP_AGENT_LANE_USAGE_KEY`), however much of the lane the wire carries.\n * `null` when it carries none (an older host, or no step reported usage).\n */\nexport function readLaneUsage(wire: unknown): TokenCounts | null {\n  if (typeof wire !== 'object' || wire === null) return null;\n  const usage = (wire as Record<string, unknown>)[DEEP_AGENT_LANE_USAGE_KEY];\n  if (typeof usage !== 'object' || usage === null) return null;\n  const { input_tokens: inputTokens, output_tokens: outputTokens } = usage as Record<\n    string,\n    unknown\n  >;\n  return isCount(inputTokens) && isCount(outputTokens) ? { inputTokens, outputTokens } : null;\n}\n\n/**\n * A lane's token use: the host's total when it sent one, else what the native\n * steps of the transcript held add up to, partial while the lane runs or when\n * that transcript is cut. `undefined` while neither counts anything.\n */\nfunction laneTokenUsage(\n  wire: unknown,\n  steps: TokenCounts | undefined,\n  status: SubagentStatus,\n  cut: boolean\n): SubagentTokenUsage | undefined {\n  const settled = isTerminalSubagentStatus(status);\n  const whole = readLaneUsage(wire);\n  if (whole !== null) return { ...whole, partial: !settled };\n  return steps === undefined ? undefined : { ...steps, partial: !settled || cut };\n}\n\nconst transcriptStepUsageCache = new WeakMap<readonly ThreadMessage[], TokenCounts | null>();\n\n/**\n * What the model calls of a converted transcript used, from assistant-ui's\n * native step usage (`metadata.steps[].usage`, one step per model call a turn\n * joined). `undefined` when no step reports usage. Memoized per transcript\n * array, which the conversion caches keep while the transcript is unchanged.\n */\nexport function transcriptStepUsage(messages: readonly ThreadMessage[]): TokenCounts | undefined {\n  const cached = transcriptStepUsageCache.get(messages);\n  if (cached !== undefined) return cached ?? undefined;\n  let inputTokens = 0;\n  let outputTokens = 0;\n  let counted = false;\n  for (const message of messages) {\n    for (const step of message.metadata.steps ?? []) {\n      if (step.usage === undefined) continue;\n      inputTokens += step.usage.inputTokens;\n      outputTokens += step.usage.outputTokens;\n      counted = true;\n    }\n  }\n  const usage = counted ? { inputTokens, outputTokens } : null;\n  transcriptStepUsageCache.set(messages, usage);\n  return usage ?? undefined;\n}\n\n/**\n * The subagent's own plan, read from a task ToolMessage's\n * `artifact.subgraph_state.todos` (the backend mirrors the subagent's isolated\n * `todos` state channel there — see the route's `_forward_subagent_todos`).\n * `undefined` (not `[]`) when the subagent never wrote a plan, so the UI can\n * distinguish \"no plan\" from \"plan with zero items\".\n */\nexport function nestedTodosFromArtifact(artifact: unknown): Todo[] | undefined {\n  const a = artifact as { subgraph_state?: { todos?: unknown } } | undefined;\n  const todos = a?.subgraph_state?.todos;\n  return Array.isArray(todos) ? (todos as Todo[]) : undefined;\n}\n\n/**\n * The persisted in-eval dispatch summaries from an `eval` ToolMessage's\n * `artifact.ptc_subagents` (written by the backend when the eval ends). Unlike\n * the live `ptc_subagents` state channel — which dies with the stream — these\n * survive checkpoint reload, so reopened sessions can still render each\n * dispatch's terminal status, duration, output, and error.\n */\nexport function ptcSubagentsFromArtifact(artifact: unknown): PtcSubagentEntry[] {\n  const a = artifact as { ptc_subagents?: unknown } | undefined;\n  const entries = a?.ptc_subagents;\n  if (!Array.isArray(entries)) return [];\n  return entries.filter(\n    (entry): entry is PtcSubagentEntry =>\n      !!entry &&\n      typeof entry === 'object' &&\n      typeof (entry as { id?: unknown }).id === 'string' &&\n      !!(entry as { id?: string }).id\n  );\n}\n\n/**\n * What one transcript contributes to a lane: the newest assistant text\n * (thought preview), the newest tool call and the count (\"last action\"\n * ticker), the producing model, and the plan recovered from the newest\n * `write_todos` call — the fallback for in-eval lanes, whose isolated `todos`\n * state channel never reaches the wire (the task path nests todos on the\n * artifact instead); the call args carry the same list, so the progress ring\n * can still fill. A pure function of the transcript array.\n */\ninterface TranscriptDerivation {\n  currentText: string;\n  model: string | undefined;\n  lastToolCall: LangChainToolCall | undefined;\n  toolCallCount: number;\n  todos: Todo[] | undefined;\n}\n\nconst EMPTY_TRANSCRIPT_DERIVATION: TranscriptDerivation = {\n  currentText: '',\n  model: undefined,\n  lastToolCall: undefined,\n  toolCallCount: 0,\n  todos: undefined,\n};\n\n/**\n * Per-transcript cache for {@link deriveTranscript}: a lane's converted\n * transcript keeps its array while the lane does not change (the conversion\n * caches hand back the previous array), so only lanes still streaming are\n * read again.\n */\nconst transcriptDerivationCache = new WeakMap<readonly ThreadMessage[], TranscriptDerivation>();\n\nfunction deriveTranscript(transcript: readonly ThreadMessage[]): TranscriptDerivation {\n  if (transcript.length === 0) return EMPTY_TRANSCRIPT_DERIVATION;\n  const cached = transcriptDerivationCache.get(transcript);\n  if (cached !== undefined) return cached;\n  let currentText = '';\n  let model: string | undefined;\n  let lastToolCall: LangChainToolCall | undefined;\n  let toolCallCount = 0;\n  let todos: Todo[] | undefined;\n  for (const message of transcript) {\n    if (message.role !== 'assistant') continue;\n    // A joined turn's `metadata.custom` merges its steps' stamps, the later\n    // step's winning (`joinExternalMessages`), so this is the newest stamp.\n    const turnModel: unknown = message.metadata?.custom?.model;\n    if (typeof turnModel === 'string' && turnModel) model = turnModel;\n    for (const part of message.content) {\n      if (part.type === 'text') {\n        if (part.text) currentText = part.text;\n        continue;\n      }\n      if (part.type !== 'tool-call') continue;\n      toolCallCount += 1;\n      lastToolCall = { id: part.toolCallId, name: part.toolName, args: part.args };\n      if (part.toolName !== 'write_todos') continue;\n      const list: unknown = part.args.todos;\n      if (Array.isArray(list)) todos = list as Todo[];\n    }\n  }\n  const derivation: TranscriptDerivation = {\n    currentText,\n    model,\n    lastToolCall,\n    toolCallCount,\n    todos,\n  };\n  transcriptDerivationCache.set(transcript, derivation);\n  return derivation;\n}\n\nconst NO_TRANSCRIPT: readonly ThreadMessage[] = [];\n\n/**\n * The lane of one `task` tool-call part. `toolMessage` is the raw ToolMessage\n * answering it, which carries the wire's cut marker for a running lane.\n */\nfunction taskSubagent(\n  part: ToolCallMessagePart,\n  toolMessage: LangChainMessage | undefined\n): SubagentDiscoverySnapshot {\n  const args: Readonly<Record<string, unknown>> = part.args;\n  const transcript = part.messages ?? NO_TRANSCRIPT;\n  const derived = deriveTranscript(transcript);\n  const messageCount = nestedMessagesFromArtifact(part.artifact).length;\n  const lane = readTruncatedLane(toolMessage);\n  const todos = nestedTodosFromArtifact(part.artifact);\n  const status: SubagentStatus =\n    part.result === undefined\n      ? 'queued'\n      : part.isPreliminary === true\n        ? 'running'\n        : part.isError === true\n          ? 'error'\n          : 'complete';\n  const usage = laneTokenUsage(\n    toolMessage,\n    transcriptStepUsage(transcript),\n    status,\n    lane !== null && lane.messages > messageCount\n  );\n  return {\n    id: part.toolCallId,\n    name: subagentNameFromArgs(args),\n    description: typeof args.description === 'string' ? args.description : '',\n    status,\n    ...(part.result !== undefined && { output: getMessageText({ content: part.result }) }),\n    toolCallCount: Math.max(derived.toolCallCount, lane?.toolCalls ?? 0),\n    messages: transcript,\n    messageCount,\n    ...(lane !== null && { omittedMessageCount: Math.max(0, lane.messages - messageCount) }),\n    ...(typeof toolMessage?.id === 'string' && {\n      source: {\n        messageId: toolMessage.id,\n        transcript: withRepeatedResult(nestedMessagesFromArtifact(part.artifact), part.result),\n        ...(lane !== null && { truncated: lane }),\n      },\n    }),\n    ...(todos !== undefined && { todos }),\n    ...(derived.lastToolCall !== undefined && { lastToolCall: derived.lastToolCall }),\n    currentText: derived.currentText,\n    ...(derived.model !== undefined && { model: derived.model }),\n    ...(usage !== undefined && { usage }),\n  };\n}\n\n/** The raw ToolMessage answering each tool call of a converted turn, from the sources bound to it. */\nfunction toolMessagesOfTurn(message: ThreadMessage): Map<string, LangChainMessage> {\n  const byCall = new Map<string, LangChainMessage>();\n  for (const source of getExternalStoreMessages<LangChainMessage>(message)) {\n    if (source.type === 'tool') byCall.set(source.tool_call_id, source);\n  }\n  return byCall;\n}\n\n/**\n * Per-part lane cache: a re-converted turn keeps the part object of every call\n * whose ToolMessage did not change (the conversion cache's `keepUnchangedParts`),\n * so a streaming lane re-derives only itself.\n */\nconst taskSubagentByPart = new WeakMap<ToolCallMessagePart, SubagentDiscoverySnapshot>();\nconst taskSubagentsByTurn = new WeakMap<ThreadMessage, ReadonlyMap<string, SubagentDiscoverySnapshot>>();\n\n/**\n * The lane of every `task` call in one converted turn (a `ThreadMessage`, or the\n * message state assistant-ui publishes for it), keyed by tool-call id in call\n * order. Memoized per turn and per part.\n */\nexport function taskSubagentsOfTurn(\n  message: ThreadMessage\n): ReadonlyMap<string, SubagentDiscoverySnapshot> {\n  const cached = taskSubagentsByTurn.get(message);\n  if (cached !== undefined) return cached;\n  const lanes = new Map<string, SubagentDiscoverySnapshot>();\n  if (message.role === 'assistant') {\n    let toolMessages: Map<string, LangChainMessage> | null = null;\n    for (const part of message.content) {\n      if (part.type !== 'tool-call' || part.toolName !== TASK_TOOL_NAME) continue;\n      let lane = taskSubagentByPart.get(part);\n      if (lane === undefined) {\n        toolMessages ??= toolMessagesOfTurn(message);\n        lane = taskSubagent(part, toolMessages.get(part.toolCallId));\n        taskSubagentByPart.set(part, lane);\n      }\n      lanes.set(part.toolCallId, lane);\n    }\n  }\n  taskSubagentsByTurn.set(message, lanes);\n  return lanes;\n}\n\n/** The lane of every `task` call in a converted thread, in transcript order. */\nexport function taskSubagentsOfThread(\n  messages: readonly ThreadMessage[]\n): SubagentDiscoverySnapshot[] {\n  return messages.flatMap((message) => [...taskSubagentsOfTurn(message).values()]);\n}\n\n/**\n * Point a lane at an in-eval dispatch's live transcript, converted into a nested\n * thread, with the live fields it derives. Never regresses a known tool-call\n * count: a countless later event must not reset a lane to \"0 tool calls\".\n */\nfunction applyLaneTranscript(\n  snap: SubagentDiscoverySnapshot,\n  transcript: readonly LangChainMessage[]\n): void {\n  snap.messages = convertSubagentTranscript(transcript, snap.status === 'running');\n  snap.messageCount = transcript.length;\n  const derived = deriveTranscript(snap.messages);\n  if (derived.currentText) snap.currentText = derived.currentText;\n  if (derived.model) snap.model = derived.model;\n  if (derived.lastToolCall) snap.lastToolCall = derived.lastToolCall;\n  snap.toolCallCount = Math.max(snap.toolCallCount, derived.toolCallCount);\n  // An in-eval lane has no artifact todos channel: recover the plan from its\n  // `write_todos` calls.\n  snap.todos = snap.todos ?? derived.todos;\n}\n\n/**\n * The lanes of in-eval dispatches, from two sources: the *persisted* summaries\n * each finished `eval` ToolMessage carries in `artifact.ptc_subagents`\n * (terminal truth; the only source after a session reopen), then the *live*\n * `ptc_subagents` state channel (`ptcSubagents`) for dispatches still\n * streaming. A live entry never downgrades a terminal snapshot back to\n * `running` — a stale lifecycle entry whose terminal event was lost must not\n * resurrect a perpetually-running lane the persisted summary already settled.\n * A lane whose steps no longer ride but whose subagent checkpoint namespace is\n * recorded (`ns`) is `checkpointed`, and `history/lane {lane}` pages its\n * steps: a live entry a later run stripped to its summary, or a persisted\n * summary with no live entry (the registry died with the activation that\n * streamed it). A live entry speaks for its lane over the summary.\n */\nexport function deriveEvalSubagents(\n  messages: readonly LangChainMessage[],\n  ptcSubagents?: Record<string, PtcSubagentEntry>\n): Map<string, SubagentDiscoverySnapshot> {\n  const byDispatchId = new Map<string, SubagentDiscoverySnapshot>();\n  // Persisted in-eval dispatch summaries (terminal truth; survives reopen).\n  for (const m of messages) {\n    if (m.type !== 'tool' || m.name !== EVAL_TOOL_NAME) continue;\n    for (const entry of ptcSubagentsFromArtifact(m.artifact)) {\n      mergePtcSubagentEntry(byDispatchId, entry, {\n        // The eval ended when these summaries were written, so any lane the\n        // backend could not settle is a cancelled dispatch, never \"running\".\n        status: entry.status === 'complete' ? 'complete' : 'error',\n        fallbackEvalId: m.tool_call_id,\n      });\n      noteCheckpointedLane(byDispatchId.get(entry.id), entry);\n    }\n  }\n  // Live lifecycle entries (the only signal while an eval is still streaming).\n  if (ptcSubagents) {\n    for (const entry of Object.values(ptcSubagents)) {\n      if (!entry || typeof entry !== 'object' || typeof entry.id !== 'string' || !entry.id) {\n        continue;\n      }\n      // This activation's registry speaks for the lane: the steps it streams,\n      // else its own namespace, else nothing to page.\n      const existing = byDispatchId.get(entry.id);\n      if (existing?.source?.checkpointed === true) existing.source = undefined;\n      mergePtcSubagentEntry(byDispatchId, entry, {\n        status:\n          entry.status === 'complete'\n            ? 'complete'\n            : entry.status === 'error'\n              ? 'error'\n              : entry.status === 'queued'\n                ? 'queued'\n                : 'running',\n      });\n      noteCheckpointedLane(byDispatchId.get(entry.id), entry);\n    }\n  }\n  return byDispatchId;\n}\n\n/** Lifecycle progression order — a merge may only move a lane forward. */\nfunction subagentStatusRank(status: SubagentStatus): number {\n  if (status === 'queued') return 0;\n  if (status === 'running') return 1;\n  return 2;\n}\n\nfunction mergePtcSubagentEntry(\n  byDispatchId: Map<string, SubagentDiscoverySnapshot>,\n  entry: PtcSubagentEntry,\n  options: { status: SubagentStatus; fallbackEvalId?: string }\n): void {\n  const { status, fallbackEvalId } = options;\n  const existing = byDispatchId.get(entry.id);\n  if (existing) {\n    // A lane only ever moves FORWARD (queued → running → terminal): a stale\n    // entry whose later event was lost must not resurrect a running lane to\n    // queued or a finished lane to running — and a settled terminal outcome\n    // never flips to the other terminal (first settled source wins).\n    if (\n      status === existing.status ||\n      subagentStatusRank(status) > subagentStatusRank(existing.status)\n    ) {\n      existing.status = status;\n    }\n    const evalId = entry.eval_id ?? fallbackEvalId;\n    if (evalId) existing.evalId = evalId;\n    if (typeof entry.duration_ms === 'number') existing.durationMs = entry.duration_ms;\n    // A count only arrives on terminal events; never let a countless later\n    // event (or an older backend) regress a known count.\n    if (typeof entry.tool_call_count === 'number') {\n      existing.toolCallCount = Math.max(existing.toolCallCount, entry.tool_call_count);\n    }\n    if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n      applyLaneTranscript(existing, entry.messages);\n    }\n    applyLaneCut(existing, entry);\n    applyLaneUsage(existing, entry);\n    // Prefer the real output (Athena's in-eval output bridge); fall back to the\n    // error string only when no (non-empty) output was captured. Same\n    // empty-string/nullish rule as the create branch below.\n    if (entry.output) existing.output = entry.output;\n    else if (entry.error && !existing.output) existing.output = entry.error;\n    return;\n  }\n  // `||` (not `??`) so an empty-string output falls back to the error, matching\n  // the merge branch's truthy check above.\n  const initialOutput = entry.output || entry.error;\n  const evalId = entry.eval_id ?? fallbackEvalId;\n  const created: SubagentDiscoverySnapshot = {\n    id: entry.id,\n    name: String(entry.subagent_type ?? 'subagent'),\n    description: entry.label ?? entry.description ?? '',\n    status,\n    toolCallCount: typeof entry.tool_call_count === 'number' ? entry.tool_call_count : 0,\n    messages: NO_TRANSCRIPT,\n    messageCount: 0,\n    currentText: '',\n    ...(evalId ? { evalId } : {}),\n    ...(typeof entry.duration_ms === 'number' ? { durationMs: entry.duration_ms } : {}),\n    ...(initialOutput ? { output: initialOutput } : {}),\n  };\n  if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n    applyLaneTranscript(created, entry.messages);\n  }\n  applyLaneCut(created, entry);\n  applyLaneUsage(created, entry);\n  byDispatchId.set(entry.id, created);\n}\n\n/**\n * Where an in-eval dispatch's streamed steps ride, and what the wire left off\n * them, read off its entry's cut marker (`DEEP_AGENT_TRUNCATED_LANE_KEY`) as a\n * `task` card's is: the steps left off, and the whole lane's tool calls.\n */\nfunction applyLaneCut(snap: SubagentDiscoverySnapshot, entry: PtcSubagentEntry): void {\n  const lane = readTruncatedLane(entry);\n  if (Array.isArray(entry.messages) && entry.messages.length > 0) {\n    snap.source = {\n      lane: entry.id,\n      transcript: entry.messages,\n      ...(lane !== null && { truncated: lane }),\n    };\n  }\n  if (lane === null) return;\n  snap.omittedMessageCount = Math.max(0, lane.messages - snap.messageCount);\n  snap.toolCallCount = Math.max(snap.toolCallCount, lane.toolCalls);\n}\n\nconst NO_LANE_STEPS: readonly LangChainMessage[] = [];\n\n/**\n * An entry that recorded its subagent's checkpoint namespace (`ns`, a registry\n * entry or the summary an eval persisted, since agora writes it) pages its\n * lane from that checkpoint when no streamed steps carry it.\n */\nfunction noteCheckpointedLane(\n  snap: SubagentDiscoverySnapshot | undefined,\n  entry: PtcSubagentEntry\n): void {\n  if (snap === undefined || snap.source !== undefined) return;\n  if (typeof entry.ns !== 'string' || !entry.ns) return;\n  snap.source = { lane: entry.id, transcript: NO_LANE_STEPS, checkpointed: true };\n}\n\n/**\n * An in-eval lane's token use, from its entry's host total or the native steps\n * of its live transcript. A merge that brings neither keeps what the lane has.\n */\nfunction applyLaneUsage(snap: SubagentDiscoverySnapshot, entry: PtcSubagentEntry): void {\n  const usage = laneTokenUsage(\n    entry,\n    transcriptStepUsage(snap.messages),\n    snap.status,\n    (snap.omittedMessageCount ?? 0) > 0\n  );\n  if (usage !== undefined) snap.usage = usage;\n}\n\n/**\n * The first call of a nested thread with one of `toolCallIds`: the calls a\n * subagent made are the tool-call parts of its transcript, ids included.\n */\nfunction findToolCall({\n  messages,\n  toolCallIds,\n}: {\n  messages: readonly ThreadMessage[] | undefined;\n  toolCallIds: ReadonlySet<string>;\n}): ToolCallMessagePart | undefined {\n  if (messages === undefined) return undefined;\n  for (const message of messages) {\n    if (message.role !== 'assistant') continue;\n    for (const part of message.content) {\n      if (part.type === 'tool-call' && toolCallIds.has(part.toolCallId)) return part;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Whether a subagent lane waits on a person's approval, given the gated calls\n * still waiting on one (`toolCallIdsAwaitingApproval`): its own dispatch is the\n * gated call (a per-dispatch `task` gate), or a call it made is (a gated tool\n * raised inside the delegated subagent). The approval names the gated call's\n * `tool_call_id` and never the lane, and a lane's transcript carries the calls\n * it made with their ids, so the call id is the join. A settled lane waits on\n * nobody.\n */\nexport function subagentAwaitingApproval({\n  lane,\n  toolCallIds,\n}: {\n  lane: Pick<SubagentDiscoverySnapshot, 'id' | 'status' | 'messages'>;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): boolean {\n  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return false;\n  return (\n    toolCallIds.has(lane.id) ||\n    findToolCall({ messages: lane.messages, toolCallIds }) !== undefined\n  );\n}\n\n/**\n * The call a subagent made that waits on a person's approval (a gated tool\n * raised inside the delegated subagent), read off its transcript — what the\n * lane card names while it waits. `undefined` when the lane made none, which\n * includes a lane whose own dispatch is the gated call.\n */\nexport function subagentToolCallAwaitingApproval({\n  lane,\n  toolCallIds,\n}: {\n  lane: Pick<SubagentDiscoverySnapshot, 'status' | 'messages'>;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): LangChainToolCall | undefined {\n  if (toolCallIds.size === 0 || isTerminalSubagentStatus(lane.status)) return undefined;\n  const part = findToolCall({ messages: lane.messages, toolCallIds });\n  return part === undefined\n    ? undefined\n    : { id: part.toolCallId, name: part.toolName, args: part.args };\n}\n\n/**\n * The calls of one converted turn that wait on a person's approval, in turn\n * order: a gated call of the turn itself, or a `task` call not yet settled\n * (no result, or the running placeholder) whose lane holds a gated call — the\n * steps the turn's step list reads as waiting rather than running or done.\n */\nexport function turnToolCallsAwaitingApproval({\n  message,\n  toolCallIds,\n}: {\n  message: ThreadMessage;\n  /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */\n  toolCallIds: ReadonlySet<string>;\n}): string[] {\n  if (toolCallIds.size === 0 || message.role !== 'assistant') return [];\n  const ids: string[] = [];\n  for (const part of message.content) {\n    if (part.type !== 'tool-call') continue;\n    if (toolCallIds.has(part.toolCallId)) {\n      ids.push(part.toolCallId);\n      continue;\n    }\n    if (part.toolName !== TASK_TOOL_NAME) continue;\n    const settled = part.result !== undefined && part.isPreliminary !== true;\n    if (!settled && findToolCall({ messages: part.messages, toolCallIds }) !== undefined) {\n      ids.push(part.toolCallId);\n    }\n  }\n  return ids;\n}\n\nconst NO_WAITING_TOOL_CALLS: ReadonlySet<string> = new Set();\n/** Joins call ids into one selector value; an id never holds it. */\nconst TOOL_CALL_ID_SEPARATOR = '\\n';\n\n/**\n * {@link turnToolCallsAwaitingApproval} for the message in scope: what a\n * turn's step list takes as `waitingToolCallIds`, given the run's waiting\n * calls (`toolCallIdsAwaitingApproval`). Selected as a joined string, so a\n * streamed token re-renders the caller only when the waiting steps change, and\n * the set keeps its identity while they do not. Olympus's activity card and\n * the SDK chat's turns both read it.\n */\nexport function useTurnToolCallsAwaitingApproval(\n  toolCallIds: ReadonlySet<string>\n): ReadonlySet<string> {\n  const key = useAuiState((s) =>\n    toolCallIds.size === 0\n      ? ''\n      : turnToolCallsAwaitingApproval({ message: s.message, toolCallIds }).join(\n          TOOL_CALL_ID_SEPARATOR\n        )\n  );\n  return useMemo(\n    () => (key === '' ? NO_WAITING_TOOL_CALLS : new Set(key.split(TOOL_CALL_ID_SEPARATOR))),\n    [key]\n  );\n}\n\n/** Result text shown for a dispatch whose owning run ended before it finished. */\nexport const ORPHANED_SUBAGENT_OUTPUT =\n  'Interrupted — the run that dispatched this subagent ended before it finished.';\n\n/**\n * Settle snapshots orphaned by their dispatching context: once the owner (e.g.\n * the `eval` tool call whose in-eval `task()` issued them) is itself terminal,\n * nothing can ever deliver a `complete`/`error` lifecycle event for a lane still\n * `queued`/`running` — the dispatch coroutines were cancelled with the eval. Those\n * lanes are coerced to `error` with an interruption message so the UI can't show\n * perpetual \"Running · no activity\" ghosts. Returns the input array unchanged\n * (same reference) when there is nothing to settle.\n */\nexport function finalizeOrphanedSubagents(\n  snapshots: readonly SubagentDiscoverySnapshot[],\n  ownerTerminal: boolean\n): readonly SubagentDiscoverySnapshot[] {\n  if (!ownerTerminal || snapshots.every((s) => isTerminalSubagentStatus(s.status))) {\n    return snapshots;\n  }\n  return snapshots.map((s) =>\n    isTerminalSubagentStatus(s.status)\n      ? s\n      : { ...s, status: 'error', output: s.output || ORPHANED_SUBAGENT_OUTPUT }\n  );\n}\n\n/**\n * The `task` tool calls sharing `toolCallId`'s parent AI message — the parallel\n * fan-out siblings, in declaration order. Parallel `task` calls always live on ONE\n * AI message's `tool_calls`, so \"same parent message\" IS the parallelism boundary;\n * sequential delegations sit on separate AI messages and form singleton groups.\n * The FIRST sibling is the group's `anchorId`: its tool-part render draws the whole\n * side-by-side group and the other siblings render nothing, keeping the layout\n * change fully inside the `task` tool UI. Falls back to a singleton group when the\n * parent AI message isn't among `messages` (a turn's bound sources, or a raw\n * transcript).\n */\nexport interface TaskSiblingGroup {\n  /** Sibling `task` tool-call ids in declaration order. */\n  ids: string[];\n  /** The first sibling — the one tool-part render that owns the group's UI. */\n  anchorId: string;\n}\n\nexport function taskSiblingGroup(\n  messages: readonly LangChainMessage[],\n  toolCallId: string\n): TaskSiblingGroup {\n  for (const m of messages) {\n    if (m.type !== 'ai' || !m.tool_calls) continue;\n    if (!m.tool_calls.some((tc) => tc.id === toolCallId)) continue;\n    const ids = m.tool_calls\n      .filter((tc) => tc.name === TASK_TOOL_NAME && tc.id)\n      .map((tc) => tc.id as string);\n    if (ids.length > 0) return { ids, anchorId: ids[0] ?? toolCallId };\n    break;\n  }\n  return { ids: [toolCallId], anchorId: toolCallId };\n}\n"],"names":["DEEP_AGENT_TRUNCATED_LANE_KEY","DEEP_AGENT_LANE_USAGE_KEY","getMessageText","withRepeatedResult","getExternalStoreMessages","TASK_TOOL_NAME","useAuiState","useMemo"],"mappings":"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"}