@athenaintel/react 0.41.2 → 0.42.1

package/dist/tools/subagent-task-tool-ui.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The subagent card: one `task` call the deep agent delegated, shown the way
+ * Olympus shows a subagent lane.
+ *
+ * - On the card: where the lane is (queued, running, done, failed, stopped),
+ *   how many tool calls it made (the wire's cut marker counts a lane whose
+ *   card carries only its newest steps), how long it has run, and while it
+ *   runs, its newest step; a finished lane's report, or why it failed, under
+ *   it, clamped.
+ * - Behind its disclosure: the lane's steps, live while it runs, ending on
+ *   what the lane ended on, whole (a failure, or a report no step carries),
+ *   so a lane with no steps still opens to its full result. The lane is
+ *   assistant-ui's native nested thread: the `task` part's `messages`, which
+ *   the SDK runtime's opt-in conversion fills
+ *   (`createSubagentTranscriptConversionCache`), rendered read-only under
+ *   `ReadonlyThreadProvider` with the chat's own tool UIs. A cut lane (a
+ *   running card always; a finished one when the provider declares the
+ *   lane-cut contract, `subagentLaneHistory`) says how many of its steps it
+ *   shows, and "Load earlier steps" reads the rest with `history/lane`
+ *   (`useDeepAgentLaneHistory`), a read under the thread's own attach.
+ *
+ * A read-only nested thread has no statewire thread behind it: a `task` call
+ * inside a subagent's own steps renders as a static row, and the steps are
+ * their own error boundary, so a tool UI that throws there never takes the
+ * chat down with it.
+ */
+import { type ThreadMessage, type ToolCallMessagePartComponent, type ToolCallMessagePartStatus } from "@assistant-ui/react";
+import { type SubagentStatus } from "../agent-runtime/src/index";
+import { type ToolCallSummary } from "./tool-summary";
+/**
+ * Where a lane is, as the card shows it: the lane's own status, except that a
+ * lane parked on a person's approval is `approval` (its own dispatch, or a call
+ * it made, is a gated call nobody has answered), any other call the run waits
+ * on an answer for is `waiting`, and one the run stopped before it settled is
+ * `stopped`.
+ */
+export type SubagentLanePhase = "queued" | "approval" | "waiting" | "running" | "complete" | "error" | "stopped";
+export declare const SUBAGENT_LANE_PHASE_LABELS: Record<SubagentLanePhase, string>;
+/** The lane's phase from its status, the status assistant-ui gives its part, and the run's approval. */
+export declare function subagentLanePhase({ status, partStatus, awaitingApproval, }: {
+    status: SubagentStatus;
+    partStatus: ToolCallMessagePartStatus | undefined;
+    /** The lane waits on a person's approval (agent-runtime's `subagentAwaitingApproval`). */
+    awaitingApproval?: boolean;
+}): SubagentLanePhase;
+/** The phases a lane never leaves. */
+export declare function isSettledSubagentLanePhase(phase: SubagentLanePhase): boolean;
+/**
+ * What a settled lane ended on, whole: its report, or why it failed. A lane
+ * that the run's own failure ended has no result of its own, so the `task`
+ * part's status says why (as the generic card shows a failed call). Empty
+ * while the lane runs.
+ */
+export declare function subagentLaneResult({ output, phase, partStatus, }: {
+    /** The lane's own result text (`SubagentDiscoverySnapshot.output`). */
+    output: string | undefined;
+    phase: SubagentLanePhase;
+    partStatus: ToolCallMessagePartStatus | undefined;
+}): string;
+/**
+ * How long a finished lane ran, measured by the server: the `task` result's
+ * `_started_at` and `_created_at`, which the deep agent's tool-call timing
+ * stamps on every tool result and mirrors onto its artifact (the one field of
+ * a tool message the converter hands the tool-call part). `null` when either
+ * stamp is missing.
+ */
+export declare function finishedLaneDurationMs(artifact: unknown): number | null;
+/**
+ * When the agent delegated the call `toolCallId`: the server stamp
+ * (`_created_at`) of the assistant message that made it, among the raw
+ * messages bound to the turn. A running lane's card carries no stamp of its
+ * own, so its clock counts from here, the way the turn header counts from the
+ * turn's own stamps. `null` without one.
+ */
+export declare function laneDelegatedAtMs({ sources, toolCallId, }: {
+    sources: readonly unknown[];
+    toolCallId: string;
+}): number | null;
+/**
+ * The lane's newest tool step as its summary line ("Read `routes.ts`",
+ * "Running `npm test`"), from the lane's converted steps: the last tool call
+ * of its newest assistant turn, worded for whether it has answered. `null`
+ * before the lane's first tool call.
+ */
+export declare function latestLaneStep(messages: readonly ThreadMessage[]): ToolCallSummary | null;
+/**
+ * The subagent's type as the card names it: the `task` call's `subagent_type`
+ * in words, with the default `general-purpose` agent as "Subagent".
+ */
+export declare function subagentTypeLabel(name: string): string;
+/** "1 tool call", "12 tool calls". */
+export declare function toolCallCountLabel(count: number): string;
+/** What the steps panel says about the steps it shows of a cut lane. */
+export declare function laneStepsNote({ shown, total, arrivesLater, }: {
+    /** Steps the panel shows. */
+    shown: number;
+    /** Steps the lane stores (its cut marker), when the card carries fewer. */
+    total: number | undefined;
+    /**
+     * A running lane on a host that pages no running lane: its card brings the
+     * rest once the subagent finishes.
+     */
+    arrivesLater: boolean;
+}): string | null;
+/**
+ * The `task` tool UI (`TOOL_UI_REGISTRY.task`): the subagent card, or inside
+ * a subagent's own steps, a static delegation row.
+ */
+export declare const SubagentTaskToolUI: ToolCallMessagePartComponent;

package/dist/tools/subagent-task-tool-ui.js

@@ -0,0 +1,494 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useAuiState, getExternalStoreMessages, ReadonlyThreadProvider, ThreadPrimitive, MessagePrimitive } from "@assistant-ui/react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { BotIcon, ChevronDownIcon, LoaderIcon, CheckIcon, AlertCircleIcon, XCircleIcon, ShieldAlertIcon, CircleDashedIcon } from "lucide-react";
+import { memo, useMemo, useState, useEffect, Component, createContext, useContext } from "react";
+import { useApprovalWaitInScope } from "../chat/use-statewire-approval-request.js";
+import { MESSAGE_CREATED_AT_KEY } from "../chat/message-time.js";
+import { readInstantMs, formatWorkDuration } from "../chat/super-grouping/turn-timing.js";
+import { athenaDiagnostics } from "../diagnostics/athena-diagnostics.js";
+import { useAthenaQueryClient } from "../lib/use-athena-rest-query.js";
+import { CollapsibleTrigger } from "../ui/collapsible.js";
+import { useNestedPtcComponents } from "./NestedPtcMessages.js";
+import { StepText } from "./step-text.js";
+import { useToolAppearance } from "./tool-appearance.js";
+import { ToolFallbackRoot, ToolFallbackContent, ToolFallback } from "./tool-fallback.js";
+import { summarizeToolCall, humanizeToolName } from "./tool-summary.js";
+import { hasStatewireThreadExtras } from "../agent-runtime/src/thread-extras.js";
+import { taskSubagentsOfTurn, subagentAwaitingApproval, subagentToolCallAwaitingApproval } from "../agent-runtime/src/subagents.js";
+import { salientToolCallDetail } from "../agent-runtime/src/tool-names.js";
+import { useDeepAgentLaneHistory } from "../agent-runtime/src/lane-history.js";
+import { createSubagentLaneConversion, withLaneReport } from "../agent-runtime/src/subagent-transcripts.js";
+import { deepAgentRowKey } from "../agent-runtime/src/messages.js";
+import { cn } from "cnfast";
+const NO_LANE_STEPS = [];
+const NO_MESSAGES = [];
+const SUBAGENT_LANE_PHASE_LABELS = {
+  queued: "Queued",
+  approval: "Waiting for approval",
+  waiting: "Waiting for you",
+  running: "Running",
+  complete: "Done",
+  error: "Failed",
+  stopped: "Stopped"
+};
+function subagentLanePhase({
+  status,
+  partStatus,
+  awaitingApproval = false
+}) {
+  if (status === "complete" || status === "error") return status;
+  if (awaitingApproval) return "approval";
+  if ((partStatus == null ? void 0 : partStatus.type) === "requires-action") return "waiting";
+  if ((partStatus == null ? void 0 : partStatus.type) === "incomplete") {
+    return partStatus.reason === "cancelled" ? "stopped" : "error";
+  }
+  return status;
+}
+function isSettledSubagentLanePhase(phase) {
+  return phase === "complete" || phase === "error" || phase === "stopped";
+}
+function subagentLaneResult({
+  output,
+  phase,
+  partStatus
+}) {
+  if (!isSettledSubagentLanePhase(phase)) return "";
+  const own = (output == null ? void 0 : output.trim()) ?? "";
+  if (own !== "" || phase !== "error" || (partStatus == null ? void 0 : partStatus.type) !== "incomplete") return own;
+  const { error } = partStatus;
+  if (error === void 0 || error === null) return "";
+  return (typeof error === "string" ? error : JSON.stringify(error)).trim();
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function finishedLaneDurationMs(artifact) {
+  const stamps = record(artifact);
+  const startedAt = readInstantMs(stamps == null ? void 0 : stamps._started_at);
+  const finishedAt = readInstantMs(stamps == null ? void 0 : stamps[MESSAGE_CREATED_AT_KEY]);
+  return startedAt !== null && finishedAt !== null && finishedAt >= startedAt ? finishedAt - startedAt : null;
+}
+const ASSISTANT_TYPES = /* @__PURE__ */ new Set(["ai", "AIMessageChunk"]);
+function laneDelegatedAtMs({
+  sources,
+  toolCallId
+}) {
+  for (const source of sources) {
+    const message = record(source);
+    if (!message || !ASSISTANT_TYPES.has(message.type)) continue;
+    const calls = message.tool_calls;
+    if (!Array.isArray(calls) || !calls.some((call) => {
+      var _a;
+      return ((_a = record(call)) == null ? void 0 : _a.id) === toolCallId;
+    })) continue;
+    const kwargs = record(message.additional_kwargs);
+    const metadata = record(kwargs == null ? void 0 : kwargs.metadata);
+    return readInstantMs(metadata == null ? void 0 : metadata[MESSAGE_CREATED_AT_KEY]) ?? readInstantMs(kwargs == null ? void 0 : kwargs[MESSAGE_CREATED_AT_KEY]) ?? readInstantMs(message[MESSAGE_CREATED_AT_KEY]);
+  }
+  return null;
+}
+function latestLaneStep(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if ((message == null ? void 0 : message.role) !== "assistant") continue;
+    for (let partIndex = message.content.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = message.content[partIndex];
+      if ((part == null ? void 0 : part.type) !== "tool-call") continue;
+      const answered = part.result !== void 0 && part.isPreliminary !== true;
+      return summarizeToolCall({
+        toolName: part.toolName,
+        args: part.args,
+        result: answered ? part.result : void 0,
+        status: answered ? part.isError === true ? "error" : "complete" : "running"
+      });
+    }
+  }
+  return null;
+}
+function subagentTypeLabel(name) {
+  const trimmed = name.trim();
+  if (trimmed === "" || trimmed === "subagent" || trimmed === "general-purpose") return "Subagent";
+  return humanizeToolName(trimmed);
+}
+function toolCallCountLabel(count) {
+  return `${count} tool call${count === 1 ? "" : "s"}`;
+}
+function stepsLabel(count) {
+  return `${count} step${count === 1 ? "" : "s"}`;
+}
+function laneStepsNote({
+  shown,
+  total,
+  arrivesLater
+}) {
+  if (total === void 0 || total <= shown) return null;
+  const leftOff = total - shown;
+  return arrivesLater ? `Showing the latest steps. ${leftOff} earlier ${leftOff === 1 ? "step arrives" : "steps arrive"} when this subagent finishes.` : `Showing the latest ${shown} of ${stepsLabel(total)}.`;
+}
+function useInReadOnlyThread() {
+  return useAuiState((s) => {
+    var _a;
+    const thread = (_a = s.optional) == null ? void 0 : _a.thread;
+    return thread !== void 0 && !hasStatewireThreadExtras(thread.extras);
+  });
+}
+function laneFromArgs(toolCallId, args) {
+  const record2 = typeof args === "object" && args !== null ? args : {};
+  return {
+    id: toolCallId,
+    name: typeof record2.subagent_type === "string" ? record2.subagent_type : "subagent",
+    description: typeof record2.description === "string" ? record2.description : "",
+    status: "queued",
+    toolCallCount: 0,
+    messages: NO_MESSAGES,
+    messageCount: 0,
+    currentText: ""
+  };
+}
+function LaneStatusGlyph({ phase }) {
+  const glyph = phase === "running" ? /* @__PURE__ */ jsx(LoaderIcon, { className: "size-3.5 animate-spin text-muted-foreground motion-reduce:animate-none" }) : phase === "complete" ? /* @__PURE__ */ jsx(CheckIcon, { className: "size-3.5 text-emerald-600" }) : phase === "error" ? /* @__PURE__ */ jsx(AlertCircleIcon, { className: "size-3.5 text-destructive" }) : phase === "stopped" ? /* @__PURE__ */ jsx(XCircleIcon, { className: "size-3.5 text-muted-foreground" }) : phase === "waiting" || phase === "approval" ? /* @__PURE__ */ jsx(ShieldAlertIcon, { className: "size-3.5 text-amber-600" }) : /* @__PURE__ */ jsx(CircleDashedIcon, { className: "size-3.5 text-muted-foreground motion-safe:animate-pulse" });
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      "data-slot": "subagent-status",
+      "data-phase": phase,
+      "aria-hidden": "true",
+      className: "mt-0.5 flex size-4 shrink-0 items-center justify-center",
+      children: glyph
+    }
+  );
+}
+function useRunningElapsedMs(running, startMs) {
+  const [clock, setClock] = useState(null);
+  useEffect(() => {
+    if (!running) {
+      setClock(null);
+      return void 0;
+    }
+    const seenAt = Date.now();
+    setClock({ seenAt, now: seenAt });
+    const timer = setInterval(() => setClock({ seenAt, now: Date.now() }), 1e3);
+    return () => clearInterval(timer);
+  }, [running]);
+  if (!running || clock === null) return null;
+  return Math.max(0, clock.now - (startMs ?? clock.seenAt));
+}
+const LaneStepComponentsContext = createContext(null);
+const EmptyStepPart = () => null;
+const LaneStep = () => {
+  const role = useAuiState((s) => s.message.role);
+  const components = useContext(LaneStepComponentsContext);
+  if (role !== "assistant") return null;
+  return /* @__PURE__ */ jsx(MessagePrimitive.Parts, { components: { Empty: EmptyStepPart, ...components } });
+};
+const LANE_ROW_COMPONENTS = { Message: LaneStep };
+const ROW_KEY_SEPARATOR = "\0";
+function LaneRows() {
+  const joinedKeys = useAuiState(
+    (s) => s.thread.messages.map((message) => deepAgentRowKey(message)).join(ROW_KEY_SEPARATOR)
+  );
+  const rowKeys = useMemo(
+    () => joinedKeys === "" ? [] : joinedKeys.split(ROW_KEY_SEPARATOR),
+    [joinedKeys]
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: rowKeys.map((key, index) => /* @__PURE__ */ jsx(ThreadPrimitive.MessageByIndex, { index, components: LANE_ROW_COMPONENTS }, key)) });
+}
+class LaneStepsBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { failed: false };
+  }
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    var _a;
+    athenaDiagnostics.error(
+      "sdk.error",
+      error,
+      {
+        code: "chat_render_crash",
+        message: "A subagent's steps could not be shown",
+        hint: "Inspect component_stack: a tool UI that reads the live thread fails inside a subagent's read-only steps."
+      },
+      {
+        surface: "subagent-lane",
+        subagent: this.props.name,
+        component_stack: ((_a = errorInfo.componentStack) == null ? void 0 : _a.slice(0, 2e3)) ?? null
+      }
+    );
+  }
+  render() {
+    if (this.state.failed) {
+      return /* @__PURE__ */ jsx("p", { role: "alert", className: "px-1 text-xs text-muted-foreground", children: "These steps couldn't be shown. The conversation is not affected." });
+    }
+    return this.props.children;
+  }
+}
+function LaneQueryScope({ children }) {
+  const queryClient = useAthenaQueryClient();
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
+}
+function LaneSteps({ lane, phase, result, partMessages }) {
+  var _a, _b;
+  const running = lane.status === "running" && (phase === "running" || phase === "approval");
+  const source = lane.source;
+  const history = useDeepAgentLaneHistory({
+    messageId: source == null ? void 0 : source.messageId,
+    lane: source == null ? void 0 : source.lane,
+    carried: (source == null ? void 0 : source.transcript) ?? NO_LANE_STEPS,
+    total: (_a = source == null ? void 0 : source.truncated) == null ? void 0 : _a.messages,
+    finished: ((_b = source == null ? void 0 : source.truncated) == null ? void 0 : _b.finished) === true
+  });
+  const [convertLane] = useState(() => createSubagentLaneConversion());
+  const report = lane.status === "complete" && (source == null ? void 0 : source.messageId) !== void 0 ? lane.output : void 0;
+  const messages = (source === void 0 ? void 0 : convertLane(withLaneReport(history.steps, report), running)) ?? partMessages ?? NO_MESSAGES;
+  const components = useNestedPtcComponents(ToolFallback);
+  const shown = history.steps.length;
+  const arrivesLater = running && (source == null ? void 0 : source.messageId) !== void 0 && !history.available;
+  const note = laneStepsNote({ shown, total: history.total, arrivesLater });
+  const emptyText = phase === "running" ? "Starting…" : phase === "queued" || phase === "waiting" || phase === "approval" ? "Not started yet." : "No steps were recorded for this subagent.";
+  const failed = phase === "error";
+  const closing = failed || messages.length === 0 ? result : "";
+  return /* @__PURE__ */ jsxs("div", { "data-slot": "subagent-steps", className: "flex min-w-0 flex-col gap-2 px-2.5", children: [
+    lane.description ? /* @__PURE__ */ jsx(
+      "p",
+      {
+        "data-slot": "subagent-brief",
+        className: "whitespace-pre-wrap break-words text-xs leading-relaxed text-muted-foreground",
+        children: lane.description
+      }
+    ) : null,
+    note ? /* @__PURE__ */ jsxs(
+      "div",
+      {
+        "data-slot": "subagent-steps-note",
+        className: "flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground",
+        children: [
+          /* @__PURE__ */ jsx("span", { children: note }),
+          history.hasEarlier && !arrivesLater ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              onClick: history.loadEarlier,
+              disabled: history.loading,
+              className: "rounded font-medium text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-default disabled:no-underline disabled:opacity-60",
+              children: history.loading ? "Loading earlier steps…" : "Load earlier steps"
+            }
+          ) : null
+        ]
+      }
+    ) : null,
+    messages.length > 0 ? /* @__PURE__ */ jsx(LaneStepsBoundary, { name: lane.name, children: /* @__PURE__ */ jsx(LaneStepComponentsContext.Provider, { value: components, children: /* @__PURE__ */ jsx(ReadonlyThreadProvider, { messages, children: /* @__PURE__ */ jsx("div", { "data-slot": "subagent-step-rows", className: "flex min-w-0 flex-col gap-1", children: /* @__PURE__ */ jsx(LaneRows, {}) }) }) }) }) : /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: emptyText }),
+    closing ? /* @__PURE__ */ jsxs("div", { "data-slot": "subagent-result", className: "flex min-w-0 flex-col gap-0.5", children: [
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          className: cn(
+            "text-xs font-medium",
+            failed ? "text-destructive" : "text-muted-foreground"
+          ),
+          children: failed ? "Error" : "Report"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          "data-slot": "subagent-result-text",
+          className: cn(
+            "max-h-72 overflow-auto whitespace-pre-wrap break-words text-xs leading-relaxed",
+            failed ? "text-destructive/80" : "text-foreground/80"
+          ),
+          children: closing
+        }
+      )
+    ] }) : null
+  ] });
+}
+function laneMeta({
+  phase,
+  toolCallCount,
+  elapsedMs
+}) {
+  const parts = [SUBAGENT_LANE_PHASE_LABELS[phase]];
+  if (toolCallCount > 0 || isSettledSubagentLanePhase(phase)) {
+    parts.push(toolCallCountLabel(toolCallCount));
+  }
+  if (elapsedMs !== null && (phase !== "running" || elapsedMs >= 1e3)) {
+    parts.push(formatWorkDuration(elapsedMs));
+  }
+  return parts.join(" · ");
+}
+function SubagentTaskCard({ toolCallId, args, status, artifact, messages }) {
+  const appearance = useToolAppearance();
+  const isThread = appearance === "thread";
+  const readLane = useAuiState((s) => taskSubagentsOfTurn(s.message).get(toolCallId));
+  const lane = useMemo(
+    () => readLane ?? laneFromArgs(toolCallId, args),
+    [readLane, toolCallId, args]
+  );
+  const { toolCallIds: waitingToolCallIds } = useApprovalWaitInScope();
+  const awaitingApproval = subagentAwaitingApproval({ lane, toolCallIds: waitingToolCallIds });
+  const gatedCall = awaitingApproval ? subagentToolCallAwaitingApproval({ lane, toolCallIds: waitingToolCallIds }) : void 0;
+  const phase = subagentLanePhase({ status: lane.status, partStatus: status, awaitingApproval });
+  const running = phase === "running";
+  const delegatedAt = useAuiState(
+    (s) => running ? laneDelegatedAtMs({ sources: getExternalStoreMessages(s.message), toolCallId }) : null
+  );
+  const runningElapsed = useRunningElapsedMs(running, delegatedAt);
+  const elapsedMs = running ? runningElapsed : isSettledSubagentLanePhase(phase) ? finishedLaneDurationMs(artifact) : null;
+  const step = useMemo(() => running ? latestLaneStep(lane.messages) : null, [running, lane.messages]);
+  const hasSteps = lane.messageCount > 0 || (lane.omittedMessageCount ?? 0) > 0;
+  const typeLabel = subagentTypeLabel(lane.name);
+  const title = lane.description.trim() || typeLabel;
+  const meta = laneMeta({ phase, toolCallCount: lane.toolCallCount, elapsedMs });
+  const liveText = step ? null : lane.currentText.trim();
+  const report = subagentLaneResult({ output: lane.output, phase, partStatus: status });
+  const header = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(LaneStatusGlyph, { phase }),
+    /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 flex-1 flex-col gap-0.5", children: [
+      /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 items-baseline gap-1.5", children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            "data-slot": "subagent-title",
+            title: lane.description || void 0,
+            className: "min-w-0 truncate font-medium text-foreground",
+            children: title
+          }
+        ),
+        title !== typeLabel ? /* @__PURE__ */ jsx(
+          "span",
+          {
+            "data-slot": "subagent-type",
+            className: "shrink-0 rounded-full bg-muted px-1.5 py-px text-[10px] font-medium text-muted-foreground",
+            children: typeLabel
+          }
+        ) : null
+      ] }),
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          "data-slot": "subagent-meta",
+          className: cn(
+            "text-xs tabular-nums text-muted-foreground",
+            phase === "error" && "text-destructive"
+          ),
+          children: meta
+        }
+      ),
+      phase === "approval" ? /* @__PURE__ */ jsxs(
+        "span",
+        {
+          "data-slot": "subagent-approval",
+          className: "flex min-w-0 items-baseline gap-1 text-xs text-muted-foreground",
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "shrink-0 text-amber-700", children: gatedCall ? "Needs approval to run" : "Needs approval to start" }),
+            gatedCall ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("code", { className: "shrink-0 rounded bg-foreground/[0.06] px-1 py-px font-mono text-[11px] text-foreground/85", children: gatedCall.name }),
+              /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: salientToolCallDetail(gatedCall) })
+            ] }) : null
+          ]
+        }
+      ) : running ? /* @__PURE__ */ jsx("span", { "data-slot": "subagent-activity", className: "min-w-0 truncate text-xs text-muted-foreground", children: step ? /* @__PURE__ */ jsx("span", { title: step.detail, children: /* @__PURE__ */ jsx(StepText, { text: step.label, code: step.code }) }) : liveText || "Starting…" }) : null
+    ] })
+  ] });
+  return /* @__PURE__ */ jsxs(
+    ToolFallbackRoot,
+    {
+      "data-testid": "subagent-task-card",
+      "data-phase": phase,
+      role: "group",
+      "aria-label": `Subagent: ${title}`,
+      className: cn(isThread && phase === "error" && "border-destructive/30 bg-destructive/5"),
+      children: [
+        hasSteps || running || report ? /* @__PURE__ */ jsxs(
+          CollapsibleTrigger,
+          {
+            "data-slot": "subagent-trigger",
+            className: cn(
+              "group/trigger flex w-full min-w-0 items-start gap-2 text-left text-[13px] leading-snug transition-colors hover:bg-muted/40",
+              isThread ? "rounded-lg px-2.5 py-1.5" : "px-3"
+            ),
+            children: [
+              header,
+              /* @__PURE__ */ jsx(
+                ChevronDownIcon,
+                {
+                  "aria-hidden": "true",
+                  className: cn(
+                    "mt-0.5 size-3.5 shrink-0 text-muted-foreground/60",
+                    "transition-transform duration-(--animation-duration) ease-out",
+                    "group-data-[state=closed]/trigger:-rotate-90"
+                  )
+                }
+              )
+            ]
+          }
+        ) : /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-slot": "subagent-trigger",
+            className: cn(
+              "flex w-full min-w-0 items-start gap-2 text-[13px] leading-snug",
+              isThread ? "px-2.5 py-1.5" : "px-3"
+            ),
+            children: header
+          }
+        ),
+        report ? /* @__PURE__ */ jsx(
+          "p",
+          {
+            "data-slot": "subagent-report",
+            className: cn(
+              "mb-1.5 line-clamp-3 whitespace-pre-line break-words text-xs leading-relaxed",
+              isThread ? "mr-2.5 ml-8" : "mx-3 mt-1.5 ml-9",
+              phase === "error" ? "text-destructive" : "text-foreground/80"
+            ),
+            children: report
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(ToolFallbackContent, { children: /* @__PURE__ */ jsx(LaneQueryScope, { children: /* @__PURE__ */ jsx(LaneSteps, { lane, phase, result: report, partMessages: messages }) }) })
+      ]
+    }
+  );
+}
+function SubagentDelegationRow({ args, result, isError, status }) {
+  const settled = result !== void 0 && (status == null ? void 0 : status.type) !== "running";
+  const summary = summarizeToolCall({
+    toolName: "task",
+    args: typeof args === "object" && args !== null ? args : void 0,
+    status: !settled ? "running" : isError === true ? "error" : "complete"
+  });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-testid": "subagent-delegation",
+      className: "my-1 flex min-w-0 items-center gap-2 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-[13px]",
+      children: [
+        /* @__PURE__ */ jsx(BotIcon, { "aria-hidden": "true", className: "size-3.5 shrink-0 text-muted-foreground" }),
+        /* @__PURE__ */ jsx("span", { title: summary.detail, className: "min-w-0 truncate text-foreground", children: summary.label })
+      ]
+    }
+  );
+}
+const SubagentTaskToolUIImpl = (props) => useInReadOnlyThread() ? /* @__PURE__ */ jsx(SubagentDelegationRow, { ...props }) : /* @__PURE__ */ jsx(SubagentTaskCard, { ...props });
+const SubagentTaskToolUI = memo(
+  SubagentTaskToolUIImpl
+);
+SubagentTaskToolUI.displayName = "SubagentTaskToolUI";
+export {
+  SUBAGENT_LANE_PHASE_LABELS,
+  SubagentTaskToolUI,
+  finishedLaneDurationMs,
+  isSettledSubagentLanePhase,
+  laneDelegatedAtMs,
+  laneStepsNote,
+  latestLaneStep,
+  subagentLanePhase,
+  subagentLaneResult,
+  subagentTypeLabel,
+  toolCallCountLabel
+};
+//# sourceMappingURL=subagent-task-tool-ui.js.map