@athenaintel/react 0.57.2 → 0.59.0

package/dist/subagents/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const laneModel = require("./lane-model.cjs");
+const laneParts = require("./lane-parts.cjs");
+const subagentLaneGroup = require("./subagent-lane-group.cjs");
+const subagentTranscriptDrawer = require("./subagent-transcript-drawer.cjs");
+const subagents_laneFollow = require("./lane-follow.cjs");
+const taskSubagentGroup = require("./task-subagent-group.cjs");
+const useOmittedImagesInView = require("./use-omitted-images-in-view.cjs");
+exports.SUBAGENT_LANES_PAGE_SIZE = laneModel.SUBAGENT_LANES_PAGE_SIZE;
+exports.SUBAGENT_STALL_THRESHOLD_MS = laneModel.SUBAGENT_STALL_THRESHOLD_MS;
+exports.SUBAGENT_STATUS_LABELS = laneModel.SUBAGENT_STATUS_LABELS;
+exports.SUBAGENT_STOPPED_LABEL = laneModel.SUBAGENT_STOPPED_LABEL;
+exports.SUBAGENT_STOPPED_OUTPUT = laneModel.SUBAGENT_STOPPED_OUTPUT;
+exports.finishedLaneDurationMs = laneModel.finishedLaneDurationMs;
+exports.formatLaneElapsed = laneModel.formatLaneElapsed;
+exports.formatLaneTokens = laneModel.formatLaneTokens;
+exports.formatTokenCount = laneModel.formatTokenCount;
+exports.laneDelegatedAtMs = laneModel.laneDelegatedAtMs;
+exports.laneDurationLabel = laneModel.laneDurationLabel;
+exports.laneFacts = laneModel.laneFacts;
+exports.lanePlanProgress = laneModel.lanePlanProgress;
+exports.laneStepsNote = laneModel.laneStepsNote;
+exports.laneTokenBreakdown = laneModel.laneTokenBreakdown;
+exports.laneTokenCount = laneModel.laneTokenCount;
+exports.reportedDurationLabel = laneModel.reportedDurationLabel;
+exports.subagentCountParts = laneModel.subagentCountParts;
+exports.subagentLanePageCount = laneModel.subagentLanePageCount;
+exports.subagentLaneTitle = laneModel.subagentLaneTitle;
+exports.subagentStatusLabel = laneModel.subagentStatusLabel;
+exports.subagentTypeLabel = laneModel.subagentTypeLabel;
+exports.toolCallCountLabel = laneModel.toolCallCountLabel;
+exports.LaneAwaitingApprovalNote = laneParts.LaneAwaitingApprovalNote;
+exports.SubagentDelegationChip = laneParts.SubagentDelegationChip;
+exports.SubagentForkConnectors = laneParts.SubagentForkConnectors;
+exports.SubagentLaneCard = laneParts.SubagentLaneCard;
+exports.SubagentLanesPager = laneParts.SubagentLanesPager;
+exports.SubagentOrchestrationStrip = laneParts.SubagentOrchestrationStrip;
+exports.SubagentProgressRing = laneParts.SubagentProgressRing;
+exports.SubagentSegmentedProgress = laneParts.SubagentSegmentedProgress;
+exports.SubagentStatusLine = laneParts.SubagentStatusLine;
+exports.SubagentLaneGroup = subagentLaneGroup.SubagentLaneGroup;
+exports.SubagentLaneTranscript = subagentTranscriptDrawer.SubagentLaneTranscript;
+exports.SubagentTranscriptDrawer = subagentTranscriptDrawer.SubagentTranscriptDrawer;
+exports.DeepAgentLaneFollowScope = subagents_laneFollow.DeepAgentLaneFollowScope;
+exports.useDeepAgentLaneFollowRegistry = subagents_laneFollow.useDeepAgentLaneFollowRegistry;
+exports.useTaskSubagentGroup = taskSubagentGroup.useTaskSubagentGroup;
+exports.useOmittedImagesInView = useOmittedImagesInView.useOmittedImagesInView;
+//# sourceMappingURL=index.cjs.map

package/dist/subagents/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/subagents/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The subagent lanes, as a lean entry for hosts that render their own thread
+ * and register their own `task` tool UI (Olympus): the lane group, its parts,
+ * the transcript drawer, the lane-follow scope and what a lane says. The full
+ * `@athenaintel/react` entry's `task` tool UI (`SubagentTaskToolUI`) draws them
+ * for `AthenaChat`.
+ *
+ * Published as the `@athenaintel/react/subagents` sub-path.
+ */
+export { finishedLaneDurationMs, formatLaneElapsed, formatLaneTokens, formatTokenCount, laneDelegatedAtMs, laneDurationLabel, laneFacts, lanePlanProgress, laneStepsNote, laneTokenBreakdown, laneTokenCount, reportedDurationLabel, SUBAGENT_LANES_PAGE_SIZE, SUBAGENT_STALL_THRESHOLD_MS, SUBAGENT_STATUS_LABELS, SUBAGENT_STOPPED_LABEL, SUBAGENT_STOPPED_OUTPUT, subagentCountParts, subagentLanePageCount, subagentLaneTitle, subagentStatusLabel, type SubagentTiming, subagentTypeLabel, toolCallCountLabel, } from './lane-model';
+export { LaneAwaitingApprovalNote, SubagentDelegationChip, SubagentForkConnectors, SubagentLaneCard, type SubagentLaneCardProps, SubagentLanesPager, type SubagentLaneWait, SubagentOrchestrationStrip, SubagentProgressRing, SubagentSegmentedProgress, SubagentStatusLine, } from './lane-parts';
+export { SubagentLaneGroup, type SubagentLaneGroupApprovalWait, type SubagentLaneGroupProps, } from './subagent-lane-group';
+export { SubagentLaneTranscript, SubagentTranscriptDrawer, type SubagentTranscriptDrawerOptions, type SubagentTranscriptDrawerProps, type SubagentTranscriptRenderProps, } from './subagent-transcript-drawer';
+export { DeepAgentLaneFollowScope, useDeepAgentLaneFollowRegistry } from './lane-follow';
+export { type TaskSubagentGroupState, useTaskSubagentGroup } from './task-subagent-group';
+export { useOmittedImagesInView } from './use-omitted-images-in-view';

package/dist/subagents/index.js

@@ -0,0 +1,49 @@
+import { SUBAGENT_LANES_PAGE_SIZE, SUBAGENT_STALL_THRESHOLD_MS, SUBAGENT_STATUS_LABELS, SUBAGENT_STOPPED_LABEL, SUBAGENT_STOPPED_OUTPUT, finishedLaneDurationMs, formatLaneElapsed, formatLaneTokens, formatTokenCount, laneDelegatedAtMs, laneDurationLabel, laneFacts, lanePlanProgress, laneStepsNote, laneTokenBreakdown, laneTokenCount, reportedDurationLabel, subagentCountParts, subagentLanePageCount, subagentLaneTitle, subagentStatusLabel, subagentTypeLabel, toolCallCountLabel } from "./lane-model.js";
+import { LaneAwaitingApprovalNote, SubagentDelegationChip, SubagentForkConnectors, SubagentLaneCard, SubagentLanesPager, SubagentOrchestrationStrip, SubagentProgressRing, SubagentSegmentedProgress, SubagentStatusLine } from "./lane-parts.js";
+import { SubagentLaneGroup } from "./subagent-lane-group.js";
+import { SubagentLaneTranscript, SubagentTranscriptDrawer } from "./subagent-transcript-drawer.js";
+import { DeepAgentLaneFollowScope, useDeepAgentLaneFollowRegistry } from "./lane-follow.js";
+import { useTaskSubagentGroup } from "./task-subagent-group.js";
+import { useOmittedImagesInView } from "./use-omitted-images-in-view.js";
+export {
+  DeepAgentLaneFollowScope,
+  LaneAwaitingApprovalNote,
+  SUBAGENT_LANES_PAGE_SIZE,
+  SUBAGENT_STALL_THRESHOLD_MS,
+  SUBAGENT_STATUS_LABELS,
+  SUBAGENT_STOPPED_LABEL,
+  SUBAGENT_STOPPED_OUTPUT,
+  SubagentDelegationChip,
+  SubagentForkConnectors,
+  SubagentLaneCard,
+  SubagentLaneGroup,
+  SubagentLaneTranscript,
+  SubagentLanesPager,
+  SubagentOrchestrationStrip,
+  SubagentProgressRing,
+  SubagentSegmentedProgress,
+  SubagentStatusLine,
+  SubagentTranscriptDrawer,
+  finishedLaneDurationMs,
+  formatLaneElapsed,
+  formatLaneTokens,
+  formatTokenCount,
+  laneDelegatedAtMs,
+  laneDurationLabel,
+  laneFacts,
+  lanePlanProgress,
+  laneStepsNote,
+  laneTokenBreakdown,
+  laneTokenCount,
+  reportedDurationLabel,
+  subagentCountParts,
+  subagentLanePageCount,
+  subagentLaneTitle,
+  subagentStatusLabel,
+  subagentTypeLabel,
+  toolCallCountLabel,
+  useDeepAgentLaneFollowRegistry,
+  useOmittedImagesInView,
+  useTaskSubagentGroup
+};
+//# sourceMappingURL=index.js.map

package/dist/subagents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/subagents/lane-follow.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const require$$0 = require("react");
+const laneFollow = require("../agent-runtime/src/lane-follow.cjs");
+const DeepAgentLaneFollowContext = require$$0.createContext(null);
+function DeepAgentLaneFollowScope({
+  registry,
+  children
+}) {
+  const [own] = require$$0.useState(laneFollow.createDeepAgentLaneFollowRegistry);
+  return /* @__PURE__ */ jsxRuntime.jsx(DeepAgentLaneFollowContext.Provider, { value: registry ?? own, children });
+}
+function useDeepAgentLaneFollowRegistry() {
+  return require$$0.useContext(DeepAgentLaneFollowContext);
+}
+exports.DeepAgentLaneFollowScope = DeepAgentLaneFollowScope;
+exports.useDeepAgentLaneFollowRegistry = useDeepAgentLaneFollowRegistry;
+//# sourceMappingURL=lane-follow.cjs.map

package/dist/subagents/lane-follow.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-follow.cjs","sources":["../../src/subagents/lane-follow.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createDeepAgentLaneFollowRegistry,\n  type DeepAgentLaneFollowRegistry,\n} from '@athenaintel/agent-runtime';\nimport { createContext, type ReactNode, useContext, useState } from 'react';\n\n/**\n * The subagent lanes a chat's surface shows live (an open transcript\n * drawer's), which its window sync follows on the wire\n * (`useDeepAgentLaneFollowSync`): a followed running lane's card carries every\n * step, not just its newest. One per chat, so a drawer follows on its own\n * chat's attach only. `AthenaChat` mounts one; a host with its own runtime\n * mounts one around its thread and its window sync.\n *\n * Also published alone as `@athenaintel/react/lane-follow`, which imports\n * nothing else of the SDK's, so a shell can mount the scope without loading\n * the lanes.\n */\nconst DeepAgentLaneFollowContext = createContext<DeepAgentLaneFollowRegistry | null>(null);\n\nexport function DeepAgentLaneFollowScope({\n  registry,\n  children,\n}: {\n  /** The chat's registry; a fresh one by default. */\n  registry?: DeepAgentLaneFollowRegistry;\n  children: ReactNode;\n}) {\n  const [own] = useState(createDeepAgentLaneFollowRegistry);\n  return <DeepAgentLaneFollowContext.Provider value={registry ?? own}>{children}</DeepAgentLaneFollowContext.Provider>;\n}\n\n/** The chat's followed lanes; `null` outside a scope, where nothing is followed. */\nexport function useDeepAgentLaneFollowRegistry(): DeepAgentLaneFollowRegistry | null {\n  return useContext(DeepAgentLaneFollowContext);\n}\n"],"names":["createContext","useState","createDeepAgentLaneFollowRegistry","useContext"],"mappings":";;;;;AAoBA,MAAM,6BAA6BA,WAAAA,cAAkD,IAAI;AAElF,SAAS,yBAAyB;AAAA,EACvC;AAAA,EACA;AACF,GAIG;AACD,QAAM,CAAC,GAAG,IAAIC,WAAAA,SAASC,4CAAiC;AACxD,wCAAQ,2BAA2B,UAA3B,EAAoC,OAAO,YAAY,KAAM,UAAS;AAChF;AAGO,SAAS,iCAAqE;AACnF,SAAOC,WAAAA,WAAW,0BAA0B;AAC9C;;;"}

package/dist/subagents/lane-follow.d.ts

@@ -0,0 +1,9 @@
+import { type DeepAgentLaneFollowRegistry } from '../agent-runtime/src/index';
+import { type ReactNode } from 'react';
+export declare function DeepAgentLaneFollowScope({ registry, children, }: {
+    /** The chat's registry; a fresh one by default. */
+    registry?: DeepAgentLaneFollowRegistry;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The chat's followed lanes; `null` outside a scope, where nothing is followed. */
+export declare function useDeepAgentLaneFollowRegistry(): DeepAgentLaneFollowRegistry | null;

package/dist/subagents/lane-follow.js

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useContext } from "react";
+import { createDeepAgentLaneFollowRegistry } from "../agent-runtime/src/lane-follow.js";
+const DeepAgentLaneFollowContext = createContext(null);
+function DeepAgentLaneFollowScope({
+  registry,
+  children
+}) {
+  const [own] = useState(createDeepAgentLaneFollowRegistry);
+  return /* @__PURE__ */ jsx(DeepAgentLaneFollowContext.Provider, { value: registry ?? own, children });
+}
+function useDeepAgentLaneFollowRegistry() {
+  return useContext(DeepAgentLaneFollowContext);
+}
+export {
+  DeepAgentLaneFollowScope,
+  useDeepAgentLaneFollowRegistry
+};
+//# sourceMappingURL=lane-follow.js.map

package/dist/subagents/lane-follow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-follow.js","sources":["../../src/subagents/lane-follow.tsx"],"sourcesContent":["'use client';\n\nimport {\n  createDeepAgentLaneFollowRegistry,\n  type DeepAgentLaneFollowRegistry,\n} from '@athenaintel/agent-runtime';\nimport { createContext, type ReactNode, useContext, useState } from 'react';\n\n/**\n * The subagent lanes a chat's surface shows live (an open transcript\n * drawer's), which its window sync follows on the wire\n * (`useDeepAgentLaneFollowSync`): a followed running lane's card carries every\n * step, not just its newest. One per chat, so a drawer follows on its own\n * chat's attach only. `AthenaChat` mounts one; a host with its own runtime\n * mounts one around its thread and its window sync.\n *\n * Also published alone as `@athenaintel/react/lane-follow`, which imports\n * nothing else of the SDK's, so a shell can mount the scope without loading\n * the lanes.\n */\nconst DeepAgentLaneFollowContext = createContext<DeepAgentLaneFollowRegistry | null>(null);\n\nexport function DeepAgentLaneFollowScope({\n  registry,\n  children,\n}: {\n  /** The chat's registry; a fresh one by default. */\n  registry?: DeepAgentLaneFollowRegistry;\n  children: ReactNode;\n}) {\n  const [own] = useState(createDeepAgentLaneFollowRegistry);\n  return <DeepAgentLaneFollowContext.Provider value={registry ?? own}>{children}</DeepAgentLaneFollowContext.Provider>;\n}\n\n/** The chat's followed lanes; `null` outside a scope, where nothing is followed. */\nexport function useDeepAgentLaneFollowRegistry(): DeepAgentLaneFollowRegistry | null {\n  return useContext(DeepAgentLaneFollowContext);\n}\n"],"names":[],"mappings":";;;AAoBA,MAAM,6BAA6B,cAAkD,IAAI;AAElF,SAAS,yBAAyB;AAAA,EACvC;AAAA,EACA;AACF,GAIG;AACD,QAAM,CAAC,GAAG,IAAI,SAAS,iCAAiC;AACxD,6BAAQ,2BAA2B,UAA3B,EAAoC,OAAO,YAAY,KAAM,UAAS;AAChF;AAGO,SAAS,iCAAqE;AACnF,SAAO,WAAW,0BAA0B;AAC9C;"}

package/dist/subagents/lane-model.cjs

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const turnTiming = require("../chat/super-grouping/turn-timing.cjs");
+const messageTime = require("../chat/message-time.cjs");
+const subagents = require("../agent-runtime/src/subagents.cjs");
+const DEFAULT_SUBAGENT_TYPES = /* @__PURE__ */ new Set(["", "subagent", "general-purpose"]);
+function subagentTypeLabel(name) {
+  const trimmed = name.trim();
+  if (DEFAULT_SUBAGENT_TYPES.has(trimmed.toLowerCase())) return null;
+  const words = trimmed.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_\-.:/]+/).filter(Boolean).map((word) => /^[A-Z0-9]{2,}$/.test(word) ? word : word.toLowerCase());
+  if (words.length === 0) return null;
+  const label = words.join(" ");
+  return `${label.charAt(0).toUpperCase()}${label.slice(1)}`;
+}
+function subagentLaneTitle(snapshot) {
+  return snapshot.description || subagentTypeLabel(snapshot.name) || "Subagent";
+}
+const SUBAGENT_STATUS_LABELS = {
+  queued: "Queued",
+  running: "Running",
+  complete: "Done",
+  error: "Failed"
+};
+const SUBAGENT_STOPPED_LABEL = "Stopped";
+const SUBAGENT_STOPPED_OUTPUT = "Stopped before it finished.";
+function subagentStatusLabel({
+  status,
+  awaitingApproval = false,
+  stopped = false
+}) {
+  if (stopped) return SUBAGENT_STOPPED_LABEL;
+  return awaitingApproval ? subagents.SUBAGENT_AWAITING_APPROVAL_LABEL : SUBAGENT_STATUS_LABELS[status];
+}
+function subagentCountParts({
+  awaiting = 0,
+  queued,
+  running,
+  complete,
+  failed,
+  stopped = 0
+}) {
+  return [
+    awaiting > 0 ? `${awaiting} waiting for approval` : null,
+    queued > 0 ? `${queued} queued` : null,
+    running > 0 ? `${running} running` : null,
+    complete > 0 ? `${complete} done` : null,
+    failed > 0 ? `${failed} failed` : null,
+    stopped > 0 ? `${stopped} stopped` : null
+  ].filter((part) => part !== null);
+}
+const SUBAGENT_STALL_THRESHOLD_MS = 3e4;
+function formatLaneElapsed(ms) {
+  return turnTiming.formatWorkDuration(ms);
+}
+function reportedDurationLabel(snapshot) {
+  if (!subagents.isTerminalSubagentStatus(snapshot.status) || snapshot.durationMs == null) return void 0;
+  return formatLaneElapsed(snapshot.durationMs);
+}
+function laneDurationLabel({
+  snapshot,
+  timing,
+  now,
+  stopped = false
+}) {
+  const reported = reportedDurationLabel(snapshot);
+  if (reported !== void 0) return reported;
+  if (!timing) return void 0;
+  const settled = stopped || subagents.isTerminalSubagentStatus(snapshot.status);
+  if (!settled && snapshot.status === "running") return formatLaneElapsed(now - timing.firstSeenAt);
+  if (settled && timing.sawActive && timing.completedAt != null) {
+    return formatLaneElapsed(timing.completedAt - timing.firstSeenAt);
+  }
+  return void 0;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function finishedLaneDurationMs(artifact) {
+  const stamps = record(artifact);
+  const startedAt = turnTiming.readInstantMs(stamps == null ? void 0 : stamps._started_at);
+  const finishedAt = turnTiming.readInstantMs(stamps == null ? void 0 : stamps[messageTime.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 turnTiming.readInstantMs(metadata == null ? void 0 : metadata[messageTime.MESSAGE_CREATED_AT_KEY]) ?? turnTiming.readInstantMs(kwargs == null ? void 0 : kwargs[messageTime.MESSAGE_CREATED_AT_KEY]) ?? turnTiming.readInstantMs(message[messageTime.MESSAGE_CREATED_AT_KEY]);
+  }
+  return null;
+}
+function toolCallCountLabel(count) {
+  return `${count} tool call${count === 1 ? "" : "s"}`;
+}
+function lanePlanProgress(snapshot) {
+  var _a, _b;
+  const total = ((_a = snapshot.todos) == null ? void 0 : _a.length) ?? 0;
+  if (total === 0) return null;
+  const done = ((_b = snapshot.todos) == null ? void 0 : _b.filter((todo) => todo.status === "completed").length) ?? 0;
+  return { done, total };
+}
+function laneFacts(snapshot) {
+  const plan = lanePlanProgress(snapshot);
+  return [
+    snapshot.toolCallCount > 0 ? toolCallCountLabel(snapshot.toolCallCount) : null,
+    plan ? `${plan.done}/${plan.total} steps` : null
+  ].filter((fact) => fact !== null);
+}
+function formatTokenCount(tokens) {
+  if (!Number.isFinite(tokens)) return "-";
+  if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+  if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(1)}k`;
+  return tokens.toLocaleString();
+}
+function laneTokenCount(usage) {
+  return usage.inputTokens + usage.outputTokens;
+}
+function formatLaneTokens(usage) {
+  if (usage === void 0) return null;
+  const count = laneTokenCount(usage);
+  if (!Number.isFinite(count) || count <= 0) return null;
+  return `${formatTokenCount(count)}${usage.partial ? "+" : ""} tokens`;
+}
+function laneTokenBreakdown(usage) {
+  const floor = usage.partial ? "+" : "";
+  return `${formatTokenCount(usage.inputTokens)}${floor} in · ${formatTokenCount(usage.outputTokens)}${floor} out`;
+}
+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)}.`;
+}
+const SUBAGENT_LANES_PAGE_SIZE = 4;
+function subagentLanePageCount(count) {
+  return count > 1 ? Math.max(1, Math.ceil(count / SUBAGENT_LANES_PAGE_SIZE)) : 1;
+}
+exports.SUBAGENT_LANES_PAGE_SIZE = SUBAGENT_LANES_PAGE_SIZE;
+exports.SUBAGENT_STALL_THRESHOLD_MS = SUBAGENT_STALL_THRESHOLD_MS;
+exports.SUBAGENT_STATUS_LABELS = SUBAGENT_STATUS_LABELS;
+exports.SUBAGENT_STOPPED_LABEL = SUBAGENT_STOPPED_LABEL;
+exports.SUBAGENT_STOPPED_OUTPUT = SUBAGENT_STOPPED_OUTPUT;
+exports.finishedLaneDurationMs = finishedLaneDurationMs;
+exports.formatLaneElapsed = formatLaneElapsed;
+exports.formatLaneTokens = formatLaneTokens;
+exports.formatTokenCount = formatTokenCount;
+exports.laneDelegatedAtMs = laneDelegatedAtMs;
+exports.laneDurationLabel = laneDurationLabel;
+exports.laneFacts = laneFacts;
+exports.lanePlanProgress = lanePlanProgress;
+exports.laneStepsNote = laneStepsNote;
+exports.laneTokenBreakdown = laneTokenBreakdown;
+exports.laneTokenCount = laneTokenCount;
+exports.reportedDurationLabel = reportedDurationLabel;
+exports.subagentCountParts = subagentCountParts;
+exports.subagentLanePageCount = subagentLanePageCount;
+exports.subagentLaneTitle = subagentLaneTitle;
+exports.subagentStatusLabel = subagentStatusLabel;
+exports.subagentTypeLabel = subagentTypeLabel;
+exports.toolCallCountLabel = toolCallCountLabel;
+//# sourceMappingURL=lane-model.cjs.map

package/dist/subagents/lane-model.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-model.cjs","sources":["../../src/subagents/lane-model.ts"],"sourcesContent":["/**\n * What the subagent lanes say, as pure functions: a lane's title and type,\n * its status words, its duration, its facts and token use, and a fan-out's\n * counts. The lane card, the orchestration strip, the transcript drawer and a\n * host's own surfaces (Olympus's header popover) read them, so every place a\n * lane shows says the same.\n */\nimport {\n  isTerminalSubagentStatus,\n  SUBAGENT_AWAITING_APPROVAL_LABEL,\n  type SubagentDiscoverySnapshot,\n  type SubagentStatus,\n  type SubagentTokenUsage,\n} from '@athenaintel/agent-runtime';\nimport { formatWorkDuration, readInstantMs } from '../chat/super-grouping/turn-timing';\nimport { MESSAGE_CREATED_AT_KEY } from '../chat/message-time';\n\n// ─── Names ───────────────────────────────────────────────────────────\n\n/** Types every delegation without a preset gets: they say nothing about the lane. */\nconst DEFAULT_SUBAGENT_TYPES: ReadonlySet<string> = new Set(['', 'subagent', 'general-purpose']);\n\n/**\n * A preset subagent's type in sentence case (\"code-reviewer\" → \"Code\n * reviewer\"); `null` for the default general-purpose subagent, whose type is\n * not worth a label.\n */\nexport function subagentTypeLabel(name: string): string | null {\n  const trimmed = name.trim();\n  if (DEFAULT_SUBAGENT_TYPES.has(trimmed.toLowerCase())) return null;\n  const words = trimmed\n    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')\n    .split(/[\\s_\\-.:/]+/)\n    .filter(Boolean)\n    .map((word) => (/^[A-Z0-9]{2,}$/.test(word) ? word : word.toLowerCase()));\n  if (words.length === 0) return null;\n  const label = words.join(' ');\n  return `${label.charAt(0).toUpperCase()}${label.slice(1)}`;\n}\n\n/** What a lane is called: its task brief, else its preset's name, else \"Subagent\". */\nexport function subagentLaneTitle(\n  snapshot: Pick<SubagentDiscoverySnapshot, 'name' | 'description'>,\n): string {\n  return snapshot.description || subagentTypeLabel(snapshot.name) || 'Subagent';\n}\n\n// ─── Status ──────────────────────────────────────────────────────────\n\n/**\n * A lane's status in words. `queued` covers both a `task` call awaiting its\n * first event and an in-eval dispatch waiting for one of the bridge's\n * concurrency slots.\n */\nexport const SUBAGENT_STATUS_LABELS: Record<SubagentStatus, string> = {\n  queued: 'Queued',\n  running: 'Running',\n  complete: 'Done',\n  error: 'Failed',\n};\n\n/** What a lane reads once the run that delegated it ended before it settled. */\nexport const SUBAGENT_STOPPED_LABEL = 'Stopped';\n\n/** A stopped lane's card, when the lane left no output of its own. */\nexport const SUBAGENT_STOPPED_OUTPUT = 'Stopped before it finished.';\n\n/** A lane's status word, or the wait for approval (or the stop) that stands in for it. */\nexport function subagentStatusLabel({\n  status,\n  awaitingApproval = false,\n  stopped = false,\n}: {\n  status: SubagentStatus;\n  awaitingApproval?: boolean;\n  stopped?: boolean;\n}): string {\n  if (stopped) return SUBAGENT_STOPPED_LABEL;\n  return awaitingApproval ? SUBAGENT_AWAITING_APPROVAL_LABEL : SUBAGENT_STATUS_LABELS[status];\n}\n\n/**\n * A fan-out's lanes counted in the lanes' own words, lanes waiting for\n * approval first (\"1 waiting for approval · 2 running · 4 done · 1 failed\");\n * a count of none is left out.\n */\nexport function subagentCountParts({\n  awaiting = 0,\n  queued,\n  running,\n  complete,\n  failed,\n  stopped = 0,\n}: {\n  awaiting?: number;\n  queued: number;\n  running: number;\n  complete: number;\n  failed: number;\n  stopped?: number;\n}): string[] {\n  return [\n    awaiting > 0 ? `${awaiting} waiting for approval` : null,\n    queued > 0 ? `${queued} queued` : null,\n    running > 0 ? `${running} running` : null,\n    complete > 0 ? `${complete} done` : null,\n    failed > 0 ? `${failed} failed` : null,\n    stopped > 0 ? `${stopped} stopped` : null,\n  ].filter((part): part is string => part !== null);\n}\n\n// ─── Time ────────────────────────────────────────────────────────────\n\n/** A lane goes quiet this long before its card says it has seen no activity. */\nexport const SUBAGENT_STALL_THRESHOLD_MS = 30_000;\n\n/**\n * When this client saw a lane begin, change and finish. The wire carries no\n * event stamps for a lane's steps, so its card keeps its own: the stall badge\n * reads `lastEventAt`, and a duration it witnessed reads `firstSeenAt` to\n * `completedAt`.\n */\nexport interface SubagentTiming {\n  firstSeenAt: number;\n  lastEventAt: number;\n  completedAt: number | null;\n  /** True once this client saw the lane running (false for a lane reopened finished). */\n  sawActive: boolean;\n}\n\n/** \"29s\", \"2m 05s\", \"1h 03m\". */\nexport function formatLaneElapsed(ms: number): string {\n  return formatWorkDuration(ms);\n}\n\n/**\n * A finished lane's runtime as the backend reported it (`durationMs`: an\n * in-eval dispatch's terminal event, or a `task` result's own stamps), which\n * survives a reload where this client's timing does not. `undefined` while the\n * lane runs or when nothing reported it.\n */\nexport function reportedDurationLabel(\n  snapshot: Pick<SubagentDiscoverySnapshot, 'status' | 'durationMs'>,\n): string | undefined {\n  if (!isTerminalSubagentStatus(snapshot.status) || snapshot.durationMs == null) return undefined;\n  return formatLaneElapsed(snapshot.durationMs);\n}\n\n/**\n * The duration a lane shows: the backend's for a finished lane, else how long\n * a running lane has run, else a finished lane's runtime this client\n * witnessed. Never a fabricated \"0s\" for a lane reopened finished.\n */\nexport function laneDurationLabel({\n  snapshot,\n  timing,\n  now,\n  stopped = false,\n}: {\n  snapshot: Pick<SubagentDiscoverySnapshot, 'status' | 'durationMs'>;\n  timing: SubagentTiming | undefined;\n  now: number;\n  /** The run ended before the lane settled: it runs no longer. */\n  stopped?: boolean;\n}): string | undefined {\n  const reported = reportedDurationLabel(snapshot);\n  if (reported !== undefined) return reported;\n  if (!timing) return undefined;\n  const settled = stopped || isTerminalSubagentStatus(snapshot.status);\n  if (!settled && snapshot.status === 'running') return formatLaneElapsed(now - timing.firstSeenAt);\n  if (settled && timing.sawActive && timing.completedAt != null) {\n    return formatLaneElapsed(timing.completedAt - timing.firstSeenAt);\n  }\n  return undefined;\n}\n\nfunction record(value: unknown): Record<string, unknown> | undefined {\n  return value && typeof value === 'object' && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\n/**\n * How long a finished `task` lane ran, measured by the server: the result's\n * `_started_at` and `_created_at`, which the deep agent's tool-call timing\n * stamps on every tool result and mirrors onto its artifact (the one field of\n * a tool message the converter hands the tool-call part). `null` when either\n * stamp is missing.\n */\nexport function finishedLaneDurationMs(artifact: unknown): number | null {\n  const stamps = record(artifact);\n  const startedAt = readInstantMs(stamps?._started_at);\n  const finishedAt = readInstantMs(stamps?.[MESSAGE_CREATED_AT_KEY]);\n  return startedAt !== null && finishedAt !== null && finishedAt >= startedAt\n    ? finishedAt - startedAt\n    : null;\n}\n\nconst ASSISTANT_TYPES: ReadonlySet<unknown> = new Set(['ai', 'AIMessageChunk']);\n\n/**\n * When the agent delegated the call `toolCallId`: the server stamp\n * (`_created_at`) of the assistant message that made it, among the raw\n * messages bound to the turn. Parallel siblings share it (one message makes\n * them all). `null` without one.\n */\nexport function laneDelegatedAtMs({\n  sources,\n  toolCallId,\n}: {\n  sources: readonly unknown[];\n  toolCallId: string;\n}): number | null {\n  for (const source of sources) {\n    const message = record(source);\n    if (!message || !ASSISTANT_TYPES.has(message.type)) continue;\n    const calls = message.tool_calls;\n    if (!Array.isArray(calls) || !calls.some((call) => record(call)?.id === toolCallId)) continue;\n    const kwargs = record(message.additional_kwargs);\n    const metadata = record(kwargs?.metadata);\n    return (\n      readInstantMs(metadata?.[MESSAGE_CREATED_AT_KEY]) ??\n      readInstantMs(kwargs?.[MESSAGE_CREATED_AT_KEY]) ??\n      readInstantMs(message[MESSAGE_CREATED_AT_KEY])\n    );\n  }\n  return null;\n}\n\n// ─── Facts ───────────────────────────────────────────────────────────\n\n/** \"1 tool call\", \"12 tool calls\". */\nexport function toolCallCountLabel(count: number): string {\n  return `${count} tool call${count === 1 ? '' : 's'}`;\n}\n\n/** The lane's own plan, as completed and total steps; `null` before it writes one. */\nexport function lanePlanProgress(\n  snapshot: Pick<SubagentDiscoverySnapshot, 'todos'>,\n): { done: number; total: number } | null {\n  const total = snapshot.todos?.length ?? 0;\n  if (total === 0) return null;\n  const done = snapshot.todos?.filter((todo) => todo.status === 'completed').length ?? 0;\n  return { done, total };\n}\n\n/**\n * The card footer's facts: its tool calls and its plan's progress. A count of\n * none is left out: an in-eval lane reports its tool calls only once it\n * finishes, so \"0 tool calls\" would mislead.\n */\nexport function laneFacts(\n  snapshot: Pick<SubagentDiscoverySnapshot, 'toolCallCount' | 'todos'>,\n): string[] {\n  const plan = lanePlanProgress(snapshot);\n  return [\n    snapshot.toolCallCount > 0 ? toolCallCountLabel(snapshot.toolCallCount) : null,\n    plan ? `${plan.done}/${plan.total} steps` : null,\n  ].filter((fact): fact is string => fact !== null);\n}\n\n/** \"812\", \"12.4k\", \"1.2M\": a token count as the session's usage shows it. */\nexport function formatTokenCount(tokens: number): string {\n  if (!Number.isFinite(tokens)) return '-';\n  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`;\n  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;\n  return tokens.toLocaleString();\n}\n\n/** A lane's token use as one count: its input, the prompt cache included, and its output. */\nexport function laneTokenCount(usage: SubagentTokenUsage): number {\n  return usage.inputTokens + usage.outputTokens;\n}\n\n/**\n * A lane's token use as a summary segment: `412.3k tokens`, or `412.3k+ tokens`\n * while it is a floor (the lane runs, or only the steps held were counted).\n * `null` for a lane that reports no use.\n */\nexport function formatLaneTokens(usage: SubagentTokenUsage | undefined): string | null {\n  if (usage === undefined) return null;\n  const count = laneTokenCount(usage);\n  if (!Number.isFinite(count) || count <= 0) return null;\n  return `${formatTokenCount(count)}${usage.partial ? '+' : ''} tokens`;\n}\n\n/** A lane's input (prompt cache included) and output tokens, each a floor (`+`) while the use is. */\nexport function laneTokenBreakdown(usage: SubagentTokenUsage): string {\n  const floor = usage.partial ? '+' : '';\n  return `${formatTokenCount(usage.inputTokens)}${floor} in · ${formatTokenCount(usage.outputTokens)}${floor} out`;\n}\n\n// ─── Steps ───────────────────────────────────────────────────────────\n\n/** \"1 step\", \"12 steps\". */\nfunction stepsLabel(count: number): string {\n  return `${count} step${count === 1 ? '' : 's'}`;\n}\n\n/** What the transcript says about the steps it shows of a cut lane; `null` when it shows them all. */\nexport function laneStepsNote({\n  shown,\n  total,\n  arrivesLater,\n}: {\n  /** Steps the transcript shows. */\n  shown: number;\n  /** Steps the lane stores (its cut marker), when the card carries fewer. */\n  total: number | undefined;\n  /**\n   * A running lane on a host that pages no running lane: its card brings the\n   * rest once the subagent finishes.\n   */\n  arrivesLater: boolean;\n}): string | null {\n  if (total === undefined || total <= shown) return null;\n  const leftOff = total - shown;\n  return arrivesLater\n    ? `Showing the latest steps. ${leftOff} earlier ${leftOff === 1 ? 'step arrives' : 'steps arrive'} when this subagent finishes.`\n    : `Showing the latest ${shown} of ${stepsLabel(total)}.`;\n}\n\n// ─── Paging ──────────────────────────────────────────────────────────\n\n/** Lanes per page once a parallel group paginates (two rows of two). */\nexport const SUBAGENT_LANES_PAGE_SIZE = 4;\n\n/** How many pages `count` lanes take; a lone lane never pages. */\nexport function subagentLanePageCount(count: number): number {\n  return count > 1 ? Math.max(1, Math.ceil(count / SUBAGENT_LANES_PAGE_SIZE)) : 1;\n}\n"],"names":["SUBAGENT_AWAITING_APPROVAL_LABEL","formatWorkDuration","isTerminalSubagentStatus","readInstantMs","MESSAGE_CREATED_AT_KEY"],"mappings":"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"}

package/dist/subagents/lane-model.d.ts

@@ -0,0 +1,140 @@
+/**
+ * What the subagent lanes say, as pure functions: a lane's title and type,
+ * its status words, its duration, its facts and token use, and a fan-out's
+ * counts. The lane card, the orchestration strip, the transcript drawer and a
+ * host's own surfaces (Olympus's header popover) read them, so every place a
+ * lane shows says the same.
+ */
+import { type SubagentDiscoverySnapshot, type SubagentStatus, type SubagentTokenUsage } from '../agent-runtime/src/index';
+/**
+ * A preset subagent's type in sentence case ("code-reviewer" → "Code
+ * reviewer"); `null` for the default general-purpose subagent, whose type is
+ * not worth a label.
+ */
+export declare function subagentTypeLabel(name: string): string | null;
+/** What a lane is called: its task brief, else its preset's name, else "Subagent". */
+export declare function subagentLaneTitle(snapshot: Pick<SubagentDiscoverySnapshot, 'name' | 'description'>): string;
+/**
+ * A lane's status in words. `queued` covers both a `task` call awaiting its
+ * first event and an in-eval dispatch waiting for one of the bridge's
+ * concurrency slots.
+ */
+export declare const SUBAGENT_STATUS_LABELS: Record<SubagentStatus, string>;
+/** What a lane reads once the run that delegated it ended before it settled. */
+export declare const SUBAGENT_STOPPED_LABEL = "Stopped";
+/** A stopped lane's card, when the lane left no output of its own. */
+export declare const SUBAGENT_STOPPED_OUTPUT = "Stopped before it finished.";
+/** A lane's status word, or the wait for approval (or the stop) that stands in for it. */
+export declare function subagentStatusLabel({ status, awaitingApproval, stopped, }: {
+    status: SubagentStatus;
+    awaitingApproval?: boolean;
+    stopped?: boolean;
+}): string;
+/**
+ * A fan-out's lanes counted in the lanes' own words, lanes waiting for
+ * approval first ("1 waiting for approval · 2 running · 4 done · 1 failed");
+ * a count of none is left out.
+ */
+export declare function subagentCountParts({ awaiting, queued, running, complete, failed, stopped, }: {
+    awaiting?: number;
+    queued: number;
+    running: number;
+    complete: number;
+    failed: number;
+    stopped?: number;
+}): string[];
+/** A lane goes quiet this long before its card says it has seen no activity. */
+export declare const SUBAGENT_STALL_THRESHOLD_MS = 30000;
+/**
+ * When this client saw a lane begin, change and finish. The wire carries no
+ * event stamps for a lane's steps, so its card keeps its own: the stall badge
+ * reads `lastEventAt`, and a duration it witnessed reads `firstSeenAt` to
+ * `completedAt`.
+ */
+export interface SubagentTiming {
+    firstSeenAt: number;
+    lastEventAt: number;
+    completedAt: number | null;
+    /** True once this client saw the lane running (false for a lane reopened finished). */
+    sawActive: boolean;
+}
+/** "29s", "2m 05s", "1h 03m". */
+export declare function formatLaneElapsed(ms: number): string;
+/**
+ * A finished lane's runtime as the backend reported it (`durationMs`: an
+ * in-eval dispatch's terminal event, or a `task` result's own stamps), which
+ * survives a reload where this client's timing does not. `undefined` while the
+ * lane runs or when nothing reported it.
+ */
+export declare function reportedDurationLabel(snapshot: Pick<SubagentDiscoverySnapshot, 'status' | 'durationMs'>): string | undefined;
+/**
+ * The duration a lane shows: the backend's for a finished lane, else how long
+ * a running lane has run, else a finished lane's runtime this client
+ * witnessed. Never a fabricated "0s" for a lane reopened finished.
+ */
+export declare function laneDurationLabel({ snapshot, timing, now, stopped, }: {
+    snapshot: Pick<SubagentDiscoverySnapshot, 'status' | 'durationMs'>;
+    timing: SubagentTiming | undefined;
+    now: number;
+    /** The run ended before the lane settled: it runs no longer. */
+    stopped?: boolean;
+}): string | undefined;
+/**
+ * How long a finished `task` lane ran, measured by the server: the 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. Parallel siblings share it (one message makes
+ * them all). `null` without one.
+ */
+export declare function laneDelegatedAtMs({ sources, toolCallId, }: {
+    sources: readonly unknown[];
+    toolCallId: string;
+}): number | null;
+/** "1 tool call", "12 tool calls". */
+export declare function toolCallCountLabel(count: number): string;
+/** The lane's own plan, as completed and total steps; `null` before it writes one. */
+export declare function lanePlanProgress(snapshot: Pick<SubagentDiscoverySnapshot, 'todos'>): {
+    done: number;
+    total: number;
+} | null;
+/**
+ * The card footer's facts: its tool calls and its plan's progress. A count of
+ * none is left out: an in-eval lane reports its tool calls only once it
+ * finishes, so "0 tool calls" would mislead.
+ */
+export declare function laneFacts(snapshot: Pick<SubagentDiscoverySnapshot, 'toolCallCount' | 'todos'>): string[];
+/** "812", "12.4k", "1.2M": a token count as the session's usage shows it. */
+export declare function formatTokenCount(tokens: number): string;
+/** A lane's token use as one count: its input, the prompt cache included, and its output. */
+export declare function laneTokenCount(usage: SubagentTokenUsage): number;
+/**
+ * A lane's token use as a summary segment: `412.3k tokens`, or `412.3k+ tokens`
+ * while it is a floor (the lane runs, or only the steps held were counted).
+ * `null` for a lane that reports no use.
+ */
+export declare function formatLaneTokens(usage: SubagentTokenUsage | undefined): string | null;
+/** A lane's input (prompt cache included) and output tokens, each a floor (`+`) while the use is. */
+export declare function laneTokenBreakdown(usage: SubagentTokenUsage): string;
+/** What the transcript says about the steps it shows of a cut lane; `null` when it shows them all. */
+export declare function laneStepsNote({ shown, total, arrivesLater, }: {
+    /** Steps the transcript 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;
+/** Lanes per page once a parallel group paginates (two rows of two). */
+export declare const SUBAGENT_LANES_PAGE_SIZE = 4;
+/** How many pages `count` lanes take; a lone lane never pages. */
+export declare function subagentLanePageCount(count: number): number;