@opengeni/react 0.20.0 → 0.23.0

package/src/hooks/use-composer.ts

@@ -27,23 +27,15 @@ export type UseComposerOptions = EmbeddedSessionClientOverride &
     effectiveControl?: EffectiveSessionControl | null | undefined;
     /** Apply durable model/tool/reasoning settings in the host's controlled UI. */
     onDraftApplied?: ((draft: ComposerDraft) => void) | undefined;
-    /**
-     * Opt out of OpenGeni's remote composer-draft reads and writes. Embedded
-     * hosts can use this when their human lane permits messages and controls but
-     * deliberately withholds draft mutation because model/tool policy is
-     * server-owned. The unsent value remains local React state and send/steer
-     * continue to work without a draft revision fence. Queue checkout is hidden
-     * because the current queue-edit contract necessarily creates a durable
-     * composer draft.
-     *
-     * @default "durable"
-     */
+    /** Disable remote composer-draft reads and writes for embedded hosts. */
     draftPersistence?: "durable" | "disabled" | undefined;
   };
 
 export type ComposerState = {
   value: string;
   setValue: (value: string) => void;
+  /** Read the current draft synchronously before a destructive replacement. */
+  hasDraftContent: () => boolean;
   /** Append the draft behind prompts already visible in the queue. */
   send: (text?: string) => Promise<boolean>;
   /** Supersede current direction with the draft. */
@@ -61,12 +53,7 @@ export type ComposerState = {
   draftLoading: boolean;
   draftSaving: boolean;
   draftConflict: Error | null;
-  /**
-   * Whether this controller owns a durable server-side draft. Custom
-   * controllers that omit the field retain the historical durable behavior.
-   * Queue checkout is unavailable when persistence is disabled because the
-   * current queue-edit contract atomically moves the turn into that draft.
-   */
+  /** Whether this controller owns a durable server-side draft. */
   draftPersistence?: "durable" | "disabled" | undefined;
   /** Apply an atomic queue Edit checkout without a second read. */
   applyDraft: (draft: ComposerDraft) => void;
@@ -92,6 +79,8 @@ export function useComposer(
   const durableDrafts = options.draftPersistence !== "disabled";
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${durableDrafts ? "durable" : "disabled"}`;
   const [value, setValue] = useState("");
+  // Keep rendered state behind the committed target identity for one frame:
+  // a parent may switch sessionId without remounting this public hook.
   const [stateTargetKey, setStateTargetKey] = useState(targetKey);
   const [sending, setSending] = useState(false);
   const [pausing, setPausing] = useState(false);
@@ -103,11 +92,12 @@ export function useComposer(
   const [draftConflict, setDraftConflict] = useState<Error | null>(null);
   const [restoredResources, setRestoredResources] = useState<ResourceRef[]>([]);
   const pendingClientEventId = useRef<string | null>(null);
+  const valueRef = useRef("");
   const draftRef = useRef<ComposerDraft | null>(null);
-  const draftLoadErrorRef = useRef<Error | null>(null);
-  const draftReadGeneration = useRef(0);
+  const restoredResourcesRef = useRef<ResourceRef[]>([]);
   const localEditRevision = useRef(0);
   const targetGeneration = useRef(0);
+  const draftReadGeneration = useRef(0);
   const lastSavedSignature = useRef<string | null>(null);
   const saveChain = useRef<Promise<void>>(Promise.resolve());
   const onSent = options.onSent;
@@ -115,29 +105,25 @@ export function useComposer(
   // Read through a ref so a new extras closure (created every render by
   // callers passing inline functions) does not invalidate `send`.
   const sendExtrasRef = useRef(options.sendExtras);
-  useLayoutEffect(() => {
-    sendExtrasRef.current = options.sendExtras;
-  }, [options.sendExtras]);
-  const liveExtras = resolveSendExtras(options.sendExtras);
-  const liveExtrasVersion = JSON.stringify(liveExtras);
+  sendExtrasRef.current = options.sendExtras;
+  const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
 
   // A composer is bound to one session: switching targets must not leak the
-  // previous session's draft, error, or retry idempotency key. Revoke the old
-  // target only when the new render commits: a suspended transition must leave
-  // the still-visible composer fully interactive.
+  // previous session's draft, error, or retry idempotency key.
   const targetKeyRef = useRef(targetKey);
   useLayoutEffect(() => {
     if (targetKeyRef.current === targetKey) return;
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
+    draftReadGeneration.current += 1;
     pendingClientEventId.current = null;
     localEditRevision.current = 0;
-    draftReadGeneration.current += 1;
+    valueRef.current = "";
     draftRef.current = null;
-    draftLoadErrorRef.current = null;
+    restoredResourcesRef.current = [];
     lastSavedSignature.current = null;
-    // An unresolved save for the old target must neither block nor join the
-    // new target's autosave chain. Its own generation fence drops settlement.
+    // Old saves may still be awaiting the network. Their generation fence
+    // prevents settlement, and a fresh chain avoids blocking this target.
     saveChain.current = Promise.resolve();
     setStateTargetKey(targetKey);
     setValue("");
@@ -158,6 +144,8 @@ export function useComposer(
       if (!durableDrafts) {
         pendingClientEventId.current = null;
         localEditRevision.current += 1;
+        valueRef.current = next.text;
+        restoredResourcesRef.current = next.resources;
         draftRef.current = null;
         lastSavedSignature.current = null;
         setDraft(null);
@@ -166,7 +154,9 @@ export function useComposer(
         setDraftConflict(null);
         return;
       }
+      valueRef.current = next.text;
       draftRef.current = next;
+      restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
       localEditRevision.current += 1;
       pendingClientEventId.current = null;
@@ -180,7 +170,7 @@ export function useComposer(
   );
 
   const loadDraft = useCallback(
-    async (replaceLocal: boolean, rejectOnFailure = false): Promise<void> => {
+    async (replaceLocal: boolean): Promise<void> => {
       if (targetKeyRef.current !== targetKey) return;
       if (!sessionId || !durableDrafts) {
         setDraftLoading(false);
@@ -189,47 +179,57 @@ export function useComposer(
       const generation = targetGeneration.current;
       const readTicket = ++draftReadGeneration.current;
       const localAtStart = localEditRevision.current;
+      const baseAtStart = draftRef.current;
+      const extrasAtStart = resolveSendExtras(sendExtrasRef.current);
+      const localSignatureAtStart = baseAtStart
+        ? draftSignature(
+            composerDraftPayload(
+              baseAtStart,
+              valueRef.current,
+              restoredResourcesRef.current,
+              extrasAtStart,
+            ),
+          )
+        : null;
+      const localWasDirtyAtStart =
+        localSignatureAtStart === null
+          ? localAtStart !== 0
+          : localSignatureAtStart !== lastSavedSignature.current;
       setDraftLoading(true);
       try {
         const fetched = await client.getComposerDraft(workspaceId, sessionId);
-        if (generation !== targetGeneration.current || targetKeyRef.current !== targetKey) {
+        if (
+          generation !== targetGeneration.current ||
+          targetKeyRef.current !== targetKey ||
+          readTicket !== draftReadGeneration.current
+        ) {
           return;
         }
-        const ownsLatestRead = readTicket === draftReadGeneration.current;
         const currentRevision = draftRef.current?.revision ?? -1;
-        if ((ownsLatestRead || rejectOnFailure) && fetched.revision >= currentRevision) {
+        if (fetched.revision >= currentRevision) {
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
-          if (replaceLocal || localAtStart === localEditRevision.current) {
+          if (
+            replaceLocal ||
+            (!localWasDirtyAtStart && localAtStart === localEditRevision.current)
+          ) {
+            valueRef.current = fetched.text;
+            restoredResourcesRef.current = fetched.resources;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
             onDraftApplied?.(fetched);
           }
         }
-        const authoritativeRevision = draftRef.current?.revision ?? -1;
-        if (rejectOnFailure && authoritativeRevision < fetched.revision) {
-          throw new TypeError("Composer draft reconciliation did not commit authoritative state");
-        }
-        if (ownsLatestRead || rejectOnFailure) {
-          const recoveredError = draftLoadErrorRef.current;
-          draftLoadErrorRef.current = null;
-          if (recoveredError) {
-            setError((current) => (current === recoveredError ? null : current));
-          }
-        }
       } catch (cause) {
         if (
           generation === targetGeneration.current &&
           targetKeyRef.current === targetKey &&
-          (readTicket === draftReadGeneration.current || rejectOnFailure)
+          readTicket === draftReadGeneration.current
         ) {
-          const failure = asError(cause);
-          draftLoadErrorRef.current = failure;
-          setError(failure);
+          setError(asError(cause));
         }
-        if (rejectOnFailure) throw cause;
       } finally {
         if (
           generation === targetGeneration.current &&
@@ -264,29 +264,23 @@ export function useComposer(
       enabled: Boolean(sessionId) && durableDrafts,
       ...(options.events !== undefined ? { events: options.events } : {}),
     },
-    async () => await loadDraft(false, true),
   );
 
   const currentDraftPayload = useCallback((): SaveComposerDraftRequest | null => {
-    if (targetKeyRef.current !== targetKey) return null;
+    if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
     const base = draftRef.current;
     if (!base) return null;
     const extras = resolveSendExtras(sendExtrasRef.current);
-    return {
-      expectedRevision: base.revision,
-      text: value,
-      resources: mergeResources(restoredResources, extras.resources ?? []),
-      tools: extras.tools ?? base.tools,
-      model: extras.model ?? base.model,
-      reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
-    };
-  }, [restoredResources, targetKey, value]);
+    return composerDraftPayload(base, value, restoredResources, extras);
+  }, [durableDrafts, restoredResources, targetKey, value]);
 
   const persistPayload = useCallback(
     async (payload: SaveComposerDraftRequest): Promise<boolean> => {
       const ownedTargetKey = targetKey;
       const ownedGeneration = targetGeneration.current;
-      if (!sessionId || targetKeyRef.current !== ownedTargetKey) return false;
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== ownedTargetKey) {
+        return false;
+      }
       let success = false;
       const run = async () => {
         if (
@@ -339,7 +333,7 @@ export function useComposer(
       await saveChain.current;
       return success;
     },
-    [client, sessionId, targetKey, workspaceId],
+    [client, durableDrafts, sessionId, targetKey, workspaceId],
   );
 
   // Private durable autosave. A newer local edit is never replaced by an older
@@ -394,11 +388,10 @@ export function useComposer(
       setSending(true);
       setError(null);
       try {
-        // Trimming is only an emptiness check. A non-blank prompt must be sent
-        // byte-for-byte as the user wrote it, because expectedDraftRevision
-        // binds the submission to that exact durable draft. File-only messages
-        // use the same non-blank placeholder in both the saved draft and the
-        // submitted prompt so the content fence cannot reject its own client.
+        // Trimming is only an emptiness check. A non-blank prompt is persisted
+        // and submitted byte-for-byte, while file-only sends use the same
+        // placeholder for both operations so the server content fence cannot
+        // reject its own client.
         const sendText = hasText ? rawText : FILE_ONLY_MESSAGE_TEXT;
         const currentPayload = currentDraftPayload();
         const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
@@ -409,11 +402,22 @@ export function useComposer(
         ) {
           return false;
         }
-        const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
+        // The wire contract requires non-empty text (z.string().min(1)) and the
+        // worker rejects whitespace-only text; a file-only message therefore
+        // carries a minimal default so the attachments still get delivered.
+        const acknowledgedDraft = draftRef.current;
+        const sendExtras =
+          acknowledgedDraft?.toolsProvided === true &&
+          !Object.prototype.hasOwnProperty.call(extras, "tools")
+            ? { ...extras, tools: acknowledgedDraft.tools }
+            : extras;
+        const input = composeSendInput(sendText, pendingClientEventId.current, sendExtras, {
           ...(options.effectiveControl?.controlEtag
             ? { controlEtag: options.effectiveControl.controlEtag }
             : {}),
-          ...(draftRef.current ? { expectedDraftRevision: draftRef.current.revision } : {}),
+          ...(durableDrafts && draftRef.current
+            ? { expectedDraftRevision: draftRef.current.revision }
+            : {}),
           resources: mergeResources(restoredResources, extras.resources ?? []),
         });
         if (delivery === "steer") {
@@ -440,6 +444,7 @@ export function useComposer(
             updatedAt: null,
           };
           draftRef.current = cleared;
+          restoredResourcesRef.current = [];
           setDraft(cleared);
           setRestoredResources([]);
           lastSavedSignature.current = draftSignature(draftPayload(cleared));
@@ -447,7 +452,10 @@ export function useComposer(
         if (explicit === undefined) {
           // Clear only the draft that was sent: edits made while the request
           // was in flight were never delivered and must survive.
-          setValue((current) => (current === draftAtSend ? "" : current));
+          if (valueRef.current === draftAtSend) {
+            valueRef.current = "";
+            setValue("");
+          }
         }
         onSent?.(sendText);
         return true;
@@ -471,6 +479,7 @@ export function useComposer(
     [
       client,
       currentDraftPayload,
+      durableDrafts,
       onSent,
       options.effectiveControl?.controlEtag,
       persistPayload,
@@ -491,7 +500,9 @@ export function useComposer(
   // — keeping useComposer attachment-agnostic while still lighting up the send
   // affordance the moment a file is ready. ChatComposer additionally gates this
   // on its `attachments.uploading` flag so a message never departs mid-upload.
-  const hasReadyResources = restoredResources.length > 0 || (liveExtras.resources?.length ?? 0) > 0;
+  const hasReadyResources =
+    restoredResources.length > 0 ||
+    (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
 
   const pause = useCallback(
     async (reason?: string): Promise<void> => {
@@ -570,12 +581,14 @@ export function useComposer(
       setError(null);
       try {
         if (option.scope === "workspace") {
-          if (!client.setWorkspaceInferenceState) {
-            throw new Error("Workspace-level resume is not available through this client");
-          }
           const workspaceBlocker = options.effectiveControl?.blockers.find(
             (blocker) => blocker.kind === "workspace",
           );
+          if (!client.setWorkspaceInferenceState) {
+            throw new Error(
+              "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState.",
+            );
+          }
           await client.setWorkspaceInferenceState(workspaceId, {
             action: "resume",
             clientEventId: generateClientEventId(),
@@ -623,6 +636,7 @@ export function useComposer(
       if (targetKeyRef.current !== targetKey) return;
       pendingClientEventId.current = null;
       localEditRevision.current += 1;
+      valueRef.current = next;
       setValue(next);
     },
     [targetKey],
@@ -632,11 +646,27 @@ export function useComposer(
     (index: number) => {
       if (targetKeyRef.current !== targetKey) return;
       localEditRevision.current += 1;
-      setRestoredResources((current) => current.filter((_, candidate) => candidate !== index));
+      const next = restoredResourcesRef.current.filter((_, candidate) => candidate !== index);
+      restoredResourcesRef.current = next;
+      setRestoredResources(next);
     },
     [targetKey],
   );
 
+  const hasDraftContent = useCallback((): boolean => {
+    const current = draftRef.current;
+    const extras = resolveSendExtras(sendExtrasRef.current);
+    const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+    const tools = toolsProvidedByHost ? (extras.tools ?? []) : (current?.tools ?? []);
+    return (
+      valueRef.current.length > 0 ||
+      restoredResourcesRef.current.length > 0 ||
+      (extras.resources?.length ?? 0) > 0 ||
+      tools.length > 0 ||
+      (current?.sourceTurnId !== null && current?.sourceTurnId !== undefined)
+    );
+  }, []);
+
   const resolveDraftConflict = useCallback(
     async (choice: "keep_mine" | "use_remote"): Promise<void> => {
       const ownedTargetKey = targetKey;
@@ -679,6 +709,7 @@ export function useComposer(
   return {
     value: identityMatches ? value : "",
     setValue: updateValue,
+    hasDraftContent,
     send,
     steer,
     sending: identityMatches ? sending : false,
@@ -774,11 +805,30 @@ function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
     text: draft.text,
     resources: draft.resources,
     tools: draft.tools,
+    toolsProvided: draft.toolsProvided,
     model: draft.model,
     reasoningEffort: draft.reasoningEffort,
   };
 }
 
+function composerDraftPayload(
+  base: ComposerDraft,
+  text: string,
+  restoredResources: ResourceRef[],
+  extras: ComposerSendExtras,
+): SaveComposerDraftRequest {
+  const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+  return {
+    expectedRevision: base.revision,
+    text,
+    resources: mergeResources(restoredResources, extras.resources ?? []),
+    tools: toolsProvidedByHost ? (extras.tools ?? []) : base.tools,
+    toolsProvided: toolsProvidedByHost ? true : base.toolsProvided,
+    model: extras.model ?? base.model,
+    reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
+  };
+}
+
 function draftSignature(payload: SaveComposerDraftRequest): string {
   const { expectedRevision: _revision, ...content } = payload;
   return JSON.stringify(content);

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/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";