@opengeni/react 0.20.0 → 0.25.0

package/dist/{chunk-6UT5OC3P.js → chunk-SHOFILHJ.js}

@@ -6,12 +6,19 @@ import {
   useDebouncedCallback,
   useEmbeddedHumanInputSession,
   useEmbeddedSession,
+  useEmbeddedSessionMcpApprovalPolicy,
   useMutationRunner,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-HHFA4AFX.js";
+} from "./chunk-I3BJZIG5.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) {
@@ -379,6 +386,14 @@ ${message}` : message;
         }
         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":
@@ -439,6 +454,7 @@ function isActivityItem(item) {
     case "worker":
     case "sandbox":
     case "memory":
+    case "fleet-decision":
       return true;
     default:
       return false;
@@ -565,7 +581,7 @@ 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";
+  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 {
@@ -916,11 +932,6 @@ function extractSessionRef(value, depth = 0) {
 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";
@@ -1945,6 +1956,107 @@ function useSessionControl(sessionId, options = {}) {
   };
 }
 
+// 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;
@@ -2039,14 +2151,14 @@ function isRecord(value) {
 }
 
 // src/hooks/use-human-input.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef4, useState as useState3 } from "react";
+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 = useCallback4(
+  const load = useCallback5(
     async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
     [client, sessionId, workspaceId]
   );
@@ -2055,13 +2167,13 @@ function useHumanInputRequests(sessionId, options = {}) {
     pollIntervalMs: options.pollIntervalMs
   });
   const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
-  const [respondingRequestId, setRespondingRequestId] = useState3(null);
-  const respondingRequestRef = useRef4(null);
-  useEffect3(() => {
+  const [respondingRequestId, setRespondingRequestId] = useState4(null);
+  const respondingRequestRef = useRef5(null);
+  useEffect4(() => {
     respondingRequestRef.current = null;
     setRespondingRequestId(null);
   }, [sessionId, workspaceId]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "human-input", state.refresh);
   }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
@@ -2070,7 +2182,7 @@ function useHumanInputRequests(sessionId, options = {}) {
     enabled,
     ...options.events !== void 0 ? { events: options.events } : {}
   });
-  const respond = useCallback4(
+  const respond = useCallback5(
     async (requestId, response) => {
       if (!sessionId || respondingRequestRef.current !== null) return null;
       respondingRequestRef.current = requestId;
@@ -2107,12 +2219,12 @@ function useHumanInputRequests(sessionId, options = {}) {
 }
 
 export {
+  toolDisplayName,
   buildTimeline,
   creditExhaustedFromEvents,
   sessionStatusFromEvents,
   groupTimeline,
   extractSessionRef,
-  toolDisplayName,
   SESSION_EVENT_BROWSER_MAX_BYTES,
   SESSION_EVENT_BROWSER_MAX_COUNT,
   SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
@@ -2123,6 +2235,8 @@ export {
   isTurnQueueEvent,
   useTurnQueue,
   useSessionControl,
+  isSessionMcpApprovalPolicyEvent,
+  useSessionMcpApprovalPolicy,
   approvalsFromRequiresAction,
   projectPendingApprovals,
   humanInputRequestFromEvent,
@@ -2130,4 +2244,4 @@ export {
   isHumanInputEvent,
   useHumanInputRequests
 };
-//# sourceMappingURL=chunk-6UT5OC3P.js.map
+//# sourceMappingURL=chunk-SHOFILHJ.js.map