@opengeni/react 0.20.0 → 0.25.0

package/src/hooks/use-session-mcp-approval-policy.ts

@@ -0,0 +1,161 @@
+import type {
+  SessionEvent,
+  SessionMcpApprovalPolicy,
+  SessionMcpServerMetadata,
+  UpdateSessionMcpApprovalPolicyResponse,
+} from "@opengeni/sdk";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import {
+  useEmbeddedSessionMcpApprovalPolicy,
+  type EmbeddedSessionMcpApprovalPolicyClientOverride,
+} from "../session-context";
+import {
+  useDebouncedCallback,
+  useMutationRunner,
+  usePolledValue,
+  useSessionEventTrigger,
+  type SessionEventFeedOptions,
+} from "./internal";
+
+export function isSessionMcpApprovalPolicyEvent(
+  event: Pick<SessionEvent, "type" | "payload">,
+  serverId?: string,
+): boolean {
+  if (event.type !== "session.mcp.approval_policy.updated") {
+    return false;
+  }
+  if (serverId === undefined) {
+    return true;
+  }
+  const payload = event.payload as { serverId?: unknown } | null;
+  return payload?.serverId === serverId;
+}
+
+export type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolicyClientOverride &
+  SessionEventFeedOptions & {
+    /** Optional safety-net polling (ms). Off by default; policy events drive refreshes. */
+    pollIntervalMs?: number | undefined;
+  };
+
+export type UseSessionMcpApprovalPolicyResult = {
+  server: SessionMcpServerMetadata | null;
+  policy: SessionMcpApprovalPolicy | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  update: (
+    policy: SessionMcpApprovalPolicy,
+  ) => Promise<UpdateSessionMcpApprovalPolicyResponse | null>;
+  updating: boolean;
+  clearError: () => void;
+};
+
+/**
+ * Read and update one existing session MCP server's approval policy. Updates
+ * become effective for the next claimed attempt; current work is unchanged.
+ */
+export function useSessionMcpApprovalPolicy(
+  sessionId: string | null | undefined,
+  serverId: string | null | undefined,
+  options: UseSessionMcpApprovalPolicyOptions = {},
+): UseSessionMcpApprovalPolicyResult {
+  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
+  const [override, setOverride] = useState<SessionMcpServerMetadata | null>(null);
+  const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${serverId ?? ""}`;
+  const authoritativeGeneration = useRef(0);
+  const mutationIdentity = useMemo(() => ({ client, targetKey }), [client, targetKey]);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
+
+  useLayoutEffect(() => {
+    authoritativeGeneration.current += 1;
+    setOverride(null);
+  }, [client, targetKey]);
+
+  type PolicyRead = {
+    targetKey: string;
+    generation: number;
+    server: SessionMcpServerMetadata | null;
+  };
+  const load = useCallback(async (): Promise<PolicyRead> => {
+    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((server) => server.id === serverId) ?? null,
+    };
+  }, [client, serverId, sessionId, targetKey, workspaceId]);
+  const {
+    data,
+    loading,
+    error: loadError,
+    refresh,
+  } = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs,
+  });
+  useEffect(() => {
+    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
+      setOverride(null);
+    }
+  }, [data, targetKey]);
+
+  const scheduleRefresh = useDebouncedCallback(() => void refresh());
+  const matchesPolicyEvent = useCallback(
+    (event: Pick<SessionEvent, "type" | "payload">) =>
+      isSessionMcpApprovalPolicyEvent(event, serverId ?? undefined),
+    [serverId],
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    matchesPolicyEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...(options.events !== undefined ? { events: options.events } : {}),
+    },
+    async () => await refresh(),
+  );
+
+  const update = useCallback(
+    async (
+      policy: SessionMcpApprovalPolicy,
+    ): Promise<UpdateSessionMcpApprovalPolicyResponse | null> => {
+      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,
+  };
+}

package/src/hooks/use-workspace-sessions.ts

@@ -1,5 +1,5 @@
 import type { Session } from "@opengeni/sdk";
-import { useCallback } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { usePolledValue } from "./internal";
 
@@ -8,6 +8,8 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   parentSessionId?: string | null | undefined;
   cursor?: string | undefined;
   search?: string | undefined;
+  /** Return only the complete personal pinned projection. */
+  pinsOnly?: boolean | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -38,7 +40,21 @@ export function useWorkspaceSessions(
   const parentSessionId = options.parentSessionId;
   const cursor = options.cursor;
   const search = options.search;
-  const queryKey = JSON.stringify({ workspaceId, limit, parentSessionId, cursor, search });
+  const pinsOnly = options.pinsOnly;
+  const enabled = options.enabled ?? true;
+  const queryKey = [
+    workspaceId,
+    limit ?? "",
+    parentSessionId === null ? "null" : (parentSessionId ?? ""),
+    cursor ?? "",
+    search ?? "",
+    pinsOnly ? "1" : "",
+  ].join("\u0000");
+  const previousQueryKey = useRef(queryKey);
+  const queryKeyTransition = previousQueryKey.current !== queryKey;
+  useEffect(() => {
+    previousQueryKey.current = queryKey;
+  }, [queryKey]);
   const load = useCallback(
     async () => ({
       queryKey,
@@ -47,13 +63,14 @@ export function useWorkspaceSessions(
         ...(parentSessionId !== undefined ? { parentSessionId } : {}),
         ...(cursor !== undefined ? { cursor } : {}),
         ...(search !== undefined ? { search } : {}),
+        ...(pinsOnly ? { pinsOnly: true } : {}),
       }),
     }),
-    [client, workspaceId, limit, parentSessionId, cursor, search, queryKey],
+    [client, workspaceId, limit, parentSessionId, cursor, search, pinsOnly, queryKey],
   );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
-    enabled: options.enabled,
+    enabled,
   });
   // usePolledValue drops stale async completions, while the explicit query key
   // also prevents the previous query's cached value from painting for the one
@@ -69,7 +86,15 @@ export function useWorkspaceSessions(
     pinned,
     pinnedTruncated: page?.pinnedTruncated ?? false,
     nextCursor: page?.nextCursor ?? null,
-    loading: state.loading,
+    // `usePolledValue` clears the old data and starts the new request in an
+    // effect. During that query-key transition render, its old loading flag
+    // can still be false; expose loading immediately so consumers do not
+    // announce a transient false zero-match result.
+    loading:
+      enabled &&
+      (state.loading ||
+        queryKeyTransition ||
+        (state.data !== null && state.data.queryKey !== queryKey)),
     error: state.error,
     refresh: state.refresh,
   };

package/src/index.ts

@@ -9,6 +9,7 @@
 
 export type {
   EmbeddedHumanInputSessionClientLike,
+  EmbeddedSessionMcpApprovalPolicyClientLike,
   EmbeddedSessionClientLike,
   SessionClientLike,
 } from "./client";
@@ -78,6 +79,14 @@ export type {
   UseSessionControlOptions,
   UseSessionControlResult,
 } from "./hooks/use-session-control";
+export {
+  isSessionMcpApprovalPolicyEvent,
+  useSessionMcpApprovalPolicy,
+} from "./hooks/use-session-mcp-approval-policy";
+export type {
+  UseSessionMcpApprovalPolicyOptions,
+  UseSessionMcpApprovalPolicyResult,
+} from "./hooks/use-session-mcp-approval-policy";
 export { useScheduledTasks } from "./hooks/use-scheduled-tasks";
 export type {
   UseScheduledTasksOptions,

package/src/session-context.ts

@@ -2,6 +2,7 @@ import type { StreamConnectionState, WorkspaceControlEvent } from "@opengeni/sdk
 import { createContext, useContext } from "react";
 import type {
   EmbeddedHumanInputSessionClientLike,
+  EmbeddedSessionMcpApprovalPolicyClientLike,
   EmbeddedSessionClientLike,
   SessionClientLike,
 } from "./client";
@@ -40,6 +41,11 @@ export type EmbeddedHumanInputClientOverride = {
   workspaceId?: string | undefined;
 };
 
+export type EmbeddedSessionMcpApprovalPolicyClientOverride = {
+  client?: EmbeddedSessionMcpApprovalPolicyClientLike | undefined;
+  workspaceId?: string | undefined;
+};
+
 export type EmbeddedSessionContextValue = Omit<OpenGeniContextValue, "client"> & {
   client: EmbeddedSessionClientLike;
 };
@@ -117,6 +123,25 @@ export function useEmbeddedHumanInputSession(override: EmbeddedHumanInputClientO
   };
 }
 
+/** Resolve the approval-policy refinement without widening session-only hosts. */
+export function useEmbeddedSessionMcpApprovalPolicy(
+  override: EmbeddedSessionMcpApprovalPolicyClientOverride = {},
+): Omit<EmbeddedSessionContextValue, "client"> & {
+  client: EmbeddedSessionMcpApprovalPolicyClientLike;
+} {
+  const embedded = useEmbeddedSession(override);
+  const client = embedded.client as Partial<EmbeddedSessionMcpApprovalPolicyClientLike>;
+  if (typeof client.updateSessionMcpApprovalPolicy !== "function") {
+    throw new Error(
+      "@opengeni/react: useSessionMcpApprovalPolicy requires updateSessionMcpApprovalPolicy.",
+    );
+  }
+  return {
+    ...embedded,
+    client: client as EmbeddedSessionMcpApprovalPolicyClientLike,
+  };
+}
+
 /**
  * Resolve the client only — for hooks that are not workspace-scoped
  * (`useWorkspaces`, `useBillingUsage`).

package/src/session.ts

@@ -6,10 +6,12 @@
 
 export type {
   EmbeddedHumanInputSessionClientLike as HumanInputSessionClientLike,
+  EmbeddedSessionMcpApprovalPolicyClientLike as SessionMcpApprovalPolicyClientLike,
   EmbeddedSessionClientLike as SessionClientLike,
 } from "./client";
 export type {
   EmbeddedHumanInputClientOverride as HumanInputClientOverride,
+  EmbeddedSessionMcpApprovalPolicyClientOverride as SessionMcpApprovalPolicyClientOverride,
   EmbeddedSessionClientOverride as ClientOverride,
 } from "./session-context";
 
@@ -38,6 +40,14 @@ export type {
   UseSessionControlOptions,
   UseSessionControlResult,
 } from "./hooks/use-session-control";
+export {
+  isSessionMcpApprovalPolicyEvent,
+  useSessionMcpApprovalPolicy,
+} from "./hooks/use-session-mcp-approval-policy";
+export type {
+  UseSessionMcpApprovalPolicyOptions,
+  UseSessionMcpApprovalPolicyResult,
+} from "./hooks/use-session-mcp-approval-policy";
 
 export { approvalsFromRequiresAction, projectPendingApprovals } from "./approvals";
 export type { PendingApproval } from "./approvals";

package/src/timeline/activity-rail.tsx

@@ -5,15 +5,19 @@ import {
   BrainIcon,
   SquareTerminalIcon,
 } from "lucide-react";
+import { lazy, Suspense } from "react";
+import { jsx as rowJsx, jsxs as rowJsxs } from "react/jsx-runtime";
 import { cn } from "../lib/cn";
 import { truncate } from "../lib/format";
 import { defaultToolRegistry } from "./tool-renderers";
 import { useEntranceAnimation } from "./entrance";
 import type { ToolRegistry } from "./registry";
 import { BodyNote, PayloadBlock, ActivityDisclosure } from "./shared";
-import { toolDisplayName } from "./projection";
+import { toolDisplayName } from "./tool-display-name";
 import type { ActivityItem, MemoryItem, ReasoningItem, SandboxItem, WorkerItem } from "./types";
 
+const LazyFleetDecisionRow = lazy(() => import("./fleet-decision-row"));
+
 /* ----------------------------------------------------------------------------
    Activity rail
 
@@ -112,6 +116,18 @@ function renderActivity(
       return <SandboxRow item={item} />;
     case "memory":
       return <MemoryRow item={item} onMemoryClick={onMemoryClick} />;
+    case "fleet-decision":
+      return (
+        <Suspense fallback={null}>
+          <LazyFleetDecisionRow
+            item={item}
+            d={ActivityDisclosure}
+            b={BodyNote}
+            j={rowJsx}
+            s={rowJsxs}
+          />
+        </Suspense>
+      );
     default:
       return assertNever(item);
   }