@opengeni/react 0.5.0 → 0.6.1

package/src/timeline/projection.ts

@@ -8,6 +8,7 @@ import type {
   SessionStatusItem,
   TimelineGroup,
   TimelineItem,
+  TurnEndItem,
   ToolCallItem,
   WorkerItem,
 } from "./types";
@@ -29,6 +30,7 @@ import type {
 /** Tool names on the first-party OpenGeni MCP server that operate on sessions. */
 const WORKER_SPAWN_TOOL = "session_create";
 const WORKER_MESSAGE_TOOL = "session_send_message";
+const WORKER_INTERRUPT_TOOL = "session_interrupt";
 
 export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   const items: TimelineItem[] = [];
@@ -159,6 +161,23 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const callId = typeof payload.id === "string" ? payload.id : null;
         const args = payload.arguments ?? null;
         closeStreamingTail();
+        if (name === WORKER_INTERRUPT_TOOL) {
+          // stop (default) vs steer — the target keeps its goal on steer and
+          // picks up its next queued turn (pair with session_send_message).
+          items.push({
+            kind: "worker",
+            id: event.id,
+            turnId,
+            callId,
+            action: "interrupt",
+            prompt: null,
+            workerSessionId: extractSessionRef(args),
+            mode: workerInterruptMode(args),
+            status: "running",
+            occurredAt: event.occurredAt,
+          });
+          break;
+        }
         if (name === WORKER_SPAWN_TOOL || name === WORKER_MESSAGE_TOOL) {
           items.push({
             kind: "worker",
@@ -261,6 +280,14 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (!isSessionStatus(status)) {
           break;
         }
+        // Only attention-worthy statuses earn a timeline divider. queued /
+        // running / idle are machinery telemetry: the header pill carries the
+        // live status, the shimmer says "running", and the turn chip's duration
+        // facet says how long — a stale "idle · 27s" row is pure noise,
+        // especially in historical traces.
+        if (!ATTENTION_STATUSES.has(status)) {
+          break;
+        }
         const previous = [...items].reverse().find((item): item is SessionStatusItem => item.kind === "session-status");
         if (previous?.status === status) {
           break;
@@ -283,30 +310,40 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 
       case "turn.completed": {
         finalizeOpen(turnId);
+        items.push(turnEndItem(event, "complete", null));
         break;
       }
 
       case "turn.failed": {
+        const hadActivity = hasTurnActivity(items, turnId);
+        const failureText = failureMessage(payload);
         finalizeOpen(turnId, "failed");
-        items.push({
-          kind: "notice",
-          id: event.id,
-          tone: "failed",
-          text: failureMessage(payload) ?? "The turn failed.",
-          occurredAt: event.occurredAt,
-        });
+        items.push(turnEndItem(event, "failed", failureText));
+        if (!hadActivity) {
+          items.push({
+            kind: "notice",
+            id: event.id,
+            tone: "failed",
+            text: failureText ?? "The turn failed.",
+            occurredAt: event.occurredAt,
+          });
+        }
         break;
       }
 
       case "turn.cancelled": {
+        const hadActivity = hasTurnActivity(items, turnId);
         finalizeOpen(turnId, "cancelled");
-        items.push({
-          kind: "notice",
-          id: event.id,
-          tone: "cancelled",
-          text: "Interrupted.",
-          occurredAt: event.occurredAt,
-        });
+        items.push(turnEndItem(event, "cancelled", null));
+        if (!hadActivity) {
+          items.push({
+            kind: "notice",
+            id: event.id,
+            tone: "cancelled",
+            text: "Interrupted.",
+            occurredAt: event.occurredAt,
+          });
+        }
         break;
       }
 
@@ -351,7 +388,8 @@ export function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus |
 
 /* ----------------------------------------------------------------------------
    Visual grouping: consecutive activity items (reasoning / tools / workers /
-   sandbox) cluster into one collapsible block between chat messages.
+   sandbox) cluster into collapsible blocks. Once a turn settles, the full
+   non-user span folds behind a turn group, with activity blocks nested inside.
    -------------------------------------------------------------------------- */
 
 /**
@@ -376,13 +414,18 @@ export function groupTimeline(items: TimelineItem[]): TimelineGroup[] {
   for (const item of items) {
     if (isActivityItem(item)) {
       const open = groups[groups.length - 1];
-      if (open?.kind === "activity") {
+      if (open?.kind === "activity" && open.outcome === undefined) {
         open.items.push(item);
       } else {
         groups.push({ kind: "activity", id: `activity-${item.id}`, items: [item] });
       }
       continue;
     }
+    if (item.kind === "turn-end") {
+      stampTurnOutcome(groups, item);
+      foldSettledTurn(groups, item);
+      continue;
+    }
     groups.push({ kind: "item", item });
   }
   return groups;
@@ -390,12 +433,161 @@ export function groupTimeline(items: TimelineItem[]): TimelineGroup[] {
 
 /* --- helpers ---------------------------------------------------------------- */
 
+function turnEndItem(
+  event: SessionEvent,
+  outcome: TurnEndItem["outcome"],
+  failureText: string | null,
+): TurnEndItem {
+  return {
+    kind: "turn-end",
+    id: `${event.id}-turn-end`,
+    turnId: event.turnId ?? null,
+    outcome,
+    failureText,
+    occurredAt: event.occurredAt,
+  };
+}
+
+function hasTurnActivity(items: TimelineItem[], turnId: string | null): boolean {
+  if (turnId) {
+    return items.some((item) => isActivityItem(item) && item.turnId === turnId);
+  }
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (!item || item.kind === "turn-end" || item.kind === "user-message") {
+      return false;
+    }
+    if (isActivityItem(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function stampTurnOutcome(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
+  if (turnEnd.turnId === null) {
+    const trailing = groups[groups.length - 1];
+    if (trailing?.kind === "activity" && trailing.outcome === undefined) {
+      applyTurnOutcome(trailing, turnEnd);
+    }
+    return;
+  }
+  for (const group of groups) {
+    if (group.kind !== "activity" || group.outcome !== undefined) {
+      continue;
+    }
+    if (group.items.some((activity) => activity.turnId === turnEnd.turnId)) {
+      applyTurnOutcome(group, turnEnd);
+    }
+  }
+}
+
+function applyTurnOutcome(group: Extract<TimelineGroup, { kind: "activity" }>, turnEnd: TurnEndItem): void {
+  group.outcome = turnEnd.outcome;
+  if (turnEnd.failureText) {
+    group.failureText = turnEnd.failureText;
+  }
+}
+
+function foldSettledTurn(groups: TimelineGroup[], turnEnd: TurnEndItem): void {
+  let startIndex = groups.length;
+  let stoppedAtForeignTurn = false;
+  while (startIndex > 0) {
+    const previous = groups[startIndex - 1];
+    if (isTurnBoundary(previous)) {
+      break;
+    }
+    if (belongsToDifferentTurn(previous, turnEnd.turnId)) {
+      stoppedAtForeignTurn = true;
+      break;
+    }
+    startIndex -= 1;
+  }
+  if (stoppedAtForeignTurn) {
+    while (startIndex < groups.length && isBetweenTurnDivider(groups[startIndex])) {
+      startIndex += 1;
+    }
+  }
+
+  const collected = groups.slice(startIndex);
+  if (collected.length === 0) {
+    return;
+  }
+
+  const finalMessage = extractFinalAgentMessage(collected, turnEnd);
+  const body = finalMessage ? collected.slice(0, -1) : collected;
+  if (body.length === 0) {
+    return;
+  }
+
+  const firstOccurredAt = groupStartedAt(body[0]) ?? turnEnd.occurredAt;
+  const turnGroup: TimelineGroup = {
+    kind: "turn",
+    id: `turn-${turnEnd.turnId ?? turnEnd.id}`,
+    outcome: turnEnd.outcome,
+    startedAt: firstOccurredAt,
+    endedAt: turnEnd.occurredAt,
+    groups: body,
+  };
+  if (turnEnd.failureText) {
+    turnGroup.failureText = turnEnd.failureText;
+  }
+
+  groups.splice(startIndex, collected.length, ...(finalMessage ? [turnGroup, finalMessage] : [turnGroup]));
+}
+
+function isTurnBoundary(group: TimelineGroup | undefined): boolean {
+  return group?.kind === "turn" || (group?.kind === "item" && group.item.kind === "user-message");
+}
+
+function belongsToDifferentTurn(group: TimelineGroup | undefined, turnId: string | null): boolean {
+  if (!group || !turnId) {
+    return false;
+  }
+  if (group.kind === "activity") {
+    return group.items.length > 0 && group.items.every((item) => item.turnId !== null && item.turnId !== turnId);
+  }
+  return group.kind === "item" && group.item.kind === "agent-message" && group.item.turnId !== null && group.item.turnId !== turnId;
+}
+
+function isBetweenTurnDivider(group: TimelineGroup | undefined): boolean {
+  return group?.kind === "item" && group.item.kind === "session-status" && group.item.status !== "running";
+}
+
+function extractFinalAgentMessage(groups: TimelineGroup[], turnEnd: TurnEndItem): Extract<TimelineGroup, { kind: "item" }> | null {
+  const tail = groups[groups.length - 1];
+  if (tail?.kind !== "item" || tail.item.kind !== "agent-message" || tail.item.streaming) {
+    return null;
+  }
+  if (tail.item.turnId && turnEnd.turnId && tail.item.turnId !== turnEnd.turnId) {
+    return null;
+  }
+  return tail;
+}
+
+function groupStartedAt(group: TimelineGroup | undefined): string | undefined {
+  if (!group) {
+    return undefined;
+  }
+  switch (group.kind) {
+    case "item":
+      return group.item.occurredAt;
+    case "activity":
+      return group.items[0]?.occurredAt;
+    case "turn":
+      return group.startedAt;
+  }
+}
+
 function asRecord(value: unknown): Record<string, unknown> {
   return value !== null && typeof value === "object" ? (value as Record<string, unknown>) : {};
 }
 
 const SESSION_STATUSES: readonly SessionStatus[] = ["queued", "running", "idle", "requires_action", "failed", "cancelled"];
 
+/** Statuses that demand the reader's attention and so earn a timeline divider. */
+const ATTENTION_STATUSES: ReadonlySet<SessionStatus> = new Set(["requires_action", "failed", "cancelled"]);
+
 /** Keep only entries that match the wire shapes; user payloads are untyped. */
 function resourceRefs(value: unknown): import("@opengeni/sdk").ResourceRef[] {
   if (!Array.isArray(value)) {
@@ -502,6 +694,12 @@ function workerPrompt(args: unknown): string | null {
   return null;
 }
 
+/** The interrupt mode from `session_interrupt` args; defaults to "stop". */
+function workerInterruptMode(args: unknown): "stop" | "steer" {
+  const record = asRecord(typeof args === "string" ? tryParseJson(args) : args);
+  return record.mode === "steer" ? "steer" : "stop";
+}
+
 /**
  * Find a session id in orchestration tool arguments or output. Handles raw
  * objects, JSON strings, and MCP tool results (`{ content: [{ type: "text",

package/src/timeline/turn-summary.tsx

@@ -5,40 +5,41 @@ import { cn } from "../lib/cn";
 import { useForcedDefaultOpen } from "./disclosure-context";
 import { applyPatchOps, isApplyPatch } from "./parsers";
 import { rawTypeOf } from "./registry";
-import type { ActivityItem } from "./types";
+import type { ActivityItem, TurnOutcome } from "./types";
+export type { TurnOutcome } from "./types";
 
 /* ----------------------------------------------------------------------------
    Turn summary
 
-   A completed (or failed/cancelled) turn's activity folds behind one quiet
-   summary chip: "N steps · M files · K commands · 1 screenshot". The chip is the
-   default surface; expanding it reveals the full activity rail (the caller's
-   rendered rows). A live turn never folds — render its rows directly.
+   A completed (or failed/cancelled) turn folds behind one quiet summary chip:
+   "N steps · M files · K commands · 1 screenshot · 4m". The chip is the default
+   surface; expanding it reveals the full settled turn body. A live turn never
+   folds — render its rows directly.
 
    This keeps the timeline calm: a finished turn is a single line until the
    reader chooses to look inside it.
    -------------------------------------------------------------------------- */
 
-export type TurnOutcome = "complete" | "failed" | "cancelled";
-
 export type TurnSummaryProps = {
   /** The activity items in the turn (used only to compute the facet counts). */
   items: ActivityItem[];
   outcome: TurnOutcome;
   /** A short failure reason shown inline on a failed chip (never hidden). */
   failureText?: string | undefined;
+  /** Elapsed turn duration; shown as a trailing facet when at least 1s. */
+  durationMs?: number | undefined;
   /** Start expanded. */
   defaultOpen?: boolean | undefined;
   /** The rendered activity rail revealed on expand. */
   children: React.ReactNode;
 };
 
-export function TurnSummary({ items, outcome, failureText, defaultOpen, children }: TurnSummaryProps) {
+export function TurnSummary({ items, outcome, failureText, durationMs, defaultOpen, children }: TurnSummaryProps) {
   // An explicit `defaultOpen` always wins; otherwise an ancestor may seed it
   // (screenshot instrumentation); otherwise the turn starts folded.
   const forcedDefaultOpen = useForcedDefaultOpen();
   const [open, setOpen] = useState(defaultOpen ?? forcedDefaultOpen ?? false);
-  const facets = summarizeTurn(items);
+  const facets = summarizeTurn(items, durationMs);
 
   return (
     <Collapsible.Root open={open} onOpenChange={setOpen} className="animate-og-enter">
@@ -92,7 +93,7 @@ export function TurnSummary({ items, outcome, failureText, defaultOpen, children
 }
 
 /** Compose the facet summary line ("14 steps · 3 files · 2 commands · 1 screenshot · 4m"). */
-function summarizeTurn(items: ActivityItem[]): string {
+function summarizeTurn(items: ActivityItem[], durationMs?: number): string {
   let files = 0;
   let commands = 0;
   let screenshots = 0;
@@ -121,5 +122,26 @@ function summarizeTurn(items: ActivityItem[]): string {
   if (screenshots) {
     parts.push(`${screenshots} ${screenshots === 1 ? "screenshot" : "screenshots"}`);
   }
+  const duration = formatDurationFacet(durationMs);
+  if (duration) {
+    parts.push(duration);
+  }
   return parts.join(" · ");
 }
+
+function formatDurationFacet(durationMs: number | undefined): string | null {
+  if (durationMs === undefined || !Number.isFinite(durationMs) || durationMs < 1000) {
+    return null;
+  }
+  const totalSeconds = Math.floor(durationMs / 1000);
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) {
+    return `${totalMinutes}m`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}

package/src/timeline/types.ts

@@ -69,11 +69,16 @@ export type WorkerItem = {
   id: string;
   turnId: string | null;
   callId: string | null;
-  action: "spawn" | "message";
+  action: "spawn" | "message" | "interrupt";
   /** The worker's initial message / the message sent to it, when parseable. */
   prompt: string | null;
   /** The target/spawned worker session id, when parseable from args/output. */
   workerSessionId: string | null;
+  /**
+   * For an `interrupt` action, whether it stops the target (default) or steers
+   * it (cancel the current turn, keep the goal). Absent on spawn/message.
+   */
+  mode?: "stop" | "steer";
   status: "running" | "complete" | "failed" | "cancelled";
   occurredAt: string;
 };
@@ -112,6 +117,17 @@ export type NoticeItem = {
   occurredAt: string;
 };
 
+export type TurnOutcome = "complete" | "failed" | "cancelled";
+
+export type TurnEndItem = {
+  kind: "turn-end";
+  id: string;
+  turnId: string | null;
+  outcome: TurnOutcome;
+  failureText: string | null;
+  occurredAt: string;
+};
+
 export type TimelineItem =
   | UserMessageItem
   | AgentMessageItem
@@ -121,11 +137,21 @@ export type TimelineItem =
   | SandboxItem
   | SessionStatusItem
   | GoalItem
-  | NoticeItem;
+  | NoticeItem
+  | TurnEndItem;
 
 /** Activity items cluster between chat messages (reasoning, tools, workers, sandbox). */
 export type ActivityItem = ReasoningItem | ToolCallItem | WorkerItem | SandboxItem;
 
 export type TimelineGroup =
   | { kind: "item"; item: TimelineItem }
-  | { kind: "activity"; id: string; items: ActivityItem[] };
+  | { kind: "activity"; id: string; items: ActivityItem[]; outcome?: TurnOutcome; failureText?: string }
+  | {
+      kind: "turn";
+      id: string;
+      outcome: TurnOutcome;
+      failureText?: string;
+      startedAt: string;
+      endedAt: string;
+      groups: TimelineGroup[];
+    };

package/src/types/machines.ts

@@ -0,0 +1,67 @@
+// ----------------------------------------------------------------------------
+// Bring-your-own-compute — Machines view-model.
+//
+// The data-contract types (MachineView / MetricSample / MachinesResponse /
+// MachineMetricsSeriesResponse / MachineKind / MachineState) are the
+// orchestrator-owned SHARED DATA CONTRACT that M10 ships in `@opengeni/sdk`
+// (hand-written mirrors of `@opengeni/contracts`, pinned by contract-parity).
+// M9 RE-EXPORTS them here so the dashboard UI imports a single, stable name and
+// never drifts from the API — exactly as the contract intends.
+//
+// (During concurrent M9/M10 development this module briefly carried a local
+// view-model with the same field names; once M10 landed the SDK types we
+// reconciled to re-export them — the field names were identical by design.)
+//
+// Endpoints these model (M10 owns the SDK client methods):
+//   GET /v1/workspaces/:ws/machines                        -> MachinesResponse
+//   GET /v1/workspaces/:ws/machines/:enrollmentId/metrics/series?window=1h
+//                                                          -> { samples: MetricSample[] }
+// ----------------------------------------------------------------------------
+import type {
+  MachineKind,
+  MachineMetricsSeriesResponse,
+  MachinesResponse,
+  MachineState,
+  MachineView,
+  MetricSample,
+} from "@opengeni/sdk";
+
+export type {
+  MachineKind,
+  MachineMetricsSeriesResponse,
+  MachinesResponse,
+  MachineState,
+  MachineView,
+  MetricSample,
+};
+
+// --- connection-status grouping (a PURE UI projection — not a contract type) --
+
+/**
+ * The three connection-status pill values the UI surfaces across the dashboard,
+ * the dock, and the timeline. `consent_required` / `display_unavailable` /
+ * `enrolling` are NOT connection states — they map onto a connection state for
+ * the pill and carry their own badge separately.
+ */
+export type ConnectionStatus = "online" | "reconnecting" | "offline";
+
+/** Project a machine `state` onto its connection-status pill value. */
+export function connectionStatusForState(state: MachineState): ConnectionStatus {
+  switch (state) {
+    case "online":
+    case "consent_required":
+    case "display_unavailable":
+      // The control plane is reachable; the limitation is consent / no display.
+      return "online";
+    case "reconnecting":
+    case "enrolling":
+      return "reconnecting";
+    case "offline":
+      return "offline";
+    default: {
+      // Exhaustiveness guard — a new state must be classified explicitly.
+      const _never: never = state;
+      return _never;
+    }
+  }
+}