@opengeni/react 0.23.0 → 0.25.5

package/dist/chunk-OZDLELJQ.js

@@ -0,0 +1,937 @@
+import {
+  CREDIT_EXHAUSTION_MESSAGE,
+  humanizeFailureReason,
+  isCreditExhaustion,
+  tryParseJson
+} from "./chunk-M7X4JZOD.js";
+
+// src/timeline/projection.ts
+var { default: fleetDecisionItem } = await import("./fleet-decision-projection-SLNZMS42.js");
+function toolDisplayName(name) {
+  const boundary = name.indexOf("__");
+  const toolPart = boundary >= 0 ? name.slice(boundary + 2) : name;
+  return toolPart.replace(/[_-]+/g, " ").trim();
+}
+var WORKER_SPAWN_TOOL = "session_create";
+var WORKER_MESSAGE_TOOL = "session_send_message";
+function buildTimeline(events) {
+  const items = [];
+  const prescan = prescanTurnAnchors(events);
+  const ordered = orderTimelineEvents(events, prescan);
+  const last = () => items[items.length - 1];
+  const closeStreamingTail = () => {
+    const open = last();
+    if ((open?.kind === "agent-message" || open?.kind === "reasoning") && open.streaming) {
+      open.streaming = false;
+    }
+  };
+  const finalizeOpen = (turnId, disposition = "complete") => {
+    for (const item of items) {
+      if (turnId !== void 0 && "turnId" in item && item.turnId && turnId && item.turnId !== turnId) {
+        continue;
+      }
+      if ((item.kind === "agent-message" || item.kind === "reasoning") && item.streaming) {
+        item.streaming = false;
+      }
+      if ((item.kind === "tool-call" || item.kind === "worker") && item.status === "running") {
+        item.status = disposition;
+      }
+      if (item.kind === "sandbox" && item.status === "running") {
+        item.status = disposition;
+      }
+    }
+  };
+  for (const event of ordered) {
+    const payload = asRecord(event.payload);
+    const turnId = event.turnId ?? null;
+    switch (event.type) {
+      case "user.message": {
+        closeStreamingTail();
+        const childCompletion = workerCompletionPayload(payload.childCompletion);
+        if (childCompletion) {
+          items.push({
+            kind: "worker-completion",
+            id: event.id,
+            turnId,
+            occurredAt: event.occurredAt,
+            childSessionId: childCompletion.childSessionId,
+            childStatus: childCompletion.childStatus,
+            goalStatus: childCompletion.goalStatus,
+            goalText: childCompletion.goalText,
+            evidence: childCompletion.evidence,
+            pausedReason: childCompletion.pausedReason,
+            text: typeof payload.text === "string" ? payload.text : ""
+          });
+          break;
+        }
+        items.push({
+          kind: "user-message",
+          id: event.id,
+          text: typeof payload.text === "string" ? payload.text : "",
+          resources: resourceRefs(payload.resources),
+          tools: toolRefs(payload.tools),
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "agent.message.delta": {
+        const text = typeof payload.text === "string" ? payload.text : "";
+        if (!text) {
+          break;
+        }
+        const open = last();
+        if (open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
+          open.text += text;
+          break;
+        }
+        closeStreamingTail();
+        items.push({
+          kind: "agent-message",
+          id: event.id,
+          turnId,
+          text,
+          streaming: true,
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "agent.message.completed": {
+        const text = typeof payload.text === "string" ? payload.text : "";
+        const open = [...items].reverse().find(
+          (item) => item.kind === "agent-message" && item.turnId === turnId
+        );
+        if (open && (open.streaming || !open.text || text === open.text || text.startsWith(open.text))) {
+          if (!open.text || text && text.startsWith(open.text)) {
+            open.text = text || open.text;
+          }
+          open.streaming = false;
+          break;
+        }
+        if (text) {
+          items.push({
+            kind: "agent-message",
+            id: event.id,
+            turnId,
+            text,
+            streaming: false,
+            occurredAt: event.occurredAt
+          });
+        }
+        break;
+      }
+      case "agent.reasoning.delta": {
+        const text = reasoningText(event.payload);
+        if (!text) {
+          break;
+        }
+        const open = last();
+        if (open?.kind === "reasoning" && open.streaming && open.turnId === turnId) {
+          open.text += text;
+          break;
+        }
+        closeStreamingTail();
+        items.push({
+          kind: "reasoning",
+          id: event.id,
+          turnId,
+          text,
+          streaming: true,
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "agent.toolCall.created": {
+        const name = typeof payload.name === "string" ? payload.name : "tool";
+        const callId = typeof payload.id === "string" ? payload.id : null;
+        const args = payload.arguments ?? null;
+        closeStreamingTail();
+        if (name === WORKER_SPAWN_TOOL || name === WORKER_MESSAGE_TOOL) {
+          items.push({
+            kind: "worker",
+            id: event.id,
+            turnId,
+            callId,
+            action: name === WORKER_SPAWN_TOOL ? "spawn" : "message",
+            prompt: workerPrompt(args),
+            workerSessionId: extractSessionRef(args),
+            status: "running",
+            occurredAt: event.occurredAt
+          });
+          break;
+        }
+        items.push({
+          kind: "tool-call",
+          id: event.id,
+          turnId,
+          callId,
+          name,
+          arguments: args,
+          output: void 0,
+          // The provider-native item drives the per-tool renderers (apply_patch
+          // operation, computer_call action, web_search providerData, …).
+          raw: payload.raw,
+          status: "running",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "agent.toolCall.output": {
+        const callId = typeof payload.id === "string" ? payload.id : null;
+        const target = findOpenCall(items, callId);
+        if (!target) {
+          break;
+        }
+        if (target.kind === "worker") {
+          target.status = isErrorOutput(payload) ? "failed" : "complete";
+          target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
+          break;
+        }
+        target.status = isErrorOutput(payload) ? "failed" : "complete";
+        target.output = payload.output;
+        break;
+      }
+      case "sandbox.operation.started":
+      case "sandbox.operation.completed":
+      case "sandbox.operation.failed": {
+        const name = typeof payload.name === "string" ? payload.name : "sandbox";
+        const status = event.type.endsWith(".failed") ? "failed" : event.type.endsWith(".completed") ? "complete" : "running";
+        if ((name === "repository-clone" || name === "file-resource-download") && status !== "failed") {
+          break;
+        }
+        const existing = findOpenSandbox(items, name);
+        if (existing && status !== "running") {
+          existing.status = status;
+          if (payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed") {
+            existing.origin = payload.origin;
+          }
+          const message = failureMessage(payload);
+          if (message) {
+            existing.output = existing.output ? `${existing.output}
+${message}` : message;
+          }
+          break;
+        }
+        if (!existing) {
+          closeStreamingTail();
+          items.push({
+            kind: "sandbox",
+            id: event.id,
+            turnId,
+            name,
+            command: typeof payload.command === "string" ? payload.command : null,
+            output: failureMessage(payload) ?? "",
+            origin: payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed" ? payload.origin : null,
+            status,
+            occurredAt: event.occurredAt
+          });
+        }
+        break;
+      }
+      case "sandbox.command.output.delta": {
+        const text = typeof payload.chunk === "string" ? payload.chunk : typeof payload.text === "string" ? payload.text : typeof payload.output === "string" ? payload.output : "";
+        if (!text) {
+          break;
+        }
+        const open = (typeof payload.name === "string" ? findOpenSandbox(items, payload.name) : void 0) ?? [...items].reverse().find(
+          (item) => item.kind === "sandbox" && item.status === "running"
+        );
+        if (open) {
+          open.output += text;
+        }
+        break;
+      }
+      case "session.status.changed": {
+        const status = payload.status;
+        if (!isSessionStatus(status)) {
+          break;
+        }
+        if (!ATTENTION_STATUSES.has(status)) {
+          break;
+        }
+        const previous = [...items].reverse().find((item) => item.kind === "session-status");
+        if (previous?.status === status) {
+          break;
+        }
+        items.push({ kind: "session-status", id: event.id, status, occurredAt: event.occurredAt });
+        break;
+      }
+      case "session.requiresAction": {
+        finalizeOpen(turnId);
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "waiting",
+          text: "Approval needed \u2014 the turn is paused until someone decides.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "session.context.compacted": {
+        closeStreamingTail();
+        const before = typeof payload.estimatedTokensBefore === "number" ? Math.round(payload.estimatedTokensBefore).toLocaleString("en-US") : null;
+        const after = typeof payload.estimatedTokensAfter === "number" ? Math.round(payload.estimatedTokensAfter).toLocaleString("en-US") : null;
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "waiting",
+          text: before && after ? `Active conversation history compacted from approximately ${before} to ${after} tokens.` : "Context compacted so the turn could continue.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "session.context.compaction.skipped": {
+        closeStreamingTail();
+        const reason = typeof payload.reason === "string" ? payload.reason : null;
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: reason === "summarization_failed" ? "failed" : "waiting",
+          text: reason === "no_history" ? "Context compaction skipped because there is no active history to compact." : reason === "replacement_not_smaller" ? "Context compaction skipped because the generated checkpoint would not reduce the context." : reason === "replacement_unchanged" ? "Context compaction stopped because it reproduced the same checkpoint without making progress." : reason === "summarization_failed" ? "Context compaction failed without replacing the active conversation history. Request it again to retry." : "Context compaction was not needed.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "turn.recovery.requested": {
+        break;
+      }
+      case "turn.event.rejected_late": {
+        break;
+      }
+      case "tool.auth_needed":
+      case "credential.auth_needed": {
+        closeStreamingTail();
+        items.push({
+          kind: "auth-needed",
+          id: event.id,
+          turnId,
+          providerDomain: typeof payload.providerDomain === "string" ? payload.providerDomain : "",
+          connectionId: typeof payload.connectionId === "string" ? payload.connectionId : null,
+          reason: authNeededReason(payload.reason),
+          scopes: stringList(payload.scopes),
+          resource: typeof payload.resource === "string" ? payload.resource : null,
+          toolName: typeof payload.toolName === "string" ? payload.toolName : null,
+          authorizationUrl: typeof payload.authorizationUrl === "string" ? payload.authorizationUrl : null,
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "turn.completed": {
+        if (payload.maintenance === "context_compaction") {
+          finalizeOpen(turnId);
+          break;
+        }
+        if (isCreditExhaustionPayload(payload)) {
+          finalizeOpen(turnId);
+          items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
+          items.push({
+            kind: "notice",
+            id: event.id,
+            tone: "failed",
+            text: CREDIT_EXHAUSTION_MESSAGE,
+            occurredAt: event.occurredAt
+          });
+          break;
+        }
+        finalizeOpen(turnId);
+        items.push(turnEndItem(event, "complete", null));
+        break;
+      }
+      case "turn.failed": {
+        const hadActivity = hasTurnActivity(items, turnId);
+        const failureText = isCreditExhaustionPayload(payload) ? CREDIT_EXHAUSTION_MESSAGE : failureMessage(payload);
+        finalizeOpen(turnId, "cancelled");
+        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": {
+        if (turnId && !prescan.startedTurnIds.has(turnId)) {
+          break;
+        }
+        const hadActivity = hasTurnActivity(items, turnId);
+        finalizeOpen(turnId, "cancelled");
+        items.push(turnEndItem(event, "cancelled", null));
+        if (!hadActivity) {
+          items.push({
+            kind: "notice",
+            id: event.id,
+            tone: "cancelled",
+            text: "Interrupted.",
+            occurredAt: event.occurredAt
+          });
+        }
+        break;
+      }
+      case "memory.saved":
+      case "memory.corrected": {
+        const memory = memoryItem(event.id, event.type, turnId, payload, event.occurredAt);
+        if (memory) {
+          closeStreamingTail();
+          items.push(memory);
+        }
+        break;
+      }
+      case "codex.fleet.decision": {
+        const decision = fleetDecisionItem(event, payload);
+        if (decision) {
+          closeStreamingTail();
+          items.push(decision);
+        }
+        break;
+      }
+      case "goal.set":
+      case "goal.updated":
+      case "goal.completed":
+      case "goal.paused":
+      case "goal.resumed":
+      case "goal.cleared":
+      case "goal.continuation": {
+        items.push({
+          kind: "goal",
+          id: event.id,
+          action: event.type.slice("goal.".length),
+          text: goalText(payload),
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return items;
+}
+function isCreditExhaustionPayload(payload) {
+  return isCreditExhaustion({
+    error: typeof payload.error === "string" ? payload.error : null,
+    detail: typeof payload.detail === "string" ? payload.detail : null,
+    segmentLimit: typeof payload.segmentLimit === "string" ? payload.segmentLimit : null
+  });
+}
+function creditExhaustedFromEvents(events) {
+  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
+  for (let index = ordered.length - 1; index >= 0; index -= 1) {
+    const event = ordered[index];
+    if (event?.type !== "turn.completed" && event?.type !== "turn.failed" && event?.type !== "turn.cancelled") {
+      continue;
+    }
+    return isCreditExhaustionPayload(asRecord(event.payload));
+  }
+  return false;
+}
+function sessionStatusFromEvents(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type !== "session.status.changed") {
+      continue;
+    }
+    const status = asRecord(event.payload).status;
+    if (isSessionStatus(status)) {
+      return status;
+    }
+  }
+  return null;
+}
+function isActivityItem(item) {
+  switch (item.kind) {
+    case "reasoning":
+    case "tool-call":
+    case "worker":
+    case "sandbox":
+    case "memory":
+    case "fleet-decision":
+      return true;
+    default:
+      return false;
+  }
+}
+function groupTimeline(items) {
+  const groups = [];
+  for (const item of items) {
+    if (isActivityItem(item)) {
+      const open = groups[groups.length - 1];
+      if (open?.kind === "activity" && open.outcome === void 0) {
+        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;
+}
+function prescanTurnAnchors(events) {
+  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
+  const queuedTurnByTrigger = /* @__PURE__ */ new Map();
+  const startSeqByTrigger = /* @__PURE__ */ new Map();
+  const cancelledTurnIds = /* @__PURE__ */ new Set();
+  const fallbackSeqByTurn = /* @__PURE__ */ new Map();
+  const startedTurnIds = /* @__PURE__ */ new Set();
+  for (const event of ordered) {
+    const payload = asRecord(event.payload);
+    const turnId = event.turnId ?? null;
+    if (event.type === "turn.queued") {
+      const triggerEventId = typeof payload.triggerEventId === "string" ? payload.triggerEventId : null;
+      const queuedTurnId = typeof payload.turnId === "string" ? payload.turnId : turnId;
+      if (triggerEventId && queuedTurnId) {
+        queuedTurnByTrigger.set(triggerEventId, queuedTurnId);
+      }
+      continue;
+    }
+    if (event.type === "turn.started") {
+      const triggerEventId = typeof payload.triggerEventId === "string" ? payload.triggerEventId : null;
+      if (triggerEventId && !startSeqByTrigger.has(triggerEventId)) {
+        startSeqByTrigger.set(triggerEventId, event.sequence);
+      }
+      if (turnId) {
+        startedTurnIds.add(turnId);
+      }
+    } else if (event.type === "turn.cancelled" && turnId) {
+      cancelledTurnIds.add(turnId);
+    }
+    if (turnId && isTurnExecutionEvidence(event.type)) {
+      const previous = fallbackSeqByTurn.get(turnId);
+      if (previous === void 0 || event.sequence < previous) {
+        fallbackSeqByTurn.set(turnId, event.sequence);
+      }
+    }
+    if (turnId && isTurnExecutionEvidence(event.type)) {
+      startedTurnIds.add(turnId);
+    }
+  }
+  for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
+    if (!startSeqByTrigger.has(triggerEventId)) {
+      const fallbackSeq = fallbackSeqByTurn.get(turnId);
+      if (fallbackSeq !== void 0) {
+        startSeqByTrigger.set(triggerEventId, fallbackSeq);
+      }
+    }
+  }
+  const cancelledBeforeStartTriggers = /* @__PURE__ */ new Set();
+  for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
+    if (cancelledTurnIds.has(turnId) && !startSeqByTrigger.has(triggerEventId) && !fallbackSeqByTurn.has(turnId)) {
+      cancelledBeforeStartTriggers.add(triggerEventId);
+    }
+  }
+  return { queuedTurnByTrigger, startSeqByTrigger, cancelledBeforeStartTriggers, startedTurnIds };
+}
+function orderTimelineEvents(events, prescan) {
+  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
+  const insertions = /* @__PURE__ */ new Map();
+  for (const event of ordered) {
+    if (event.type !== "user.message") {
+      continue;
+    }
+    const queuedTurnId = prescan.queuedTurnByTrigger.get(event.id);
+    if (!queuedTurnId) {
+      pushInsertion(insertions, event.sequence, event);
+      continue;
+    }
+    if (prescan.cancelledBeforeStartTriggers.has(event.id)) {
+      continue;
+    }
+    const startSeq = prescan.startSeqByTrigger.get(event.id);
+    if (startSeq !== void 0) {
+      pushInsertion(insertions, startSeq, event);
+      continue;
+    }
+  }
+  const projected = [];
+  for (const event of ordered) {
+    const before = insertions.get(event.sequence);
+    if (before) {
+      projected.push(...before);
+    }
+    if (event.type !== "user.message") {
+      projected.push(event);
+    }
+  }
+  return projected;
+}
+function pushInsertion(insertions, sequence, event) {
+  const bucket = insertions.get(sequence);
+  if (bucket) {
+    bucket.push(event);
+  } else {
+    insertions.set(sequence, [event]);
+  }
+}
+function isAgentActivityEvent(type) {
+  return type.startsWith("agent.") || type.startsWith("sandbox.");
+}
+function isTurnExecutionEvidence(type) {
+  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 === "credential.auth_needed" || type.startsWith("rig.setup.") || type === "codex.capacity.waiting" || type === "codex.capacity.resumed" || type === "codex.fleet.decision";
+}
+function turnEndItem(event, outcome, failureText) {
+  return {
+    kind: "turn-end",
+    id: `${event.id}-turn-end`,
+    turnId: event.turnId ?? null,
+    outcome,
+    failureText,
+    occurredAt: event.occurredAt
+  };
+}
+function hasTurnActivity(items, turnId) {
+  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, turnEnd) {
+  if (turnEnd.turnId === null) {
+    const trailing = groups[groups.length - 1];
+    if (trailing?.kind === "activity" && trailing.outcome === void 0) {
+      applyTurnOutcome(trailing, turnEnd);
+    }
+    return;
+  }
+  for (const group of groups) {
+    if (group.kind !== "activity" || group.outcome !== void 0) {
+      continue;
+    }
+    if (group.items.some((activity) => activity.turnId === turnEnd.turnId)) {
+      applyTurnOutcome(group, turnEnd);
+    }
+  }
+}
+function applyTurnOutcome(group, turnEnd) {
+  if (turnEnd.outcome === "complete") {
+    group.outcome = "complete";
+    return;
+  }
+  const hasFailed = group.items.some((item) => "status" in item && item.status === "failed");
+  const hasInterrupted = group.items.some(
+    (item) => "status" in item && item.status === "cancelled"
+  );
+  group.outcome = hasFailed ? "failed" : hasInterrupted ? "cancelled" : "complete";
+  if (turnEnd.failureText && hasFailed) {
+    group.failureText = turnEnd.failureText;
+  }
+}
+function foldSettledTurn(groups, turnEnd) {
+  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 = {
+    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) {
+  return group?.kind === "turn" || group?.kind === "item" && group.item.kind === "user-message";
+}
+function belongsToDifferentTurn(group, turnId) {
+  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) {
+  return group?.kind === "item" && group.item.kind === "session-status" && group.item.status !== "running";
+}
+function extractFinalAgentMessage(groups, turnEnd) {
+  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) {
+  if (!group) {
+    return void 0;
+  }
+  switch (group.kind) {
+    case "item":
+      return group.item.occurredAt;
+    case "activity":
+      return group.items[0]?.occurredAt;
+    case "turn":
+      return group.startedAt;
+  }
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+var SESSION_STATUSES = [
+  "queued",
+  "running",
+  "idle",
+  "requires_action",
+  "failed",
+  "cancelled"
+];
+var ATTENTION_STATUSES = /* @__PURE__ */ new Set([
+  "requires_action",
+  "failed",
+  "cancelled"
+]);
+function resourceRefs(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => {
+    const record = asRecord(entry);
+    if (record.kind === "repository") {
+      return typeof record.uri === "string" && typeof record.ref === "string";
+    }
+    return record.kind === "file" && typeof record.fileId === "string";
+  });
+}
+function toolRefs(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => {
+    const record = asRecord(entry);
+    return record.kind === "mcp" && typeof record.id === "string";
+  });
+}
+function workerCompletionPayload(value) {
+  const payload = asRecord(value);
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  if (typeof payload.childSessionId !== "string" || !uuidPattern.test(payload.childSessionId) || typeof payload.status !== "string" || payload.status.trim() === "") {
+    return null;
+  }
+  const goal = asRecord(payload.goal);
+  return {
+    childSessionId: payload.childSessionId,
+    childStatus: payload.status,
+    goalStatus: typeof goal.status === "string" ? goal.status : null,
+    goalText: typeof goal.text === "string" ? goal.text : null,
+    evidence: typeof goal.evidence === "string" ? goal.evidence : null,
+    // Console pauses and several server paths put the human explanation on
+    // `rationale`, not `pausedReason` — same fallback the goal pill uses, so a
+    // paused worker card never shows "Worker paused" with the reason missing.
+    pausedReason: typeof goal.pausedReason === "string" ? goal.pausedReason : typeof goal.rationale === "string" ? goal.rationale : null
+  };
+}
+function isSessionStatus(value) {
+  return typeof value === "string" && SESSION_STATUSES.includes(value);
+}
+function isErrorOutput(payload) {
+  if (payload.error === true || payload.failed === true) {
+    return true;
+  }
+  const output = payload.output;
+  return !!output && typeof output === "object" && output.isError === true;
+}
+function findOpenCall(items, callId) {
+  const reversed = [...items].reverse();
+  const isCall = (item) => item.kind === "tool-call" || item.kind === "worker";
+  if (callId) {
+    const byId = reversed.find((item) => isCall(item) && item.callId === callId);
+    if (byId) {
+      return byId;
+    }
+  }
+  return reversed.find(
+    (item) => isCall(item) && item.status === "running"
+  );
+}
+function findOpenSandbox(items, name) {
+  return [...items].reverse().find(
+    (item) => item.kind === "sandbox" && item.name === name && item.status === "running"
+  );
+}
+function failureMessage(payload) {
+  for (const key of ["error", "message"]) {
+    const value = payload[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return humanizeFailureReason(value);
+    }
+  }
+  return null;
+}
+function goalText(payload) {
+  if (typeof payload.text === "string" && payload.text) {
+    return payload.text;
+  }
+  const goal = asRecord(payload.goal);
+  if (typeof goal.text === "string" && goal.text) {
+    return goal.text;
+  }
+  if (typeof payload.prompt === "string" && payload.prompt) {
+    return payload.prompt;
+  }
+  return null;
+}
+function memoryItem(id, type, turnId, payload, occurredAt) {
+  const memoryId = typeof payload.memoryId === "string" && payload.memoryId ? payload.memoryId : null;
+  if (!memoryId) {
+    return null;
+  }
+  const replacementPreview = typeof payload.replacementPreview === "string" ? payload.replacementPreview : void 0;
+  const replacementMemoryId = typeof payload.replacementMemoryId === "string" ? payload.replacementMemoryId : void 0;
+  const action = typeof payload.action === "string" ? payload.action : void 0;
+  return {
+    kind: "memory",
+    id,
+    turnId,
+    variant: type === "memory.corrected" ? "corrected" : "saved",
+    memoryKind: typeof payload.kind === "string" ? payload.kind : "",
+    preview: typeof payload.preview === "string" ? payload.preview : "",
+    ...payload.deduped === true ? { deduped: true } : {},
+    ...replacementPreview ? { replacementPreview } : {},
+    ...action ? { action } : {},
+    memoryId,
+    ...replacementMemoryId ? { replacementMemoryId } : {},
+    occurredAt
+  };
+}
+var AUTH_NEEDED_REASONS = /* @__PURE__ */ new Set([
+  "missing_connection",
+  "expired",
+  "insufficient_scope",
+  "refresh_failed",
+  "unsupported_auth",
+  "resource_scope_unavailable"
+]);
+function authNeededReason(value) {
+  return typeof value === "string" && AUTH_NEEDED_REASONS.has(value) ? value : null;
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+}
+function reasoningText(payload) {
+  const record = asRecord(payload);
+  if (typeof record.text === "string") {
+    return record.text;
+  }
+  const content = asRecord(asRecord(record.item).rawItem).content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    const text = asRecord(part).text;
+    return typeof text === "string" ? text : "";
+  }).join("");
+}
+function workerPrompt(args) {
+  const record = asRecord(typeof args === "string" ? tryParseJson(args) : args);
+  for (const key of ["initialMessage", "message", "text", "prompt"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
+function extractSessionRef(value, depth = 0) {
+  if (depth > 6 || value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return extractSessionRef(tryParseJson(value), depth + 1);
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const found = extractSessionRef(entry, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  if (typeof record.sessionId === "string" && looksLikeId(record.sessionId)) {
+    return record.sessionId;
+  }
+  if (typeof record.id === "string" && looksLikeId(record.id) && ("status" in record || "workspaceId" in record || "initialMessage" in record)) {
+    return record.id;
+  }
+  for (const key of ["structuredContent", "session", "result", "content"]) {
+    if (key in record) {
+      const found = extractSessionRef(record[key], depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  if (typeof record.text === "string") {
+    return extractSessionRef(tryParseJson(record.text), depth + 1);
+  }
+  return null;
+}
+function looksLikeId(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+
+export {
+  toolDisplayName,
+  buildTimeline,
+  creditExhaustedFromEvents,
+  sessionStatusFromEvents,
+  groupTimeline,
+  extractSessionRef
+};
+//# sourceMappingURL=chunk-OZDLELJQ.js.map