@opengeni/react 0.15.0 → 0.20.0

package/src/hooks/use-composer.ts

@@ -7,13 +7,13 @@ import type {
   SendMessageInput,
   SessionEvent,
 } from "@opengeni/sdk";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { useOpenGeni, type ClientOverride } from "../provider";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { useEmbeddedSession, type EmbeddedSessionClientOverride } from "../session-context";
 import { useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
 
 export type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId">;
 
-export type UseComposerOptions = ClientOverride &
+export type UseComposerOptions = EmbeddedSessionClientOverride &
   SessionEventFeedOptions & {
     /** Called with the accepted text after a successful send. */
     onSent?: ((text: string) => void) | undefined;
@@ -27,6 +27,18 @@ export type UseComposerOptions = ClientOverride &
     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"
+     */
+    draftPersistence?: "durable" | "disabled" | undefined;
   };
 
 export type ComposerState = {
@@ -49,6 +61,13 @@ 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.
+   */
+  draftPersistence?: "durable" | "disabled" | undefined;
   /** Apply an atomic queue Edit checkout without a second read. */
   applyDraft: (draft: ComposerDraft) => void;
   reloadDraft: () => Promise<void>;
@@ -69,19 +88,24 @@ export function useComposer(
   sessionId: string | null | undefined,
   options: UseComposerOptions = {},
 ): ComposerState {
-  const { client, workspaceId, registerSessionReconciler } = useOpenGeni(options);
+  const { client, workspaceId, registerSessionReconciler } = useEmbeddedSession(options);
+  const durableDrafts = options.draftPersistence !== "disabled";
+  const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${durableDrafts ? "durable" : "disabled"}`;
   const [value, setValue] = useState("");
+  const [stateTargetKey, setStateTargetKey] = useState(targetKey);
   const [sending, setSending] = useState(false);
   const [pausing, setPausing] = useState(false);
   const [resuming, setResuming] = useState(false);
   const [error, setError] = useState<Error | null>(null);
   const [draft, setDraft] = useState<ComposerDraft | null>(null);
-  const [draftLoading, setDraftLoading] = useState(Boolean(sessionId));
+  const [draftLoading, setDraftLoading] = useState(Boolean(sessionId) && durableDrafts);
   const [draftSaving, setDraftSaving] = useState(false);
   const [draftConflict, setDraftConflict] = useState<Error | null>(null);
   const [restoredResources, setRestoredResources] = useState<ResourceRef[]>([]);
   const pendingClientEventId = useRef<string | null>(null);
   const draftRef = useRef<ComposerDraft | null>(null);
+  const draftLoadErrorRef = useRef<Error | null>(null);
+  const draftReadGeneration = useRef(0);
   const localEditRevision = useRef(0);
   const targetGeneration = useRef(0);
   const lastSavedSignature = useRef<string | null>(null);
@@ -91,31 +115,57 @@ 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);
-  sendExtrasRef.current = options.sendExtras;
-  const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
+  useLayoutEffect(() => {
+    sendExtrasRef.current = options.sendExtras;
+  }, [options.sendExtras]);
+  const liveExtras = resolveSendExtras(options.sendExtras);
+  const liveExtrasVersion = JSON.stringify(liveExtras);
 
   // A composer is bound to one session: switching targets must not leak the
-  // previous session's draft, error, or retry idempotency key.
-  const targetKey = `${workspaceId}\u0000${sessionId ?? ""}`;
+  // 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.
   const targetKeyRef = useRef(targetKey);
-  useEffect(() => {
-    if (targetKeyRef.current !== targetKey) {
-      targetKeyRef.current = targetKey;
-      targetGeneration.current += 1;
-      pendingClientEventId.current = null;
-      localEditRevision.current = 0;
-      draftRef.current = null;
-      lastSavedSignature.current = null;
-      setValue("");
-      setError(null);
-      setDraft(null);
-      setDraftConflict(null);
-      setRestoredResources([]);
-    }
-  }, [targetKey]);
+  useLayoutEffect(() => {
+    if (targetKeyRef.current === targetKey) return;
+    targetKeyRef.current = targetKey;
+    targetGeneration.current += 1;
+    pendingClientEventId.current = null;
+    localEditRevision.current = 0;
+    draftReadGeneration.current += 1;
+    draftRef.current = null;
+    draftLoadErrorRef.current = null;
+    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.
+    saveChain.current = Promise.resolve();
+    setStateTargetKey(targetKey);
+    setValue("");
+    setSending(false);
+    setPausing(false);
+    setResuming(false);
+    setError(null);
+    setDraft(null);
+    setDraftLoading(Boolean(sessionId) && durableDrafts);
+    setDraftSaving(false);
+    setDraftConflict(null);
+    setRestoredResources([]);
+  }, [durableDrafts, sessionId, targetKey]);
 
   const applyDraft = useCallback(
     (next: ComposerDraft): void => {
+      if (targetKeyRef.current !== targetKey) return;
+      if (!durableDrafts) {
+        pendingClientEventId.current = null;
+        localEditRevision.current += 1;
+        draftRef.current = null;
+        lastSavedSignature.current = null;
+        setDraft(null);
+        setValue(next.text);
+        setRestoredResources(next.resources);
+        setDraftConflict(null);
+        return;
+      }
       draftRef.current = next;
       lastSavedSignature.current = draftSignature(draftPayload(next));
       localEditRevision.current += 1;
@@ -126,47 +176,84 @@ export function useComposer(
       setDraftConflict(null);
       onDraftApplied?.(next);
     },
-    [onDraftApplied],
+    [durableDrafts, onDraftApplied, targetKey],
   );
 
   const loadDraft = useCallback(
-    async (replaceLocal: boolean): Promise<void> => {
-      if (!sessionId) return;
+    async (replaceLocal: boolean, rejectOnFailure = false): Promise<void> => {
+      if (targetKeyRef.current !== targetKey) return;
+      if (!sessionId || !durableDrafts) {
+        setDraftLoading(false);
+        return;
+      }
       const generation = targetGeneration.current;
+      const readTicket = ++draftReadGeneration.current;
       const localAtStart = localEditRevision.current;
       setDraftLoading(true);
       try {
         const fetched = await client.getComposerDraft(workspaceId, sessionId);
-        if (generation !== targetGeneration.current) return;
-        draftRef.current = fetched;
-        setDraft(fetched);
-        setDraftConflict(null);
-        if (replaceLocal || localAtStart === localEditRevision.current) {
-          lastSavedSignature.current = draftSignature(draftPayload(fetched));
-          setValue(fetched.text);
-          setRestoredResources(fetched.resources);
-          onDraftApplied?.(fetched);
+        if (generation !== targetGeneration.current || targetKeyRef.current !== targetKey) {
+          return;
+        }
+        const ownsLatestRead = readTicket === draftReadGeneration.current;
+        const currentRevision = draftRef.current?.revision ?? -1;
+        if ((ownsLatestRead || rejectOnFailure) && fetched.revision >= currentRevision) {
+          draftRef.current = fetched;
+          setDraft(fetched);
+          setDraftConflict(null);
+          if (replaceLocal || localAtStart === localEditRevision.current) {
+            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) setError(asError(cause));
+        if (
+          generation === targetGeneration.current &&
+          targetKeyRef.current === targetKey &&
+          (readTicket === draftReadGeneration.current || rejectOnFailure)
+        ) {
+          const failure = asError(cause);
+          draftLoadErrorRef.current = failure;
+          setError(failure);
+        }
+        if (rejectOnFailure) throw cause;
       } finally {
-        if (generation === targetGeneration.current) setDraftLoading(false);
+        if (
+          generation === targetGeneration.current &&
+          targetKeyRef.current === targetKey &&
+          readTicket === draftReadGeneration.current
+        ) {
+          setDraftLoading(false);
+        }
       }
     },
-    [client, onDraftApplied, sessionId, workspaceId],
+    [client, durableDrafts, onDraftApplied, sessionId, targetKey, workspaceId],
   );
 
   useEffect(() => {
-    if (!sessionId) {
+    if (!sessionId || !durableDrafts) {
       setDraftLoading(false);
       return;
     }
     void loadDraft(false);
-  }, [loadDraft, sessionId]);
+  }, [durableDrafts, loadDraft, sessionId]);
   useEffect(() => {
-    if (!sessionId) return;
+    if (!sessionId || !durableDrafts) return;
     return registerSessionReconciler(sessionId, "composer", async () => await loadDraft(false));
-  }, [loadDraft, registerSessionReconciler, sessionId]);
+  }, [durableDrafts, loadDraft, registerSessionReconciler, sessionId]);
   useSessionEventTrigger(
     client,
     workspaceId,
@@ -174,12 +261,14 @@ export function useComposer(
     isComposerDraftEvent,
     () => void loadDraft(false),
     {
-      enabled: Boolean(sessionId),
+      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;
     const base = draftRef.current;
     if (!base) return null;
     const extras = resolveSendExtras(sendExtrasRef.current);
@@ -191,13 +280,21 @@ export function useComposer(
       model: extras.model ?? base.model,
       reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
     };
-  }, [restoredResources, value]);
+  }, [restoredResources, targetKey, value]);
 
   const persistPayload = useCallback(
     async (payload: SaveComposerDraftRequest): Promise<boolean> => {
-      if (!sessionId) return false;
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || targetKeyRef.current !== ownedTargetKey) return false;
       let success = false;
       const run = async () => {
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          return;
+        }
         const current = draftRef.current;
         if (!current) return;
         const request = { ...payload, expectedRevision: current.revision };
@@ -209,36 +306,61 @@ export function useComposer(
         setDraftSaving(true);
         try {
           const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
+          if (
+            targetKeyRef.current !== ownedTargetKey ||
+            targetGeneration.current !== ownedGeneration
+          ) {
+            return;
+          }
           draftRef.current = saved;
           setDraft(saved);
           lastSavedSignature.current = signature;
           setDraftConflict(null);
           success = true;
         } catch (cause) {
-          const problem = asError(cause);
-          setDraftConflict(problem);
-          setError(problem);
+          if (
+            targetKeyRef.current === ownedTargetKey &&
+            targetGeneration.current === ownedGeneration
+          ) {
+            const problem = asError(cause);
+            setDraftConflict(problem);
+            setError(problem);
+          }
         } finally {
-          setDraftSaving(false);
+          if (
+            targetKeyRef.current === ownedTargetKey &&
+            targetGeneration.current === ownedGeneration
+          ) {
+            setDraftSaving(false);
+          }
         }
       };
       saveChain.current = saveChain.current.then(run, run);
       await saveChain.current;
       return success;
     },
-    [client, sessionId, workspaceId],
+    [client, sessionId, targetKey, workspaceId],
   );
 
   // Private durable autosave. A newer local edit is never replaced by an older
   // response; saves serialize and each reads the latest acknowledged revision.
   useEffect(() => {
-    if (!sessionId || draftLoading || sending || !draftRef.current || draftConflict) return;
+    if (
+      !durableDrafts ||
+      !sessionId ||
+      draftLoading ||
+      sending ||
+      !draftRef.current ||
+      draftConflict
+    )
+      return;
     const payload = currentDraftPayload();
     if (!payload || draftSignature(payload) === lastSavedSignature.current) return;
     const timer = window.setTimeout(() => void persistPayload(payload), 500);
     return () => window.clearTimeout(timer);
   }, [
     currentDraftPayload,
+    durableDrafts,
     draftConflict,
     draftLoading,
     liveExtrasVersion,
@@ -249,13 +371,21 @@ export function useComposer(
 
   const dispatch = useCallback(
     async (delivery: "send" | "steer", explicit?: string): Promise<boolean> => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
       const draftAtSend = value;
-      const text = (explicit ?? draftAtSend).trim();
+      const rawText = explicit ?? draftAtSend;
+      const hasText = rawText.trim().length > 0;
       // Resolve the extras once: a file-only message (empty text + ≥1 ready
       // resource) is legitimate, so we must not bail on empty text alone.
       const extras = resolveSendExtras(sendExtrasRef.current);
       const hasResources = restoredResources.length > 0 || (extras.resources?.length ?? 0) > 0;
-      if ((!text && !hasResources) || !sessionId || sending) {
+      if (
+        (!hasText && !hasResources) ||
+        !sessionId ||
+        sending ||
+        targetKeyRef.current !== ownedTargetKey
+      ) {
         return false;
       }
       // Reuse the clientEventId across retries of the same draft so a
@@ -264,12 +394,21 @@ export function useComposer(
       setSending(true);
       setError(null);
       try {
-        const payload = currentDraftPayload();
+        // 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.
+        const sendText = hasText ? rawText : FILE_ONLY_MESSAGE_TEXT;
+        const currentPayload = currentDraftPayload();
+        const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
         if (payload && !(await persistPayload(payload))) return false;
-        // 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 sendText = text || FILE_ONLY_MESSAGE_TEXT;
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          return false;
+        }
         const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
           ...(options.effectiveControl?.controlEtag
             ? { controlEtag: options.effectiveControl.controlEtag }
@@ -282,6 +421,12 @@ export function useComposer(
         } else {
           await client.sendMessage(workspaceId, sessionId, input);
         }
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          return false;
+        }
         pendingClientEventId.current = null;
         const previousDraft = draftRef.current;
         if (previousDraft) {
@@ -307,10 +452,20 @@ export function useComposer(
         onSent?.(sendText);
         return true;
       } catch (cause) {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+        }
         return false;
       } finally {
-        setSending(false);
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setSending(false);
+        }
       }
     },
     [
@@ -322,6 +477,7 @@ export function useComposer(
       restoredResources,
       sending,
       sessionId,
+      targetKey,
       value,
       workspaceId,
     ],
@@ -335,13 +491,13 @@ 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 ||
-    (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
+  const hasReadyResources = restoredResources.length > 0 || (liveExtras.resources?.length ?? 0) > 0;
 
   const pause = useCallback(
     async (reason?: string): Promise<void> => {
-      if (!sessionId || pausing) {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || pausing || targetKeyRef.current !== ownedTargetKey) {
         return;
       }
       setPausing(true);
@@ -354,17 +510,29 @@ export function useComposer(
             : {}),
         });
       } catch (cause) {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+        }
       } finally {
-        setPausing(false);
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setPausing(false);
+        }
       }
     },
-    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag],
+    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag, targetKey],
   );
 
   const resume = useCallback(
     async (reason?: string): Promise<void> => {
-      if (!sessionId || resuming) return;
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || resuming || targetKeyRef.current !== ownedTargetKey) return;
       setResuming(true);
       setError(null);
       try {
@@ -375,21 +543,36 @@ export function useComposer(
             : {}),
         });
       } catch (cause) {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+        }
       } finally {
-        setResuming(false);
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setResuming(false);
+        }
       }
     },
-    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag],
+    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag, targetKey],
   );
 
   const resumeScope = useCallback(
     async (option: EffectiveControlResumeOption): Promise<void> => {
-      if (!sessionId || resuming) return;
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || resuming || targetKeyRef.current !== ownedTargetKey) return;
       setResuming(true);
       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",
           );
@@ -400,6 +583,12 @@ export function useComposer(
           });
         } else if (option.scope === "session" && option.targetId) {
           const target = await client.getQueue(workspaceId, option.targetId);
+          if (
+            targetKeyRef.current !== ownedTargetKey ||
+            targetGeneration.current !== ownedGeneration
+          ) {
+            return;
+          }
           await client.resumeSession(workspaceId, option.targetId, {
             expectedControlEtag: target.effectiveControl.controlEtag,
           });
@@ -411,29 +600,52 @@ export function useComposer(
           });
         }
       } catch (cause) {
-        setError(asError(cause));
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setError(asError(cause));
+        }
       } finally {
-        setResuming(false);
+        if (
+          targetKeyRef.current === ownedTargetKey &&
+          targetGeneration.current === ownedGeneration
+        ) {
+          setResuming(false);
+        }
       }
     },
-    [client, options.effectiveControl, resuming, sessionId, workspaceId],
+    [client, options.effectiveControl, resuming, sessionId, targetKey, workspaceId],
   );
 
-  const updateValue = useCallback((next: string) => {
-    pendingClientEventId.current = null;
-    localEditRevision.current += 1;
-    setValue(next);
-  }, []);
+  const updateValue = useCallback(
+    (next: string) => {
+      if (targetKeyRef.current !== targetKey) return;
+      pendingClientEventId.current = null;
+      localEditRevision.current += 1;
+      setValue(next);
+    },
+    [targetKey],
+  );
 
-  const removeRestoredResource = useCallback((index: number) => {
-    localEditRevision.current += 1;
-    setRestoredResources((current) => current.filter((_, candidate) => candidate !== index));
-  }, []);
+  const removeRestoredResource = useCallback(
+    (index: number) => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      setRestoredResources((current) => current.filter((_, candidate) => candidate !== index));
+    },
+    [targetKey],
+  );
 
   const resolveDraftConflict = useCallback(
     async (choice: "keep_mine" | "use_remote"): Promise<void> => {
-      if (!sessionId) return;
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== ownedTargetKey) return;
       const remote = await client.getComposerDraft(workspaceId, sessionId);
+      if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+        return;
+      }
       if (choice === "use_remote") {
         applyDraft(remote);
         return;
@@ -444,36 +656,55 @@ export function useComposer(
       const payload = currentDraftPayload();
       if (payload) await persistPayload({ ...payload, expectedRevision: remote.revision });
     },
-    [applyDraft, client, currentDraftPayload, persistPayload, sessionId, workspaceId],
+    [
+      applyDraft,
+      client,
+      currentDraftPayload,
+      durableDrafts,
+      persistPayload,
+      sessionId,
+      targetKey,
+      workspaceId,
+    ],
   );
 
+  const identityMatches = stateTargetKey === targetKey;
+  const reloadDraft = useCallback(async () => await loadDraft(true), [loadDraft]);
+  const clearError = useCallback(() => {
+    if (targetKeyRef.current !== targetKey) return;
+    setError(null);
+    setDraftConflict(null);
+  }, [targetKey]);
+
   return {
-    value,
+    value: identityMatches ? value : "",
     setValue: updateValue,
     send,
     steer,
-    sending,
-    canSend: Boolean(sessionId) && !sending && (value.trim().length > 0 || hasReadyResources),
+    sending: identityMatches ? sending : false,
+    canSend:
+      identityMatches &&
+      Boolean(sessionId) &&
+      !sending &&
+      (value.trim().length > 0 || hasReadyResources),
     pause,
-    pausing,
+    pausing: identityMatches ? pausing : false,
     resume,
     resumeScope,
-    resuming,
-    draft,
-    draftRevision: draft?.revision ?? 0,
-    draftLoading,
-    draftSaving,
-    draftConflict,
+    resuming: identityMatches ? resuming : false,
+    draft: identityMatches ? draft : null,
+    draftRevision: identityMatches ? (draft?.revision ?? 0) : 0,
+    draftLoading: identityMatches ? draftLoading : Boolean(sessionId) && durableDrafts,
+    draftSaving: identityMatches ? draftSaving : false,
+    draftConflict: identityMatches ? draftConflict : null,
+    draftPersistence: durableDrafts ? "durable" : "disabled",
     applyDraft,
-    reloadDraft: useCallback(async () => await loadDraft(true), [loadDraft]),
+    reloadDraft,
     resolveDraftConflict,
-    restoredResources,
+    restoredResources: identityMatches ? restoredResources : [],
     removeRestoredResource,
-    error,
-    clearError: useCallback(() => {
-      setError(null);
-      setDraftConflict(null);
-    }, []),
+    error: identityMatches ? error : null,
+    clearError,
   };
 }