@opengeni/react 3.5.1-canary.0 → 3.7.0-canary.0

package/src/timeline/projection.ts

@@ -58,6 +58,8 @@ const WORKER_SPAWN_TOOL = "session_create";
 const WORKER_MESSAGE_TOOL = "session_send_message";
 const WORKER_FAILURE_CODE_MAX_LENGTH = 128;
 const WORKER_FAILURE_MESSAGE_MAX_UTF8_BYTES = 1_024;
+type PendingWaitOutcome = { id: string; reason: string; occurredAt: string };
+type TrackedAgentResponse = { item: AgentMessageItem; completed: boolean };
 
 /**
  * Tools whose durable side-effect events already own the timeline (MemoryRow).
@@ -131,6 +133,8 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
   const items: TimelineItem[] = [];
   const prescan = prescanTurnAnchors(events);
   const ordered = orderTimelineEvents(events, prescan);
+  const pendingWaitOutcomeByTurn = new Map<string | null, PendingWaitOutcome>();
+  const latestAgentResponseByTurn = new Map<string | null, TrackedAgentResponse>();
   const humanInputRequests = humanInputRequestsById(events);
   const humanInputToolCallIds = new Set(
     [...humanInputRequests.values()]
@@ -220,6 +224,31 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
 
   const last = (): TimelineItem | undefined => items[items.length - 1];
 
+  const rememberAgentResponse = (
+    turnId: string | null,
+    item: AgentMessageItem,
+    completed: boolean,
+  ): void => {
+    latestAgentResponseByTurn.set(turnId, { item, completed });
+  };
+
+  const takePendingWaitOutcome = (turnId: string | null): PendingWaitOutcome | undefined => {
+    const outcome = pendingWaitOutcomeByTurn.get(turnId);
+    pendingWaitOutcomeByTurn.delete(turnId);
+    return outcome;
+  };
+
+  const takeAgentResponse = (turnId: string | null): TrackedAgentResponse | undefined => {
+    const response = latestAgentResponseByTurn.get(turnId);
+    latestAgentResponseByTurn.delete(turnId);
+    return response;
+  };
+
+  const clearUnscopedTerminalTracking = (): void => {
+    latestAgentResponseByTurn.delete(null);
+    pendingWaitOutcomeByTurn.delete(null);
+  };
+
   /** A new item of a different kind ends whatever was streaming at the tail. */
   const closeStreamingTail = (): void => {
     const open = last();
@@ -298,6 +327,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "user.message": {
         // A steering message must not mark in-flight tools complete; it only
         // ends whatever text was streaming. Turn lifecycle events finalize.
+        clearUnscopedTerminalTracking();
         closeStreamingTail();
         const childCompletion = workerCompletionPayload(payload.childCompletion);
         if (childCompletion) {
@@ -381,17 +411,20 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         const open = last();
         if (open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
           open.text += text;
+          rememberAgentResponse(turnId, open, false);
           break;
         }
         closeStreamingTail();
-        items.push({
+        const item: AgentMessageItem = {
           kind: "agent-message",
           id: event.id,
           turnId,
           text,
           streaming: true,
           occurredAt: event.occurredAt,
-        });
+        };
+        items.push(item);
+        rememberAgentResponse(turnId, item, false);
         break;
       }
 
@@ -447,10 +480,11 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
             items.splice(openIndex, 1);
             items.push(open);
           }
+          rememberAgentResponse(turnId, open, true);
           break;
         }
         if (text) {
-          items.push({
+          const item: AgentMessageItem = {
             kind: "agent-message",
             id: event.id,
             turnId,
@@ -466,7 +500,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
               turnId,
               text,
             },
-          });
+          };
+          items.push(item);
+          rememberAgentResponse(turnId, item, true);
         }
         break;
       }
@@ -616,6 +652,7 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       }
 
       case "turn.started": {
+        if (turnId) clearUnscopedTerminalTracking();
         if (!turnId) break;
         const queuedAt = queuedAtByTurn.get(turnId);
         if (!queuedAt) break;
@@ -781,6 +818,20 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "codex.capacity.waiting": {
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "waiting",
+          text:
+            stringValue(payload.detail) ??
+            stringValue(payload.error) ??
+            "Waiting for Codex capacity.",
+          occurredAt: event.occurredAt,
+        });
+        break;
+      }
+
       case "session.requiresAction": {
         finalizeOpen(turnId, "complete", event.occurredAt);
         items.push({
@@ -922,6 +973,8 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // extra agent response.
         if (payload.maintenance === "context_compaction") {
           finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
           break;
         }
         // Credit exhaustion arrives as a NOMINALLY completed turn (`detail:
@@ -932,6 +985,8 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         // projects exactly like a failed turn plus an explicit notice.
         if (isCreditExhaustionPayload(payload)) {
           finalizeOpen(turnId, "complete", event.occurredAt);
+          takeAgentResponse(turnId);
+          takePendingWaitOutcome(turnId);
           items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
           items.push({
             kind: "notice",
@@ -942,12 +997,68 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
           });
           break;
         }
+        const latestAgentResponse = takeAgentResponse(turnId);
+        const finalOutput = stringValue(payload.output);
+        const visibleFinalOutput = stripOpaqueCitationTokens(finalOutput).trim();
+        const visibleTrackedResponse = stripOpaqueCitationTokens(
+          latestAgentResponse?.item.text ?? "",
+        ).trim();
+        const finalOutputMirrorsCommentary =
+          latestAgentResponse?.item.phase === "commentary" &&
+          visibleTrackedResponse === visibleFinalOutput;
+        const hasAuthoritativeFinalOutput =
+          Boolean(visibleFinalOutput) && !finalOutputMirrorsCommentary;
+        const pendingWaitOutcome = takePendingWaitOutcome(turnId);
+        if (hasAuthoritativeFinalOutput) {
+          // `agent.message.completed` and `turn.completed` normally commit
+          // together, but legacy or partially compacted ledgers may retain only
+          // the terminal output receipt. Keep that authoritative response
+          // visible instead of leaving it trapped in raw audit data.
+          if (
+            latestAgentResponse &&
+            !latestAgentResponse.completed &&
+            finalOutput.startsWith(latestAgentResponse.item.text)
+          ) {
+            latestAgentResponse.item.text = finalOutput;
+            latestAgentResponse.item.streaming = false;
+            latestAgentResponse.item.occurredAt = event.occurredAt;
+            const responseIndex = items.indexOf(latestAgentResponse.item);
+            if (responseIndex >= 0 && responseIndex < items.length - 1) {
+              items.splice(responseIndex, 1);
+              items.push(latestAgentResponse.item);
+            }
+          } else if (visibleTrackedResponse !== visibleFinalOutput) {
+            items.push({
+              kind: "agent-message",
+              id: `${event.id}-output-message`,
+              turnId,
+              text: finalOutput,
+              streaming: false,
+              occurredAt: event.occurredAt,
+            });
+          }
+        }
         finalizeOpen(turnId, "complete", event.occurredAt);
         items.push(turnEndItem(event, "complete", null));
+        const hasCompletedFinalResponse =
+          latestAgentResponse?.completed === true &&
+          latestAgentResponse.item.phase !== "commentary" &&
+          Boolean(visibleTrackedResponse);
+        if (!hasAuthoritativeFinalOutput && !hasCompletedFinalResponse && pendingWaitOutcome) {
+          items.push({
+            kind: "notice",
+            id: `${pendingWaitOutcome.id}-visible-outcome`,
+            tone: "waiting",
+            text: waitingOutcomeText(pendingWaitOutcome.reason),
+            occurredAt: pendingWaitOutcome.occurredAt,
+          });
+        }
         break;
       }
 
       case "turn.failed": {
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
         // Credit death can hide behind fields `failureMessage` doesn't read
         // (detail/segmentLimit), so classify the whole payload before falling
@@ -980,6 +1091,8 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         if (turnId && !prescan.startedTurnIds.has(turnId)) {
           break;
         }
+        takeAgentResponse(turnId);
+        takePendingWaitOutcome(turnId);
         const hadActivity = hasTurnActivity(items, turnId);
         finalizeOpen(turnId, "cancelled", event.occurredAt);
         items.push(turnEndItem(event, "cancelled", null));
@@ -1025,6 +1138,9 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
       case "goal.cleared":
       case "goal.held":
       case "goal.continuation": {
+        if (event.type === "goal.held" && payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
         // Agent tool mutations already appear as tool-call rows in the activity
         // cluster. Re-emitting them as GoalRow landmarks splits "N steps" mid-turn.
         if (shouldSuppressAgentGoalLandmark(event.type, payload)) {
@@ -1043,6 +1159,13 @@ export function buildTimeline(events: SessionEvent[]): TimelineItem[] {
         break;
       }
 
+      case "session.wait.started": {
+        if (payload.actor === "agent") {
+          rememberPendingWaitOutcome(pendingWaitOutcomeByTurn, event, payload, turnId);
+        }
+        break;
+      }
+
       default:
         break;
     }
@@ -1953,6 +2076,8 @@ const SESSION_STATUSES: readonly SessionStatus[] = [
   "running",
   "idle",
   "requires_action",
+  "recovering",
+  "waiting_capacity",
   "failed",
   "cancelled",
 ];
@@ -2173,11 +2298,30 @@ function goalText(payload: Record<string, unknown>): string | null {
   return null;
 }
 
+function rememberPendingWaitOutcome(
+  pending: Map<string | null, PendingWaitOutcome>,
+  event: SessionEvent,
+  payload: Record<string, unknown>,
+  eventTurnId: string | null,
+): void {
+  const reason = stringValue(payload.reason).trim();
+  if (!reason) return;
+  const turnId =
+    eventTurnId || stringValue(payload.waitTurnId) || stringValue(payload.turnId) || null;
+  pending.set(turnId, { id: event.id, reason, occurredAt: event.occurredAt });
+}
+
+function waitingOutcomeText(reason: string): string {
+  return /^waiting\b/i.test(reason) ? reason : `Waiting: ${reason}`;
+}
+
 /**
  * Agent-owned goal mutations already have an in-cluster tool row. Suppress the
- * breakaway landmark for those only. `goal.completed` has no actor field today
- * and is only emitted by the agent tool, so it is always suppressed. API /
- * system / create-session / continuation landmarks stay visible.
+ * breakaway landmark for those only. Empty wait turns retain the durable hold
+ * reason and surface it after the folded steps. `goal.completed` has no actor
+ * field today and is only emitted by the agent tool, so it is always
+ * suppressed. API / system / create-session / continuation landmarks stay
+ * visible.
  */
 function shouldSuppressAgentGoalLandmark(type: string, payload: Record<string, unknown>): boolean {
   if (type === "goal.completed") {

package/src/timeline/registry.ts

@@ -13,7 +13,7 @@ import type { ToolCallItem } from "./types";
    Resolution order (most → least specific):
      1. exact match on `raw.type`        (e.g. "apply_patch_call", "computer_call")
      2. exact match on the tool `name`   (e.g. "exec_command", "web_search_call")
-     3. leaf match after MCP `__` prefix (e.g. opengeni__environment_set_variable)
+     3. allowed leaf match after MCP `__` prefix (e.g. opengeni__environment_set_variable)
      4. the registry's generic fallback
 
    A consumer extends the defaults without forking by passing overrides to
@@ -48,7 +48,13 @@ export type ToolRenderer = ComponentType<ToolRendererProps>;
 /** A registry entry: which key it matches and the component that renders it. */
 export type ToolRegistryEntry =
   | { match: "rawType"; type: string; render: ToolRenderer }
-  | { match: "name"; name: string; render: ToolRenderer };
+  | {
+      match: "name";
+      name: string;
+      render: ToolRenderer;
+      /** Disable untrusted `<server>__${name}` leaf matching for identity-sensitive renderers. */
+      matchPrefixedLeaf?: boolean | undefined;
+    };
 
 export type ToolRegistry = {
   /** Resolve the renderer for a call (never null — falls back to generic). */
@@ -92,6 +98,7 @@ export function createToolRegistry(
 
   const byRawType = new Map<string, ToolRenderer>();
   const byName = new Map<string, ToolRenderer>();
+  const byPrefixedLeaf = new Map<string, ToolRenderer>();
   for (const entry of entries) {
     if (entry.match === "rawType") {
       if (!byRawType.has(entry.type)) {
@@ -100,6 +107,11 @@ export function createToolRegistry(
     } else if (!byName.has(entry.name)) {
       byName.set(entry.name, entry.render);
     }
+    if (entry.match === "name" && entry.matchPrefixedLeaf !== false) {
+      if (!byPrefixedLeaf.has(entry.name)) {
+        byPrefixedLeaf.set(entry.name, entry.render);
+      }
+    }
   }
 
   const resolve = (item: ToolCallItem): ToolRenderer => {
@@ -116,7 +128,7 @@ export function createToolRegistry(
     }
     const leaf = mcpToolLeaf(item.name);
     if (leaf !== item.name) {
-      const byLeaf = byName.get(leaf);
+      const byLeaf = byPrefixedLeaf.get(leaf);
       if (byLeaf) {
         return byLeaf;
       }

package/src/timeline/tool-renderers.tsx

@@ -1085,6 +1085,98 @@ function SandboxFilePublishRenderer({ item, loadRetainedArtifact }: ToolRenderer
   );
 }
 
+type PublishedSiteReceipt = {
+  workspaceId: string;
+  artifactId: string;
+  title: string;
+  revision: number;
+  replayed: boolean;
+};
+
+function publishedSiteReceipt(output: unknown): PublishedSiteReceipt | null {
+  const { text, isError } = unwrapMcpOutput(output);
+  if (isError) return null;
+  const parsed = tryParseJson(text);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const artifact = (parsed as Record<string, unknown>).artifact;
+  const version = (parsed as Record<string, unknown>).version;
+  if (
+    !artifact ||
+    typeof artifact !== "object" ||
+    Array.isArray(artifact) ||
+    !version ||
+    typeof version !== "object" ||
+    Array.isArray(version)
+  ) {
+    return null;
+  }
+  const artifactRecord = artifact as Record<string, unknown>;
+  const versionRecord = version as Record<string, unknown>;
+  if (
+    typeof artifactRecord.workspaceId !== "string" ||
+    typeof artifactRecord.id !== "string" ||
+    typeof artifactRecord.title !== "string" ||
+    typeof versionRecord.revision !== "number" ||
+    !Number.isInteger(versionRecord.revision) ||
+    versionRecord.revision < 1
+  ) {
+    return null;
+  }
+  return {
+    workspaceId: artifactRecord.workspaceId,
+    artifactId: artifactRecord.id,
+    title: artifactRecord.title,
+    revision: versionRecord.revision,
+    replayed: (parsed as Record<string, unknown>).replayed === true,
+  };
+}
+
+function SiteOpenLink({ receipt }: { receipt: PublishedSiteReceipt }) {
+  const href = `/workspaces/${encodeURIComponent(receipt.workspaceId)}/artifacts/${encodeURIComponent(receipt.artifactId)}`;
+  return (
+    <a
+      href={href}
+      aria-label={`Open ${receipt.title}`}
+      className="inline-flex min-h-7 items-center rounded-og-sm px-2 text-og-sm font-medium text-og-accent-strong hover:bg-og-surface-2 hover:underline focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:min-h-10"
+      onClick={(event) => event.stopPropagation()}
+      onKeyDown={(event) => event.stopPropagation()}
+    >
+      Open
+    </a>
+  );
+}
+
+function SiteArtifactRenderer({ item }: ToolRendererProps) {
+  const leaf = mcpToolLeaf(item.name);
+  const publishingExisting = leaf === "artifacts_publish";
+  if (item.status === "running") {
+    return (
+      <ActivityDisclosure
+        icon={<PanelsTopLeftIcon className={ICON_SIZE} />}
+        iconTone="running"
+        title={publishingExisting ? "Publishing Site update" : "Publishing Site"}
+        running
+        preview={<RunningPreview>retaining source and compiled HTML…</RunningPreview>}
+      />
+    );
+  }
+  const receipt = publishedSiteReceipt(item.output);
+  if (!receipt || item.status === "failed") return <GenericRenderer item={item} />;
+  return (
+    <ActivityDisclosure
+      icon={<PanelsTopLeftIcon className={ICON_SIZE} />}
+      iconTone="accent"
+      title={publishingExisting ? `Updated ${receipt.title}` : `Published ${receipt.title}`}
+      media={<SiteOpenLink receipt={receipt} />}
+    >
+      <BodyNote>
+        Version {receipt.revision} is live
+        {receipt.replayed ? " (replayed from the original publication)." : "."}
+      </BodyNote>
+    </ActivityDisclosure>
+  );
+}
+
 function GeneratedImageDisclosure({
   receipt,
   load,
@@ -2198,7 +2290,7 @@ function goalToolPreview(name: string, args: unknown): string | null {
     leaf !== "goal_update" &&
     leaf !== "goal_complete" &&
     leaf !== "goal_pause" &&
-    leaf !== "goal_wait"
+    leaf !== "wait_for_input"
   ) {
     return null;
   }
@@ -2308,6 +2400,30 @@ const BASE_ENTRIES: ToolRegistryEntry[] = [
   { match: "name", name: "tool_search", render: ToolSearchRenderer },
   { match: "name", name: "view_image", render: ViewImageRenderer },
   { match: "name", name: "sandbox_file_publish", render: SandboxFilePublishRenderer },
+  {
+    match: "name",
+    name: "artifacts_create",
+    render: SiteArtifactRenderer,
+    matchPrefixedLeaf: false,
+  },
+  {
+    match: "name",
+    name: "artifacts_publish",
+    render: SiteArtifactRenderer,
+    matchPrefixedLeaf: false,
+  },
+  {
+    match: "name",
+    name: "opengeni__artifacts_create",
+    render: SiteArtifactRenderer,
+    matchPrefixedLeaf: false,
+  },
+  {
+    match: "name",
+    name: "opengeni__artifacts_publish",
+    render: SiteArtifactRenderer,
+    matchPrefixedLeaf: false,
+  },
   { match: "name", name: "environment_set_variable", render: SecretSetRenderer },
   { match: "name", name: "variable_set_set_variable", render: SecretSetRenderer },
   { match: "name", name: "search_documents", render: DocsSearchRenderer },

package/src/timeline/types.ts

@@ -279,7 +279,14 @@ export type FleetDecisionItem = {
   policyVersion: "adaptive-shadow-v1";
   actualOutcome: "selected" | "waiting" | "none";
   actualCandidateKey: string | null;
-  actualReason: "lease_reused" | "pin" | "rotation" | "active" | "all_capped" | "none";
+  actualReason:
+    | "lease_reused"
+    | "pin"
+    | "rotation"
+    | "active"
+    | "all_capped"
+    | "allocator_disabled"
+    | "none";
   shadowOutcome: "selected" | "paced" | "none";
   shadowCandidateKey: string | null;
   shadowReason: