@athenaintel/react 0.41.2 → 0.42.1

package/dist/agent-runtime/src/subagents.d.ts

@@ -0,0 +1,311 @@
+/**
+ * Subagent discovery: every subagent lane a deep-agent thread has spawned, as
+ * the card view model the surfaces that draw subagent lanes render. Two
+ * dispatch paths feed lanes keyed by dispatch id:
+ *
+ * - top-level `task` tool calls, read from the call's own tool-call part
+ *   ({@link taskSubagentsOfTurn}): the part's result and `isPreliminary` say
+ *   where the lane is, and its `messages` (the nested thread
+ *   `createSubagentTranscriptConversionCache` converts) are the transcript;
+ * - in-eval `task()` dispatches ({@link deriveEvalSubagents}), whose only
+ *   signals are the live `ptc_subagents` state channel and the summaries a
+ *   finished `eval` ToolMessage persists in `artifact.ptc_subagents`.
+ */
+import { type ThreadMessage } from '@assistant-ui/core';
+import type { LangChainMessage, LangChainToolCall } from '@assistant-ui/react-langgraph';
+import type { PtcSubagentEntry, Todo } from './types';
+/**
+ * Where a subagent lane is:
+ *
+ * - `queued` — the dispatch has not started: a `task` call with no result yet
+ *   (waiting for a dispatch slot or an approval; the backend shows the running
+ *   card once the dispatch holds its slot), or an in-eval dispatch waiting for
+ *   one of the bridge's concurrency slots.
+ * - `running` — a `task` call's result is still the backend's running
+ *   placeholder (its part is `isPreliminary`), and the nested transcript fills
+ *   in live; or an in-eval dispatch's lifecycle says it runs.
+ * - `complete` / `error` — the real result replaced the placeholder; `error`
+ *   when it is an error result.
+ */
+export type SubagentStatus = 'queued' | 'running' | 'complete' | 'error';
+/** True for the settled lifecycle states (`complete` / `error`). */
+export declare function isTerminalSubagentStatus(status: SubagentStatus): boolean;
+/** Aggregate lane lifecycle counts for one fan-out (orchestration strip + header chip). */
+export interface SubagentStatusCounts {
+    total: number;
+    queued: number;
+    running: number;
+    complete: number;
+    failed: number;
+    /** complete + failed — the settled count progress displays use. */
+    terminal: number;
+}
+export declare function countSubagentStatuses(snapshots: readonly SubagentDiscoverySnapshot[]): SubagentStatusCounts;
+/**
+ * Discovery snapshot for one subagent invocation. Mirrors LangChain's
+ * `SubagentDiscoverySnapshot`: `id` is the `task` tool-call id that spawned the
+ * subagent (the dispatch id for an in-eval dispatch), so cards nest under the
+ * coordinator turn that delegated the work.
+ */
+export interface SubagentDiscoverySnapshot {
+    /** The `task` tool-call id that spawned the subagent. */
+    id: string;
+    /** Subagent type/name, from the `task` call's `subagent_type` arg. */
+    name: string;
+    /** The one-line task brief from the `task` call's `description` arg. */
+    description: string;
+    /** Lifecycle state — see {@link SubagentStatus}. */
+    status: SubagentStatus;
+    /** The call's result text (empty while it is the running placeholder). */
+    output?: string;
+    /** Number of nested tool calls the subagent made. */
+    toolCallCount: number;
+    /**
+     * The subagent's transcript as a nested thread: a `task` part's native
+     * `messages`, or an in-eval dispatch's live transcript converted the same way.
+     */
+    messages: readonly ThreadMessage[];
+    /** Messages in the transcript as the wire carries them, before conversion joins a turn's steps. */
+    messageCount: number;
+    /**
+     * Nested messages the wire left off: a cut card carries its newest steps
+     * ({@link readTruncatedLane}) — a running card always, a finished one on a
+     * version-2 view — and the rest pages in through `history/lane`; an in-eval
+     * dispatch's streamed transcript is cut the same way, running or finished.
+     * Absent when the transcript rides whole.
+     */
+    omittedMessageCount?: number;
+    /**
+     * Where the lane's steps ride, what `history/lane` pages the rest of the lane
+     * under (`useDeepAgentLaneHistory`): a `task` lane's card, an in-eval lane's
+     * registry entry while it streams its steps, or, once they no longer ride,
+     * its subagent checkpoint (`checkpointed`), when agora recorded where that is
+     * (`ns`). Absent for any other in-eval lane with no streamed steps (a summary
+     * written before agora recorded the namespace, an older host).
+     */
+    source?: SubagentLaneSource;
+    /** The subagent's own plan, nested by the backend on the task artifact (`subgraph_state.todos`). */
+    todos?: Todo[];
+    /** The newest tool call in the transcript — the card's "last action" ticker. */
+    lastToolCall?: LangChainToolCall;
+    /** The newest assistant text in the transcript — the card's thought preview. */
+    currentText: string;
+    /**
+     * The `eval` tool-call id that dispatched this subagent, when it was spawned
+     * from INSIDE the code interpreter (`task()` in the REPL) rather than by a
+     * top-level `task` tool call. The eval card uses it to render lanes for its
+     * own dispatches.
+     */
+    evalId?: string;
+    /**
+     * Backend-reported runtime for a finished in-eval dispatch (from the terminal
+     * lifecycle event). Authoritative over client-side timing — it survives a page
+     * refresh, where local first-seen timestamps are gone.
+     */
+    durationMs?: number;
+    /** The model that produced the transcript, from its newest assistant turn's model stamp. */
+    model?: string;
+    /**
+     * The lane's token use: the whole lane's as the host counts it
+     * (`DEEP_AGENT_LANE_USAGE_KEY`), else the sum of the native step usage
+     * (`metadata.steps[].usage`) of the steps the transcript holds. Absent while
+     * no step reports any.
+     */
+    usage?: SubagentTokenUsage;
+}
+/** A subagent lane's token use. */
+export interface SubagentTokenUsage {
+    /** Input tokens, the prompt cache's reads and writes included. */
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    /**
+     * Less than the lane will have used: the lane still runs (its newest step may
+     * not have reported yet), or no host total arrived and the sum covers only
+     * the steps held of a lane cut to its newest ones.
+     */
+    readonly partial: boolean;
+}
+/** Input and output tokens of some model calls. */
+export interface TokenCounts {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/**
+ * The subagent's streamed transcript as the wire carries it, read from a task
+ * ToolMessage's `artifact.subgraph_state.messages` (the shape the backend nests
+ * it under — see the route's `_subagent_subgraph_state`).
+ */
+export declare function nestedMessagesFromArtifact(artifact: unknown): LangChainMessage[];
+/** What the wire left off a cut `task` card's nested transcript. */
+export interface TruncatedLane {
+    /** Nested messages the host holds for the lane. */
+    messages: number;
+    /** Tool calls across all of them. */
+    toolCalls: number;
+    /**
+     * The card is a finished lane's, cut for a version-2 view. Only a host that
+     * serves `history/lane` cuts a finished card.
+     */
+    finished: boolean;
+}
+/**
+ * Where a lane's steps ride, and what `history/lane` pages the rest of them
+ * under: a `task` lane's card, by its message id, or an in-eval dispatch's
+ * `ptc_subagents` registry entry, by its dispatch id.
+ */
+export type SubagentLaneSource = {
+    /** The steps as the wire carries them (a card's report restored, {@link withRepeatedResult}). */
+    readonly transcript: readonly LangChainMessage[];
+    /** The cut marker; absent while every step rides. */
+    readonly truncated?: TruncatedLane;
+    /**
+     * No steps ride, and `history/lane {lane}` pages the subagent's own steps
+     * from its checkpoint: an in-eval lane a later run in this activation left
+     * only its summary and `ns`, or a reopened session's lane (its registry gone,
+     * the summary its eval persisted records `ns`).
+     */
+    readonly checkpointed?: true;
+} & ({
+    /** The card's message id: the running placeholder's, then the result's. */
+    readonly messageId: string;
+    readonly lane?: undefined;
+} | {
+    /** The dispatch id: the in-eval lane's registry key. */
+    readonly lane: string;
+    readonly messageId?: undefined;
+});
+/**
+ * The cut marker off a `task` card's raw wire message: the host carries only
+ * the lane's newest nested steps and names the whole transcript here
+ * (`DEEP_AGENT_TRUNCATED_LANE_KEY`), on a running card and, for a version-2
+ * view, on a finished one. `null` when the transcript rides whole.
+ */
+export declare function readTruncatedLane(toolMessage: unknown): TruncatedLane | null;
+/**
+ * The whole lane's token use the host carries on a `task` card's raw wire
+ * message or an in-eval lane's `ptc_subagents` entry
+ * (`DEEP_AGENT_LANE_USAGE_KEY`), however much of the lane the wire carries.
+ * `null` when it carries none (an older host, or no step reported usage).
+ */
+export declare function readLaneUsage(wire: unknown): TokenCounts | null;
+/**
+ * What the model calls of a converted transcript used, from assistant-ui's
+ * native step usage (`metadata.steps[].usage`, one step per model call a turn
+ * joined). `undefined` when no step reports usage. Memoized per transcript
+ * array, which the conversion caches keep while the transcript is unchanged.
+ */
+export declare function transcriptStepUsage(messages: readonly ThreadMessage[]): TokenCounts | undefined;
+/**
+ * The subagent's own plan, read from a task ToolMessage's
+ * `artifact.subgraph_state.todos` (the backend mirrors the subagent's isolated
+ * `todos` state channel there — see the route's `_forward_subagent_todos`).
+ * `undefined` (not `[]`) when the subagent never wrote a plan, so the UI can
+ * distinguish "no plan" from "plan with zero items".
+ */
+export declare function nestedTodosFromArtifact(artifact: unknown): Todo[] | undefined;
+/**
+ * The persisted in-eval dispatch summaries from an `eval` ToolMessage's
+ * `artifact.ptc_subagents` (written by the backend when the eval ends). Unlike
+ * the live `ptc_subagents` state channel — which dies with the stream — these
+ * survive checkpoint reload, so reopened sessions can still render each
+ * dispatch's terminal status, duration, output, and error.
+ */
+export declare function ptcSubagentsFromArtifact(artifact: unknown): PtcSubagentEntry[];
+/**
+ * The lane of every `task` call in one converted turn (a `ThreadMessage`, or the
+ * message state assistant-ui publishes for it), keyed by tool-call id in call
+ * order. Memoized per turn and per part.
+ */
+export declare function taskSubagentsOfTurn(message: ThreadMessage): ReadonlyMap<string, SubagentDiscoverySnapshot>;
+/** The lane of every `task` call in a converted thread, in transcript order. */
+export declare function taskSubagentsOfThread(messages: readonly ThreadMessage[]): SubagentDiscoverySnapshot[];
+/**
+ * The lanes of in-eval dispatches, from two sources: the *persisted* summaries
+ * each finished `eval` ToolMessage carries in `artifact.ptc_subagents`
+ * (terminal truth; the only source after a session reopen), then the *live*
+ * `ptc_subagents` state channel (`ptcSubagents`) for dispatches still
+ * streaming. A live entry never downgrades a terminal snapshot back to
+ * `running` — a stale lifecycle entry whose terminal event was lost must not
+ * resurrect a perpetually-running lane the persisted summary already settled.
+ * A lane whose steps no longer ride but whose subagent checkpoint namespace is
+ * recorded (`ns`) is `checkpointed`, and `history/lane {lane}` pages its
+ * steps: a live entry a later run stripped to its summary, or a persisted
+ * summary with no live entry (the registry died with the activation that
+ * streamed it). A live entry speaks for its lane over the summary.
+ */
+export declare function deriveEvalSubagents(messages: readonly LangChainMessage[], ptcSubagents?: Record<string, PtcSubagentEntry>): Map<string, SubagentDiscoverySnapshot>;
+/**
+ * Whether a subagent lane waits on a person's approval, given the gated calls
+ * still waiting on one (`toolCallIdsAwaitingApproval`): its own dispatch is the
+ * gated call (a per-dispatch `task` gate), or a call it made is (a gated tool
+ * raised inside the delegated subagent). The approval names the gated call's
+ * `tool_call_id` and never the lane, and a lane's transcript carries the calls
+ * it made with their ids, so the call id is the join. A settled lane waits on
+ * nobody.
+ */
+export declare function subagentAwaitingApproval({ lane, toolCallIds, }: {
+    lane: Pick<SubagentDiscoverySnapshot, 'id' | 'status' | 'messages'>;
+    /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */
+    toolCallIds: ReadonlySet<string>;
+}): boolean;
+/**
+ * The call a subagent made that waits on a person's approval (a gated tool
+ * raised inside the delegated subagent), read off its transcript — what the
+ * lane card names while it waits. `undefined` when the lane made none, which
+ * includes a lane whose own dispatch is the gated call.
+ */
+export declare function subagentToolCallAwaitingApproval({ lane, toolCallIds, }: {
+    lane: Pick<SubagentDiscoverySnapshot, 'status' | 'messages'>;
+    /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */
+    toolCallIds: ReadonlySet<string>;
+}): LangChainToolCall | undefined;
+/**
+ * The calls of one converted turn that wait on a person's approval, in turn
+ * order: a gated call of the turn itself, or a `task` call not yet settled
+ * (no result, or the running placeholder) whose lane holds a gated call — the
+ * steps the turn's step list reads as waiting rather than running or done.
+ */
+export declare function turnToolCallsAwaitingApproval({ message, toolCallIds, }: {
+    message: ThreadMessage;
+    /** The gated calls still waiting on a decision (`toolCallIdsAwaitingApproval`). */
+    toolCallIds: ReadonlySet<string>;
+}): string[];
+/**
+ * {@link turnToolCallsAwaitingApproval} for the message in scope: what a
+ * turn's step list takes as `waitingToolCallIds`, given the run's waiting
+ * calls (`toolCallIdsAwaitingApproval`). Selected as a joined string, so a
+ * streamed token re-renders the caller only when the waiting steps change, and
+ * the set keeps its identity while they do not. Olympus's activity card and
+ * the SDK chat's turns both read it.
+ */
+export declare function useTurnToolCallsAwaitingApproval(toolCallIds: ReadonlySet<string>): ReadonlySet<string>;
+/** Result text shown for a dispatch whose owning run ended before it finished. */
+export declare const ORPHANED_SUBAGENT_OUTPUT = "Interrupted \u2014 the run that dispatched this subagent ended before it finished.";
+/**
+ * Settle snapshots orphaned by their dispatching context: once the owner (e.g.
+ * the `eval` tool call whose in-eval `task()` issued them) is itself terminal,
+ * nothing can ever deliver a `complete`/`error` lifecycle event for a lane still
+ * `queued`/`running` — the dispatch coroutines were cancelled with the eval. Those
+ * lanes are coerced to `error` with an interruption message so the UI can't show
+ * perpetual "Running · no activity" ghosts. Returns the input array unchanged
+ * (same reference) when there is nothing to settle.
+ */
+export declare function finalizeOrphanedSubagents(snapshots: readonly SubagentDiscoverySnapshot[], ownerTerminal: boolean): readonly SubagentDiscoverySnapshot[];
+/**
+ * The `task` tool calls sharing `toolCallId`'s parent AI message — the parallel
+ * fan-out siblings, in declaration order. Parallel `task` calls always live on ONE
+ * AI message's `tool_calls`, so "same parent message" IS the parallelism boundary;
+ * sequential delegations sit on separate AI messages and form singleton groups.
+ * The FIRST sibling is the group's `anchorId`: its tool-part render draws the whole
+ * side-by-side group and the other siblings render nothing, keeping the layout
+ * change fully inside the `task` tool UI. Falls back to a singleton group when the
+ * parent AI message isn't among `messages` (a turn's bound sources, or a raw
+ * transcript).
+ */
+export interface TaskSiblingGroup {
+    /** Sibling `task` tool-call ids in declaration order. */
+    ids: string[];
+    /** The first sibling — the one tool-part render that owns the group's UI. */
+    anchorId: string;
+}
+export declare function taskSiblingGroup(messages: readonly LangChainMessage[], toolCallId: string): TaskSiblingGroup;

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

@@ -0,0 +1,253 @@
+import { getExternalStoreMessages } from "@assistant-ui/core";
+import { useAuiState } from "@assistant-ui/store";
+import { useMemo } from "react";
+import { DEEP_AGENT_TRUNCATED_LANE_KEY, DEEP_AGENT_LANE_USAGE_KEY } from "./generated/runconfig-contract.js";
+import { getMessageText } from "./message-text.js";
+import { withRepeatedResult } from "./subagent-transcripts.js";
+import { TASK_TOOL_NAME } from "./tool-names.js";
+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[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[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: 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: 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 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 !== 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 !== 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 = useAuiState(
+    (s) => toolCallIds.size === 0 ? "" : turnToolCallsAwaitingApproval({ message: s.message, toolCallIds }).join(
+      TOOL_CALL_ID_SEPARATOR
+    )
+  );
+  return useMemo(
+    () => key === "" ? NO_WAITING_TOOL_CALLS : new Set(key.split(TOOL_CALL_ID_SEPARATOR)),
+    [key]
+  );
+}
+export {
+  isTerminalSubagentStatus,
+  nestedMessagesFromArtifact,
+  nestedTodosFromArtifact,
+  readLaneUsage,
+  readTruncatedLane,
+  subagentAwaitingApproval,
+  subagentToolCallAwaitingApproval,
+  taskSubagentsOfTurn,
+  transcriptStepUsage,
+  turnToolCallsAwaitingApproval,
+  useTurnToolCallsAwaitingApproval
+};
+//# sourceMappingURL=subagents.js.map