@opengeni/react 0.13.0 → 0.15.0

package/src/timeline/parsers.ts

@@ -148,17 +148,34 @@ export function v4aToGitFileDiff(op: ApplyPatchOperation): GitFileDiff {
           // `@@ -0,0 +1,N @@` from the range fields once newLines is counted — a
           // pre-baked partial header (e.g. `@@ +1 @@`) renders zero lines in a
           // generic unified-diff parser.
-          cur = { oldStart: 0, oldLines: 0, newStart: 1, newLines: 0, header: "", lines: [] };
+          cur = {
+            oldStart: 0,
+            oldLines: 0,
+            newStart: 1,
+            newLines: 0,
+            header: "",
+            lines: [],
+          };
           hunks.push(cur);
           oldNo = 0;
           newNo = 1;
         }
         if (raw.startsWith("+")) {
-          cur.lines.push({ type: "add", oldNo: null, newNo: newNo++, text: raw.slice(1) });
+          cur.lines.push({
+            type: "add",
+            oldNo: null,
+            newNo: newNo++,
+            text: raw.slice(1),
+          });
           cur.newLines += 1;
           additions += 1;
         } else if (raw.startsWith("-")) {
-          cur.lines.push({ type: "del", oldNo: oldNo++, newNo: null, text: raw.slice(1) });
+          cur.lines.push({
+            type: "del",
+            oldNo: oldNo++,
+            newNo: null,
+            text: raw.slice(1),
+          });
           cur.oldLines += 1;
           deletions += 1;
         } else {
@@ -200,7 +217,10 @@ export function v4aToGitFileDiff(op: ApplyPatchOperation): GitFileDiff {
  * renderer and the turn-summary facet counter never drift.
  */
 export function applyPatchOps(raw: unknown): ApplyPatchOperation[] {
-  const r = (raw ?? {}) as { operation?: ApplyPatchOperation; operations?: ApplyPatchOperation[] };
+  const r = (raw ?? {}) as {
+    operation?: ApplyPatchOperation;
+    operations?: ApplyPatchOperation[];
+  };
   if (Array.isArray(r.operations)) {
     return r.operations;
   }
@@ -264,7 +284,21 @@ export function tailPeek(text: string): string {
  * into a flat `{ text, isError }`. Non-MCP outputs pass through as their string
  * form.
  */
-export function unwrapMcpOutput(output: unknown): { text: string; isError: boolean } {
+export function unwrapMcpOutput(output: unknown): {
+  text: string;
+  isError: boolean;
+} {
+  // Managed MCP events persist a normalized single text part as
+  // `{ type: "text", text }`; accept it alongside the SDK-native content array.
+  if (
+    output &&
+    typeof output === "object" &&
+    (output as { type?: unknown }).type === "text" &&
+    typeof (output as { text?: unknown }).text === "string"
+  ) {
+    const record = output as { text: string; isError?: unknown };
+    return { text: record.text, isError: Boolean(record.isError) };
+  }
   if (output && typeof output === "object" && "content" in output) {
     const record = output as { content?: unknown; isError?: unknown };
     const isError = Boolean(record.isError);
@@ -273,7 +307,10 @@ export function unwrapMcpOutput(output: unknown): { text: string; isError: boole
         (part): part is { type: string; text: string } =>
           !!part && typeof part === "object" && (part as { type?: unknown }).type === "text",
       );
-      return { text: textPart ? String(textPart.text) : JSON.stringify(output), isError };
+      return {
+        text: textPart ? String(textPart.text) : JSON.stringify(output),
+        isError,
+      };
     }
     return { text: JSON.stringify(output), isError };
   }

package/src/timeline/projection.ts

@@ -708,13 +708,13 @@ function prescanTurnAnchors(events: SessionEvent[]): TurnAnchorPrescan {
       cancelledTurnIds.add(turnId);
     }
 
-    if (turnId && event.type !== "turn.queued" && event.type !== "turn.cancelled") {
+    if (turnId && isTurnExecutionEvidence(event.type)) {
       const previous = fallbackSeqByTurn.get(turnId);
       if (previous === undefined || event.sequence < previous) {
         fallbackSeqByTurn.set(turnId, event.sequence);
       }
     }
-    if (turnId && isAgentActivityEvent(event.type)) {
+    if (turnId && isTurnExecutionEvidence(event.type)) {
       startedTurnIds.add(turnId);
     }
   }
@@ -798,6 +798,28 @@ function isAgentActivityEvent(type: string): boolean {
   return type.startsWith("agent.") || type.startsWith("sandbox.");
 }
 
+/**
+ * Evidence that a queued prompt crossed the execution boundary when an older
+ * or partially recovered ledger is missing its canonical `turn.started`.
+ * Queue/control bookkeeping intentionally does not qualify: moving, editing,
+ * steering, or deleting a waiting row must never make its prompt appear in the
+ * transcript as though inference had begun.
+ */
+function isTurnExecutionEvidence(type: string): boolean {
+  return (
+    isAgentActivityEvent(type) ||
+    type === "turn.completed" ||
+    type === "turn.failed" ||
+    type === "turn.recovery.requested" ||
+    type === "turn.capacity_waiting" ||
+    type === "session.requiresAction" ||
+    type === "tool.auth_needed" ||
+    type.startsWith("rig.setup.") ||
+    type === "codex.capacity.waiting" ||
+    type === "codex.capacity.resumed"
+  );
+}
+
 function turnEndItem(
   event: SessionEvent,
   outcome: TurnEndItem["outcome"],

package/styles/index.css

@@ -165,6 +165,28 @@
   }
 }
 
+/* Metric-history line draw-in. The chart path carries `pathLength={1}`, so the
+   dash math is resolution-independent: one full-length dash whose offset animates
+   from 1 (hidden) to 0 (drawn). Degrades to a solid line if animations are off. */
+@keyframes og-mh-draw {
+  from {
+    stroke-dashoffset: 1;
+  }
+  to {
+    stroke-dashoffset: 0;
+  }
+}
+.og-mh-draw {
+  stroke-dasharray: 1;
+  animation: og-mh-draw 900ms var(--og-ease-out) forwards;
+}
+@media (prefers-reduced-motion: reduce) {
+  .og-mh-draw {
+    animation: none;
+    stroke-dasharray: none;
+  }
+}
+
 /* Shimmer helper: gradient text the keyframe scrolls through. */
 .og-shimmer-text {
   background: linear-gradient(