@opengeni/react 0.15.0 → 0.23.0

package/dist/chunk-UAHPKLB6.js

@@ -0,0 +1,2237 @@
+import {
+  CREDIT_EXHAUSTION_MESSAGE,
+  humanizeFailureReason,
+  isCreditExhaustion,
+  tryParseJson,
+  useDebouncedCallback,
+  useEmbeddedHumanInputSession,
+  useEmbeddedSession,
+  useEmbeddedSessionMcpApprovalPolicy,
+  useMutationRunner,
+  usePolledValue,
+  useSessionEventTrigger
+} from "./chunk-I3BJZIG5.js";
+
+// src/timeline/projection.ts
+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 "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":
+      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";
+}
+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);
+}
+function toolDisplayName(name) {
+  const boundary = name.indexOf("__");
+  const toolPart = boundary >= 0 ? name.slice(boundary + 2) : name;
+  return toolPart.replace(/[_-]+/g, " ").trim();
+}
+
+// src/hooks/use-session-events.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var INITIAL_TAIL_PAGE_SIZE = 1e3;
+var OLDER_PAGE_SIZE = 5e3;
+var INITIAL_FETCH_CAP = 1;
+var OLDER_GROUP_TARGET = 32;
+var OLDER_FETCH_CAP = 2;
+var BOUNDARY_PAGE_CAP = 4;
+var EMPTY_EVENTS = [];
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var BROWSER_EVENT_TYPE_MAX_BYTES = 256;
+var BROWSER_EVENT_ID_MAX_BYTES = 256;
+var BROWSER_EVENT_CLIENT_ID_MAX_BYTES = 4 * 1024;
+var BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES = 4 * 1024;
+var BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES = 48 * 1024;
+var BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS = [
+  "id",
+  "callId",
+  "call_id",
+  "name",
+  "toolName",
+  "status",
+  "code",
+  "isError",
+  "stream",
+  "commandId",
+  "sequence",
+  "coalescedUntil",
+  "coalescedCount",
+  "firstSequence",
+  "lastSequence"
+];
+var SESSION_EVENT_BROWSER_MAX_BYTES = 8 * 1024 * 1024;
+var SESSION_EVENT_BROWSER_MAX_COUNT = 1e4;
+var SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES = 96 * 1024;
+var SESSION_EVENT_BROWSER_PENDING_MAX_BYTES = 1024 * 1024;
+var SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
+var EMPTY_EVENT_WINDOW = {
+  events: EMPTY_EVENTS,
+  bytes: 2,
+  truncated: false
+};
+function useSessionEvents(sessionId, options = {}) {
+  const { client, workspaceId, reconcileSession } = useEmbeddedSession(options);
+  const enabled = options.enabled ?? true;
+  const after = options.after ?? 0;
+  const replay = options.replay ?? "windowed";
+  const fullReplay = replay === "full" || after !== 0;
+  const streamKey = `${workspaceId}\0${sessionId ?? ""}\0${after}\0${fullReplay ? "full" : "windowed"}`;
+  const [eventWindow, setEventWindow] = useState(EMPTY_EVENT_WINDOW);
+  const [connectionState, setConnectionState] = useState("idle");
+  const [error, setError] = useState(null);
+  const [hasOlder, setHasOlder] = useState(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState(
+    null
+  );
+  const [initialLoading, setInitialLoading] = useState(true);
+  const [loadingOlder, setLoadingOlder] = useState(false);
+  const [streamEpoch, setStreamEpoch] = useState(0);
+  const lastSequenceRef = useRef(after);
+  const streamResumeSequenceRef = useRef(after);
+  const oldestSequenceRef = useRef(null);
+  const hasOlderRef = useRef(false);
+  const loadingOlderRef = useRef(false);
+  const initialWindowLoadedRef = useRef(false);
+  const streamAbortRef = useRef(null);
+  const streamKeyRef = useRef(null);
+  const generationRef = useRef(0);
+  const eventWindowRef = useRef(EMPTY_EVENT_WINDOW);
+  const sessionStatusRef = useRef({
+    sequence: after,
+    status: null
+  });
+  const [stateStreamKey, setStateStreamKey] = useState(streamKey);
+  useEffect(() => {
+    if (streamKeyRef.current !== streamKey) {
+      streamKeyRef.current = streamKey;
+      setStateStreamKey(streamKey);
+      eventWindowRef.current = EMPTY_EVENT_WINDOW;
+      setEventWindow(EMPTY_EVENT_WINDOW);
+      setError(null);
+      setHasOlder(false);
+      sessionStatusRef.current = { sequence: after, status: null };
+      setSessionStatusProjection(null);
+      setLoadingOlder(false);
+      setInitialLoading(true);
+      lastSequenceRef.current = after;
+      streamResumeSequenceRef.current = after;
+      oldestSequenceRef.current = null;
+      hasOlderRef.current = false;
+      loadingOlderRef.current = false;
+      initialWindowLoadedRef.current = false;
+    }
+    const generation = generationRef.current + 1;
+    generationRef.current = generation;
+    if (loadingOlderRef.current) {
+      loadingOlderRef.current = false;
+      setLoadingOlder(false);
+    }
+    if (!sessionId || !enabled) {
+      setConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    const isCurrent = () => generationRef.current === generation && !controller.signal.aborted;
+    streamAbortRef.current = controller;
+    let pending = [];
+    let pendingBytes = 2;
+    let flushTimer = null;
+    const flush = () => {
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (!isCurrent()) {
+        pending = [];
+        pendingBytes = 2;
+        return;
+      }
+      if (pending.length === 0) {
+        return;
+      }
+      const batch = pending;
+      pending = [];
+      pendingBytes = 2;
+      const lastInBatch = batch[batch.length - 1];
+      if (lastInBatch) {
+        const batchResumeSequence = Math.max(...batch.map(eventResumeSequence));
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, batchResumeSequence);
+        streamResumeSequenceRef.current = Math.max(
+          streamResumeSequenceRef.current,
+          batchResumeSequence
+        );
+      }
+      observeSessionStatus(batch, sessionStatusRef, setSessionStatusProjection);
+      const current = eventWindowRef.current;
+      const next = boundBrowserSessionEventWindow([...current.events, ...batch]);
+      const retained = {
+        ...next,
+        truncated: current.truncated || next.truncated
+      };
+      eventWindowRef.current = retained;
+      setEventWindow(retained);
+      oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+      if (retained.truncated) {
+        hasOlderRef.current = true;
+        setHasOlder(true);
+      }
+    };
+    const scheduleFlush = () => {
+      if (!isCurrent()) return;
+      flushTimer ??= setTimeout(flush, 16);
+    };
+    void (async () => {
+      try {
+        if (!fullReplay && !initialWindowLoadedRef.current) {
+          setConnectionState("connecting");
+          const window = await loadEventWindow(client, workspaceId, sessionId, {
+            before: Number.MAX_SAFE_INTEGER,
+            pageSize: INITIAL_TAIL_PAGE_SIZE,
+            targetGroups: Number.POSITIVE_INFINITY,
+            maxFetches: INITIAL_FETCH_CAP,
+            signal: controller.signal
+          });
+          if (!isCurrent()) {
+            return;
+          }
+          observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+          const retained = boundBrowserSessionEventWindow(window.events);
+          eventWindowRef.current = retained;
+          setEventWindow(retained);
+          oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
+          hasOlderRef.current = window.hasOlder || retained.truncated;
+          lastSequenceRef.current = window.newestSequence;
+          streamResumeSequenceRef.current = window.newestSequence;
+          initialWindowLoadedRef.current = true;
+          setHasOlder(window.hasOlder || retained.truncated);
+          setInitialLoading(false);
+        }
+        if (fullReplay) {
+          setInitialLoading(false);
+        }
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: streamResumeSequenceRef.current,
+          signal: controller.signal,
+          beforeLive: async () => await reconcileSession(sessionId),
+          onStateChange: (state) => {
+            if (isCurrent()) {
+              setConnectionState(state);
+            }
+          }
+        });
+        for await (const event of stream) {
+          if (!isCurrent()) break;
+          const boundedEvent = boundBrowserLegacyEvent(event);
+          const boundedEventBytes = browserJsonBytes(boundedEvent);
+          const separatorBytes = pending.length === 0 ? 0 : 1;
+          if (pending.length > 0 && (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes + separatorBytes + boundedEventBytes > SESSION_EVENT_BROWSER_PENDING_MAX_BYTES)) {
+            flush();
+          }
+          pending.push(boundedEvent);
+          pendingBytes += (pending.length === 1 ? 0 : 1) + boundedEventBytes;
+          if (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes >= SESSION_EVENT_BROWSER_PENDING_MAX_BYTES) {
+            flush();
+          } else {
+            scheduleFlush();
+          }
+        }
+        if (isCurrent()) {
+          flush();
+          setConnectionState("ended");
+        }
+      } catch (cause) {
+        if (isCurrent()) {
+          flush();
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setConnectionState("error");
+        }
+      }
+    })();
+    return () => {
+      controller.abort();
+      if (generationRef.current === generation) {
+        generationRef.current = generation + 1;
+      }
+      if (streamAbortRef.current === controller) {
+        streamAbortRef.current = null;
+      }
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+      }
+    };
+  }, [
+    client,
+    workspaceId,
+    sessionId,
+    after,
+    enabled,
+    fullReplay,
+    streamKey,
+    streamEpoch,
+    reconcileSession
+  ]);
+  const loadOlder = useCallback(async () => {
+    if (!sessionId || loadingOlderRef.current || !hasOlderRef.current) {
+      return false;
+    }
+    const before = oldestSequenceRef.current;
+    if (before === null) {
+      hasOlderRef.current = false;
+      setHasOlder(false);
+      return false;
+    }
+    const generation = generationRef.current;
+    loadingOlderRef.current = true;
+    setLoadingOlder(true);
+    try {
+      const window = await loadEventWindow(client, workspaceId, sessionId, {
+        before,
+        pageSize: OLDER_PAGE_SIZE,
+        targetGroups: OLDER_GROUP_TARGET,
+        maxFetches: OLDER_FETCH_CAP
+      });
+      if (generationRef.current !== generation) {
+        return false;
+      }
+      if (window.events.length === 0) {
+        oldestSequenceRef.current = null;
+        hasOlderRef.current = false;
+        setHasOlder(false);
+        return false;
+      }
+      const current = eventWindowRef.current;
+      assertPrependOrder(current.events, window.events);
+      streamAbortRef.current?.abort();
+      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
+        direction: "oldest"
+      });
+      const retained = {
+        ...next,
+        truncated: current.truncated || next.truncated
+      };
+      const retainedOldest = retained.events[0]?.sequence ?? null;
+      if (retainedOldest === null || retainedOldest >= before) {
+        throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
+      }
+      eventWindowRef.current = retained;
+      setEventWindow(retained);
+      oldestSequenceRef.current = retainedOldest;
+      streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+      const olderStillAvailable = window.hasOlder;
+      hasOlderRef.current = olderStillAvailable;
+      setHasOlder(olderStillAvailable);
+      setStreamEpoch((epoch) => epoch + 1);
+      return olderStillAvailable;
+    } finally {
+      if (generationRef.current === generation) {
+        loadingOlderRef.current = false;
+        setLoadingOlder(false);
+      }
+    }
+  }, [client, workspaceId, sessionId]);
+  const identityMatches = stateStreamKey === streamKey;
+  const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
+  const timeline = useMemo(() => buildTimeline(visibleEvents), [visibleEvents]);
+  return {
+    events: visibleEvents,
+    timeline,
+    sessionStatus: identityMatches ? sessionStatusProjection : null,
+    connectionState: identityMatches ? connectionState : "idle",
+    lastSequence: identityMatches ? lastSequenceRef.current : after,
+    windowBytes: identityMatches ? eventWindow.bytes : 2,
+    windowTruncated: identityMatches ? eventWindow.truncated : false,
+    initialLoading: fullReplay ? false : identityMatches ? initialLoading : true,
+    hasOlder: !identityMatches ? false : hasOlder,
+    loadingOlder: !identityMatches ? false : loadingOlder,
+    loadOlder,
+    error: identityMatches ? error : null
+  };
+}
+function boundBrowserSessionEventWindow(events, options = {}) {
+  const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
+  const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
+  const safe = events.map(boundBrowserLegacyEvent);
+  const selected = [];
+  let bytes = 2;
+  const direction = options.direction ?? "newest";
+  const start = direction === "newest" ? safe.length - 1 : 0;
+  const end = direction === "newest" ? Math.max(-1, safe.length - maxCount - 1) : safe.length;
+  const step = direction === "newest" ? -1 : 1;
+  for (let index = start; index !== end && selected.length < maxCount; index += step) {
+    const event = safe[index];
+    const eventBytes = browserJsonBytes(event);
+    const separator = selected.length === 0 ? 0 : 1;
+    if (bytes + separator + eventBytes > maxBytes) break;
+    selected.push(event);
+    bytes += separator + eventBytes;
+  }
+  if (direction === "newest") selected.reverse();
+  return {
+    events: selected,
+    bytes,
+    truncated: selected.length < safe.length
+  };
+}
+function boundBrowserLegacyEvent(event) {
+  const serialized = browserSerialize(event);
+  const originalBytes = serialized.serializable ? encoder.encode(serialized.value).byteLength : null;
+  const typeIsSafe = browserUtf8Bytes(event.type) <= BROWSER_EVENT_TYPE_MAX_BYTES && !event.type.includes("\n") && !event.type.includes("\r");
+  const clientEventId = boundBrowserOptionalText(
+    event.clientEventId,
+    BROWSER_EVENT_CLIENT_ID_MAX_BYTES
+  );
+  const duplicateReason = boundBrowserOptionalText(
+    event.duplicateReason,
+    BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES
+  );
+  if (serialized.serializable && originalBytes !== null && originalBytes <= SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES && typeIsSafe && clientEventId === event.clientEventId && duplicateReason === event.duplicateReason) {
+    return event;
+  }
+  const envelopeProjection = [
+    !typeIsSafe ? browserEnvelopeFieldProjection("type", event.type, "session.event.envelope_omitted") : null,
+    clientEventId !== event.clientEventId ? browserEnvelopeFieldProjection("clientEventId", event.clientEventId, clientEventId) : null,
+    duplicateReason !== event.duplicateReason ? browserEnvelopeFieldProjection("duplicateReason", event.duplicateReason, duplicateReason) : null
+  ].filter((field) => field !== null);
+  const payloadSerialization = browserSerialize(event.payload);
+  const payloadBytes = payloadSerialization.serializable ? encoder.encode(payloadSerialization.value).byteLength : null;
+  const preview = truncateBrowserUtf8Middle(
+    payloadSerialization.value,
+    BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES
+  );
+  const truncation = {
+    truncated: true,
+    surface: "browser_legacy_guard",
+    reason: serialized.serializable ? "event_envelope_bytes_exceeded" : "event_not_serializable",
+    originalBytes,
+    deliveredBytes: 0,
+    omittedBytes: originalBytes,
+    estimatedOriginalTokens: originalBytes === null ? null : Math.ceil(originalBytes / 4),
+    estimatedDeliveredTokens: 0,
+    fullEvidence: { available: false, reason: "not_retained" },
+    details: [
+      {
+        path: "$.payload",
+        kind: "payload_preview",
+        originalBytes: payloadBytes,
+        deliveredBytes: browserUtf8Bytes(preview)
+      }
+    ]
+  };
+  const payload = {
+    ...browserPayloadIdentity(event.payload),
+    preview,
+    ...envelopeProjection.length > 0 ? {
+      originalType: boundBrowserText(event.type, BROWSER_EVENT_TYPE_MAX_BYTES),
+      envelopeProjection: {
+        truncated: true,
+        surface: "browser_legacy_guard",
+        fields: envelopeProjection
+      }
+    } : {},
+    truncation
+  };
+  const bounded = {
+    id: boundBrowserText(event.id, BROWSER_EVENT_ID_MAX_BYTES),
+    workspaceId: boundBrowserText(event.workspaceId, BROWSER_EVENT_ID_MAX_BYTES),
+    sessionId: boundBrowserText(event.sessionId, BROWSER_EVENT_ID_MAX_BYTES),
+    sequence: event.sequence,
+    type: typeIsSafe ? event.type : "session.event.envelope_omitted",
+    payload,
+    occurredAt: boundBrowserText(event.occurredAt, BROWSER_EVENT_ID_MAX_BYTES),
+    clientEventId,
+    turnId: boundBrowserOptionalText(event.turnId, BROWSER_EVENT_ID_MAX_BYTES),
+    turnGeneration: event.turnGeneration,
+    turnAttemptId: boundBrowserOptionalText(event.turnAttemptId, BROWSER_EVENT_ID_MAX_BYTES),
+    turnAssociation: event.turnAssociation,
+    duplicateOfEventId: boundBrowserOptionalText(
+      event.duplicateOfEventId,
+      BROWSER_EVENT_ID_MAX_BYTES
+    ),
+    duplicateReason
+  };
+  settleBrowserEventTruncation(bounded, truncation);
+  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
+    payload.preview = truncateBrowserUtf8Middle(String(payload.preview), 4 * 1024);
+    truncation.details = truncation.details.slice(0, 1);
+    settleBrowserEventTruncation(bounded, truncation);
+  }
+  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
+    bounded.clientEventId = null;
+    bounded.duplicateReason = null;
+    payload.preview = "[legacy event omitted at the browser byte boundary]";
+    settleBrowserEventTruncation(bounded, truncation);
+  }
+  return bounded;
+}
+function browserJsonBytes(value) {
+  return encoder.encode(browserSerialize(value).value).byteLength;
+}
+function browserSerialize(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return { value: serialized === void 0 ? "null" : serialized, serializable: true };
+  } catch {
+    return {
+      value: '"[unserializable event payload omitted at browser boundary]"',
+      serializable: false
+    };
+  }
+}
+function browserPayloadIdentity(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {};
+  const record = payload;
+  const identity = {};
+  for (const field of BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS) {
+    const value = record[field];
+    if (typeof value === "string") {
+      identity[field] = boundBrowserText(value, BROWSER_EVENT_ID_MAX_BYTES);
+    } else if (typeof value === "number" || typeof value === "boolean" || value === null) {
+      identity[field] = value;
+    }
+  }
+  return identity;
+}
+function browserEnvelopeFieldProjection(field, original, delivered) {
+  return {
+    field,
+    originalBytes: typeof original === "string" ? browserUtf8Bytes(original) : 0,
+    deliveredBytes: typeof delivered === "string" ? browserUtf8Bytes(delivered) : 0
+  };
+}
+function boundBrowserOptionalText(value, maxBytes) {
+  return typeof value === "string" ? boundBrowserText(value, maxBytes) : value;
+}
+function boundBrowserText(value, maxBytes) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  const marker = "\u2026[truncated]";
+  const prefixBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
+  let prefixEnd = Math.min(prefixBudget, bytes.byteLength);
+  while (prefixEnd > 0 && prefixEnd < bytes.byteLength && isBrowserUtf8Continuation(bytes[prefixEnd])) {
+    prefixEnd -= 1;
+  }
+  return `${decoder.decode(bytes.subarray(0, prefixEnd))}${marker}`;
+}
+function truncateBrowserUtf8Middle(value, maxBytes) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  const marker = `\u2026[${bytes.byteLength - maxBytes} bytes omitted]\u2026`;
+  const contentBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
+  const leftBudget = Math.floor(contentBudget / 2);
+  const rightBudget = contentBudget - leftBudget;
+  let leftEnd = Math.min(leftBudget, bytes.byteLength);
+  while (leftEnd > 0 && leftEnd < bytes.byteLength && isBrowserUtf8Continuation(bytes[leftEnd])) {
+    leftEnd -= 1;
+  }
+  let rightStart = Math.max(0, bytes.byteLength - rightBudget);
+  while (rightStart < bytes.byteLength && isBrowserUtf8Continuation(bytes[rightStart])) {
+    rightStart += 1;
+  }
+  return `${decoder.decode(bytes.subarray(0, leftEnd))}${marker}${decoder.decode(bytes.subarray(rightStart))}`;
+}
+function settleBrowserEventTruncation(event, truncation) {
+  for (let attempt = 0; attempt < 16; attempt += 1) {
+    const deliveredBytes = browserJsonBytes(event);
+    const omittedBytes = truncation.originalBytes === null ? null : Math.max(0, truncation.originalBytes - deliveredBytes);
+    const estimatedDeliveredTokens = Math.ceil(deliveredBytes / 4);
+    if (truncation.deliveredBytes === deliveredBytes && truncation.omittedBytes === omittedBytes && truncation.estimatedDeliveredTokens === estimatedDeliveredTokens) {
+      return;
+    }
+    truncation.deliveredBytes = deliveredBytes;
+    truncation.omittedBytes = omittedBytes;
+    truncation.estimatedDeliveredTokens = estimatedDeliveredTokens;
+  }
+  throw new RangeError("Browser event byte accounting did not converge");
+}
+function browserUtf8Bytes(value) {
+  return encoder.encode(value).byteLength;
+}
+function isBrowserUtf8Continuation(value) {
+  return (value & 192) === 128;
+}
+function observeSessionStatus(events, ref, setStatus) {
+  let latest = null;
+  for (const event of events) {
+    const status = sessionStatusFromEvents([event]);
+    if (status && (!latest || event.sequence >= latest.sequence)) {
+      latest = { sequence: event.sequence, status };
+    }
+  }
+  if (!latest || latest.sequence < ref.current.sequence) return;
+  ref.current = latest;
+  setStatus(latest.status);
+}
+async function loadEventWindow(client, workspaceId, sessionId, options) {
+  let cursor = options.before;
+  let buffer = [];
+  let reachedStart = false;
+  let fetches = 0;
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    if (page.length === 0) {
+      reachedStart = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page[0].sequence;
+    if (isLogStart(page[0])) {
+      reachedStart = true;
+      break;
+    }
+  }
+  let snapPages = 0;
+  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < BOUNDARY_PAGE_CAP && fetches < options.maxFetches) {
+    const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    snapPages += 1;
+    if (page.length === 0) {
+      reachedStart = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page[0].sequence;
+    if (isLogStart(page[0])) {
+      reachedStart = true;
+      break;
+    }
+  }
+  if (!reachedStart) {
+    const boundary = findBoundaryIndex(buffer);
+    if (boundary > 0) {
+      buffer = buffer.slice(boundary);
+    }
+  }
+  const oldest = buffer[0] ?? null;
+  const newest = buffer[buffer.length - 1] ?? null;
+  return {
+    events: buffer,
+    oldestSequence: oldest?.sequence ?? null,
+    newestSequence: newest ? maxResumeSequence(buffer) : 0,
+    hasOlder: buffer.length > 0 && !reachedStart && oldest?.type !== "session.created"
+  };
+}
+function findBoundaryIndex(events) {
+  for (let index = 0; index < events.length; index += 1) {
+    const type = events[index].type;
+    if (type === "session.created" || type === "user.message") {
+      return index;
+    }
+  }
+  return -1;
+}
+async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  const requested = options.pageSize;
+  if (requested === 0) {
+    return Object.assign([], { requested });
+  }
+  const page = await client.listEvents(workspaceId, sessionId, {
+    before,
+    limit: requested,
+    compact: true
+  });
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  return Object.assign(page, { requested });
+}
+function groupCount(events) {
+  if (events.length === 0) {
+    return 0;
+  }
+  return groupTimeline(buildTimeline(events)).length;
+}
+function isLogStart(event) {
+  return event.type === "session.created" || event.sequence <= 1;
+}
+function maxResumeSequence(events) {
+  return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
+}
+function eventResumeSequence(event) {
+  const payload = asRecord2(event.payload);
+  const coalescedUntil = Number(payload.coalescedUntil);
+  return Math.max(event.sequence, Number.isFinite(coalescedUntil) ? Math.floor(coalescedUntil) : 0);
+}
+function asRecord2(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function assertAscending(events) {
+  for (let index = 1; index < events.length; index += 1) {
+    if (events[index - 1].sequence >= events[index].sequence) {
+      throw new Error("@opengeni/react: session events must be ordered by ascending sequence");
+    }
+  }
+}
+function assertPrependOrder(existing, older) {
+  if (!shouldAssertDevelopment() || existing.length === 0 || older.length === 0) {
+    return;
+  }
+  if (older[older.length - 1].sequence >= existing[0].sequence) {
+    throw new Error("@opengeni/react: loadOlder returned overlapping session events");
+  }
+}
+function shouldAssertDevelopment() {
+  const processEnv = globalThis.process?.env;
+  return processEnv !== void 0 && processEnv.NODE_ENV !== "production";
+}
+function abortError() {
+  const error = new Error("The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+
+// src/hooks/use-turn-queue.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useLayoutEffect, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+function isTurnQueueEvent(event) {
+  return event.type.startsWith("turn.") || event.type.startsWith("session.queue.") || event.type.startsWith("session.control.") || event.type.startsWith("workspace.inference.");
+}
+function queueSnapshotCovers(candidate, observed) {
+  return Boolean(
+    candidate && candidate.version >= observed.version && candidate.effectiveControl.controlVersion >= observed.effectiveControl.controlVersion
+  );
+}
+var EMPTY_PENDING_BY_TURN = {};
+function useTurnQueue(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSession(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const [snapshot, setSnapshot] = useState2(null);
+  const [stateTargetKey, setStateTargetKey] = useState2(targetKey);
+  const [loading, setLoading] = useState2(enabled);
+  const [error, setError] = useState2(null);
+  const [mutationError, setMutationError] = useState2(null);
+  const [pendingByTurn, setPendingByTurn] = useState2({});
+  const pendingRef = useRef2({});
+  const readGeneration = useRef2(0);
+  const targetKeyRef = useRef2(targetKey);
+  const snapshotRef = useRef2(null);
+  useLayoutEffect(() => {
+    if (targetKeyRef.current === targetKey) return;
+    targetKeyRef.current = targetKey;
+    readGeneration.current += 1;
+    snapshotRef.current = null;
+    pendingRef.current = {};
+    setStateTargetKey(targetKey);
+    setSnapshot(null);
+    setLoading(enabled);
+    setError(null);
+    setMutationError(null);
+    setPendingByTurn({});
+  }, [enabled, targetKey]);
+  const acceptSnapshot = useCallback2(
+    (ownedTargetKey, next) => {
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      const current = snapshotRef.current;
+      if (next && current && (next.version < current.version || next.effectiveControl.controlVersion < current.effectiveControl.controlVersion)) {
+        return false;
+      }
+      snapshotRef.current = next;
+      setStateTargetKey(ownedTargetKey);
+      setSnapshot(next);
+      return true;
+    },
+    []
+  );
+  const load = useCallback2(
+    async (rejectOnFailure = false) => {
+      if (!sessionId) return;
+      const ownedTargetKey = `${workspaceId}\0${sessionId}`;
+      const ticket = ++readGeneration.current;
+      try {
+        const fetched = await client.getQueue(workspaceId, sessionId);
+        if (targetKeyRef.current !== ownedTargetKey) return;
+        const ownsLatestRead = ticket === readGeneration.current;
+        if (rejectOnFailure) {
+          const committed = acceptSnapshot(ownedTargetKey, fetched);
+          if (!committed && !queueSnapshotCovers(snapshotRef.current, fetched)) {
+            throw new TypeError("Queue reconciliation did not commit authoritative state");
+          }
+          setError(null);
+          if (ownsLatestRead) setLoading(false);
+        } else if (ownsLatestRead) {
+          acceptSnapshot(ownedTargetKey, fetched);
+          setError(null);
+          setLoading(false);
+        }
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && (ticket === readGeneration.current || rejectOnFailure)) {
+          setError(asError(cause));
+          if (ticket === readGeneration.current) setLoading(false);
+        }
+        if (rejectOnFailure) throw cause;
+      }
+    },
+    [client, workspaceId, sessionId, acceptSnapshot]
+  );
+  useEffect2(() => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    void load();
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      return () => {
+        readGeneration.current += 1;
+      };
+    }
+    const timer = setInterval(() => void load(), pollIntervalMs);
+    return () => {
+      clearInterval(timer);
+      readGeneration.current += 1;
+    };
+  }, [load, enabled, options.pollIntervalMs]);
+  useEffect2(() => {
+    if (enabled && workspaceControlEvent) void load();
+  }, [enabled, load, workspaceControlEvent]);
+  useEffect2(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "queue", load);
+  }, [enabled, load, registerSessionReconciler, sessionId]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isTurnQueueEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...options.events !== void 0 ? { events: options.events } : {}
+    },
+    async () => await load(true)
+  );
+  const mutate = useCallback2(
+    async (turnId, kind, command) => {
+      const ownedTargetKey = targetKey;
+      if (!sessionId || targetKeyRef.current !== ownedTargetKey || pendingRef.current[turnId]) {
+        return null;
+      }
+      const current = snapshotRef.current;
+      const turn = current?.items.find((candidate) => candidate.id === turnId);
+      if (!current || !turn) return null;
+      pendingRef.current = { ...pendingRef.current, [turnId]: kind };
+      setStateTargetKey(ownedTargetKey);
+      setPendingByTurn(pendingRef.current);
+      setMutationError(null);
+      try {
+        const result = await command(current, turn);
+        if (targetKeyRef.current !== ownedTargetKey) return null;
+        acceptSnapshot(ownedTargetKey, result.snapshot);
+        return result;
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey) {
+          setMutationError(asError(cause));
+          await load();
+        }
+        return null;
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && turnId in pendingRef.current) {
+          const next = { ...pendingRef.current };
+          delete next[turnId];
+          pendingRef.current = next;
+          setPendingByTurn(next);
+        }
+      }
+    },
+    [acceptSnapshot, load, sessionId, targetKey]
+  );
+  const moveTurn = useCallback2(
+    async (turnId, beforeTurnId) => {
+      const result = await mutate(
+        turnId,
+        "move",
+        (current) => client.moveQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId: operationKey(),
+          expectedQueueVersion: current.version,
+          beforeTurnId
+        })
+      );
+      return result !== null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const editTurn = useCallback2(
+    async (turnId, edit) => {
+      const result = await mutate(
+        turnId,
+        "edit",
+        (_current, turn) => client.editQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId: operationKey(),
+          expectedTurnVersion: turn.version,
+          expectedDraftRevision: edit.expectedDraftRevision,
+          replaceDraft: edit.replaceDraft
+        })
+      );
+      return result?.draft ?? null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const steerTurn = useCallback2(
+    async (turnId) => {
+      const result = await mutate(
+        turnId,
+        "steer",
+        (current, turn) => client.steerQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId: operationKey(),
+          expectedTurnVersion: turn.version,
+          controlEtag: current.effectiveControl.controlEtag
+        })
+      );
+      return result !== null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const removeTurn = useCallback2(
+    async (turnId) => {
+      const result = await mutate(
+        turnId,
+        "delete",
+        (_current, turn) => client.deleteQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId: operationKey(),
+          expectedTurnVersion: turn.version,
+          reason: "Deleted from the prompt queue"
+        })
+      );
+      return result !== null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const identityMatches = stateTargetKey === targetKey;
+  const visibleSnapshot = identityMatches ? snapshot : null;
+  const visiblePendingByTurn = identityMatches ? pendingByTurn : EMPTY_PENDING_BY_TURN;
+  const mutating = useMemo2(
+    () => Object.keys(visiblePendingByTurn).length > 0,
+    [visiblePendingByTurn]
+  );
+  const mutationFor = useCallback2(
+    (turnId) => visiblePendingByTurn[turnId] ?? null,
+    [visiblePendingByTurn]
+  );
+  return {
+    snapshot: visibleSnapshot,
+    queue: visibleSnapshot?.items ?? [],
+    effectiveControl: visibleSnapshot?.effectiveControl ?? null,
+    stoppingPreviousAttempt: visibleSnapshot?.stoppingPreviousAttempt ?? false,
+    loading: identityMatches ? loading : enabled,
+    error: identityMatches ? error : null,
+    refresh: load,
+    moveTurn,
+    editTurn,
+    steerTurn,
+    removeTurn,
+    pendingByTurn: visiblePendingByTurn,
+    mutationFor,
+    mutating,
+    mutationError: identityMatches ? mutationError : null,
+    clearMutationError: useCallback2(() => {
+      if (targetKeyRef.current === targetKey) setMutationError(null);
+    }, [targetKey])
+  };
+}
+function operationKey() {
+  return globalThis.crypto.randomUUID();
+}
+function asError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback3, useLayoutEffect as useLayoutEffect2, useRef as useRef3 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSession(options);
+  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pendingApproval = useRef3(null);
+  useLayoutEffect2(() => {
+    if (pendingApproval.current?.targetKey !== approvalTargetKey) {
+      pendingApproval.current = null;
+    }
+  }, [approvalTargetKey]);
+  const {
+    run: runControl,
+    mutating: controlling,
+    mutationError: controlError,
+    clearMutationError: clearControlError
+  } = useMutationRunner(approvalTargetKey);
+  const {
+    run: runApproval,
+    mutating: responding,
+    mutationError: approvalError,
+    clearMutationError: clearApprovalError
+  } = useMutationRunner(approvalTargetKey);
+  const pause = useCallback3(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await runControl(
+        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const resume = useCallback3(
+    async (reason) => {
+      if (!sessionId) return null;
+      return await runControl(
+        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const decide = useCallback3(
+    async (approvalId, decision, message) => {
+      if (!sessionId) {
+        return null;
+      }
+      const decisionKey = JSON.stringify([approvalId, decision, message ?? null]);
+      if (pendingApproval.current?.decisionKey !== decisionKey) {
+        pendingApproval.current = {
+          targetKey: approvalTargetKey,
+          decisionKey,
+          clientEventId: crypto.randomUUID()
+        };
+      }
+      const clientEventId = pendingApproval.current.clientEventId;
+      const accepted = await runApproval(
+        () => client.sendApprovalDecision(workspaceId, sessionId, {
+          approvalId,
+          decision,
+          ...message !== void 0 ? { message } : {},
+          clientEventId
+        })
+      );
+      if (accepted !== null && pendingApproval.current?.targetKey === approvalTargetKey && pendingApproval.current.clientEventId === clientEventId) {
+        pendingApproval.current = null;
+      }
+      return accepted;
+    },
+    [approvalTargetKey, client, workspaceId, sessionId, runApproval]
+  );
+  const approve = useCallback3(
+    async (approvalId, message) => await decide(approvalId, "approve", message),
+    [decide]
+  );
+  const reject = useCallback3(
+    async (approvalId, message) => await decide(approvalId, "reject", message),
+    [decide]
+  );
+  const error = approvalError ?? controlError;
+  const clearError = useCallback3(() => {
+    clearControlError();
+    clearApprovalError();
+  }, [clearControlError, clearApprovalError]);
+  return {
+    pause,
+    resume,
+    controlling,
+    approve,
+    reject,
+    responding,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/use-session-mcp-approval-policy.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect as useLayoutEffect3, useMemo as useMemo3, useRef as useRef4, useState as useState3 } from "react";
+function isSessionMcpApprovalPolicyEvent(event, serverId) {
+  if (event.type !== "session.mcp.approval_policy.updated") {
+    return false;
+  }
+  if (serverId === void 0) {
+    return true;
+  }
+  const payload = event.payload;
+  return payload?.serverId === serverId;
+}
+function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
+  const [override, setOverride] = useState3(null);
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${serverId ?? ""}`;
+  const authoritativeGeneration = useRef4(0);
+  const mutationIdentity = useMemo3(() => ({ client, targetKey }), [client, targetKey]);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
+  useLayoutEffect3(() => {
+    authoritativeGeneration.current += 1;
+    setOverride(null);
+  }, [client, targetKey]);
+  const load = useCallback4(async () => {
+    const generation = authoritativeGeneration.current;
+    if (!sessionId || !serverId) {
+      return { targetKey, generation, server: null };
+    }
+    const session = await client.getSession(workspaceId, sessionId);
+    return {
+      targetKey,
+      generation,
+      server: session.mcpServers.find((server2) => server2.id === serverId) ?? null
+    };
+  }, [client, serverId, sessionId, targetKey, workspaceId]);
+  const {
+    data,
+    loading,
+    error: loadError,
+    refresh
+  } = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs
+  });
+  useEffect3(() => {
+    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
+      setOverride(null);
+    }
+  }, [data, targetKey]);
+  const scheduleRefresh = useDebouncedCallback(() => void refresh());
+  const matchesPolicyEvent = useCallback4(
+    (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
+    [serverId]
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    matchesPolicyEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...options.events !== void 0 ? { events: options.events } : {}
+    },
+    async () => await refresh()
+  );
+  const update = useCallback4(
+    async (policy) => {
+      if (!sessionId || !serverId) {
+        return null;
+      }
+      const response = await run(
+        () => client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
+          requireApproval: policy
+        })
+      );
+      if (response) {
+        authoritativeGeneration.current += 1;
+        setOverride(response.server);
+        void refresh();
+      }
+      return response;
+    },
+    [client, refresh, run, serverId, sessionId, workspaceId]
+  );
+  const server = override ?? data?.server ?? null;
+  return {
+    server,
+    policy: server?.requireApproval ?? null,
+    loading,
+    error: mutationError ?? loadError,
+    refresh: async () => {
+      await refresh();
+    },
+    update,
+    updating: mutating,
+    clearError: clearMutationError
+  };
+}
+
+// src/approvals.ts
+function approvalsFromRequiresAction(payload) {
+  const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
+  if (!Array.isArray(approvals)) {
+    return [];
+  }
+  return approvals.map((approval, index) => {
+    const raw = approval && typeof approval === "object" ? approval : {};
+    const rawItem = raw.rawItem && typeof raw.rawItem === "object" ? raw.rawItem : {};
+    return {
+      // Mirror the runtime's canonical interruption identity before retaining
+      // the legacy top-level callId fallback for already-normalized payloads.
+      id: String(rawItem.callId ?? rawItem.id ?? raw.id ?? raw.callId ?? raw.name ?? index),
+      name: String(raw.name ?? raw.toolName ?? rawItem.name ?? "approval"),
+      arguments: raw.arguments ?? rawItem.arguments,
+      raw: approval
+    };
+  });
+}
+function projectPendingApprovals(events) {
+  let pending = [];
+  let owningTurnId = null;
+  for (const event of events) {
+    switch (event.type) {
+      case "session.requiresAction": {
+        pending = approvalsFromRequiresAction(event.payload);
+        owningTurnId = event.turnId ?? null;
+        break;
+      }
+      case "user.approvalDecision": {
+        const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
+        if (typeof payload.approvalId === "string") {
+          pending = pending.filter((approval) => approval.id !== payload.approvalId);
+        }
+        break;
+      }
+      case "turn.completed":
+      case "turn.failed":
+      case "turn.cancelled": {
+        if (owningTurnId === null || event.turnId == null || event.turnId === owningTurnId) {
+          pending = [];
+          owningTurnId = null;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return pending;
+}
+
+// src/human-input.ts
+function humanInputRequestFromEvent(event) {
+  if (event.type !== "session.humanInput.requested" || !isRecord(event.payload)) return null;
+  const request = event.payload.request;
+  if (!isRecord(request) || typeof request.id !== "string" || !Array.isArray(request.questions)) {
+    return null;
+  }
+  return {
+    id: request.id,
+    turnId: event.turnId ?? null,
+    questions: request.questions,
+    allowSkip: request.allowSkip === true,
+    expiresAt: typeof request.expiresAt === "string" ? request.expiresAt : null
+  };
+}
+function projectPendingHumanInputRequests(events) {
+  const pending = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const requested = humanInputRequestFromEvent(event);
+    if (requested) {
+      pending.set(requested.id, requested);
+      continue;
+    }
+    if (event.type === "user.humanInputResponse" && isRecord(event.payload)) {
+      if (typeof event.payload.requestId === "string") pending.delete(event.payload.requestId);
+      continue;
+    }
+    if (event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled") {
+      for (const [id, request] of pending) {
+        if (request.turnId === null || event.turnId === null || event.turnId === void 0 || request.turnId === event.turnId) {
+          pending.delete(id);
+        }
+      }
+    }
+  }
+  return [...pending.values()];
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/hooks/use-human-input.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState4 } from "react";
+function isHumanInputEvent(event) {
+  return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
+}
+function useHumanInputRequests(sessionId, options = {}) {
+  const { client, workspaceId, registerSessionReconciler } = useEmbeddedHumanInputSession(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const load = useCallback5(
+    async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
+    [client, sessionId, workspaceId]
+  );
+  const state = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs
+  });
+  const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
+  const [respondingRequestId, setRespondingRequestId] = useState4(null);
+  const respondingRequestRef = useRef5(null);
+  useEffect4(() => {
+    respondingRequestRef.current = null;
+    setRespondingRequestId(null);
+  }, [sessionId, workspaceId]);
+  useEffect4(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "human-input", state.refresh);
+  }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
+  const scheduleRefresh = useDebouncedCallback(() => void state.refresh());
+  useSessionEventTrigger(client, workspaceId, sessionId, isHumanInputEvent, scheduleRefresh, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
+  });
+  const respond = useCallback5(
+    async (requestId, response) => {
+      if (!sessionId || respondingRequestRef.current !== null) return null;
+      respondingRequestRef.current = requestId;
+      setRespondingRequestId(requestId);
+      try {
+        const event = await mutation.run(
+          () => client.submitHumanInputResponse(workspaceId, sessionId, requestId, response, {
+            clientEventId: globalThis.crypto.randomUUID()
+          })
+        );
+        if (event) await state.refresh();
+        return event;
+      } finally {
+        if (respondingRequestRef.current === requestId) {
+          respondingRequestRef.current = null;
+          setRespondingRequestId(null);
+        }
+      }
+    },
+    [client, mutation, sessionId, state, workspaceId]
+  );
+  return {
+    requests: [...state.data ?? []].sort(
+      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+    ),
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    respond,
+    respondingRequestId,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+export {
+  buildTimeline,
+  creditExhaustedFromEvents,
+  sessionStatusFromEvents,
+  groupTimeline,
+  extractSessionRef,
+  toolDisplayName,
+  SESSION_EVENT_BROWSER_MAX_BYTES,
+  SESSION_EVENT_BROWSER_MAX_COUNT,
+  SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
+  SESSION_EVENT_BROWSER_PENDING_MAX_BYTES,
+  SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
+  useSessionEvents,
+  boundBrowserSessionEventWindow,
+  isTurnQueueEvent,
+  useTurnQueue,
+  useSessionControl,
+  isSessionMcpApprovalPolicyEvent,
+  useSessionMcpApprovalPolicy,
+  approvalsFromRequiresAction,
+  projectPendingApprovals,
+  humanInputRequestFromEvent,
+  projectPendingHumanInputRequests,
+  isHumanInputEvent,
+  useHumanInputRequests
+};
+//# sourceMappingURL=chunk-UAHPKLB6.js.map