@opengeni/react 0.15.0 → 0.23.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,11 +27,15 @@ 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;
+    /** 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. */
@@ -49,6 +53,8 @@ export type ComposerState = {
   draftLoading: boolean;
   draftSaving: boolean;
   draftConflict: Error | null;
+  /** 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;
   reloadDraft: () => Promise<void>;
@@ -69,21 +75,29 @@ 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("");
+  // 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);
   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 valueRef = useRef("");
   const draftRef = useRef<ComposerDraft | null>(null);
+  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;
@@ -96,27 +110,53 @@ export function useComposer(
 
   // 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 ?? ""}`;
   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;
+    draftReadGeneration.current += 1;
+    pendingClientEventId.current = null;
+    localEditRevision.current = 0;
+    valueRef.current = "";
+    draftRef.current = null;
+    restoredResourcesRef.current = [];
+    lastSavedSignature.current = null;
+    // 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("");
+    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;
+        valueRef.current = next.text;
+        restoredResourcesRef.current = next.resources;
+        draftRef.current = null;
+        lastSavedSignature.current = null;
+        setDraft(null);
+        setValue(next.text);
+        setRestoredResources(next.resources);
+        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;
@@ -126,47 +166,94 @@ export function useComposer(
       setDraftConflict(null);
       onDraftApplied?.(next);
     },
-    [onDraftApplied],
+    [durableDrafts, onDraftApplied, targetKey],
   );
 
   const loadDraft = useCallback(
     async (replaceLocal: boolean): Promise<void> => {
-      if (!sessionId) return;
+      if (targetKeyRef.current !== targetKey) return;
+      if (!sessionId || !durableDrafts) {
+        setDraftLoading(false);
+        return;
+      }
       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) 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 ||
+          readTicket !== draftReadGeneration.current
+        ) {
+          return;
+        }
+        const currentRevision = draftRef.current?.revision ?? -1;
+        if (fetched.revision >= currentRevision) {
+          draftRef.current = fetched;
+          setDraft(fetched);
+          setDraftConflict(null);
+          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);
+          }
         }
       } catch (cause) {
-        if (generation === targetGeneration.current) setError(asError(cause));
+        if (
+          generation === targetGeneration.current &&
+          targetKeyRef.current === targetKey &&
+          readTicket === draftReadGeneration.current
+        ) {
+          setError(asError(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,30 +261,34 @@ export function useComposer(
     isComposerDraftEvent,
     () => void loadDraft(false),
     {
-      enabled: Boolean(sessionId),
+      enabled: Boolean(sessionId) && durableDrafts,
       ...(options.events !== undefined ? { events: options.events } : {}),
     },
   );
 
   const currentDraftPayload = useCallback((): SaveComposerDraftRequest | 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, value]);
+    return composerDraftPayload(base, value, restoredResources, extras);
+  }, [durableDrafts, restoredResources, targetKey, value]);
 
   const persistPayload = useCallback(
     async (payload: SaveComposerDraftRequest): Promise<boolean> => {
-      if (!sessionId) return false;
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || !durableDrafts || 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 +300,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, durableDrafts, 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 +365,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,17 +388,36 @@ export function useComposer(
       setSending(true);
       setError(null);
       try {
-        const payload = currentDraftPayload();
+        // 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;
         if (payload && !(await persistPayload(payload))) return false;
+        if (
+          targetKeyRef.current !== ownedTargetKey ||
+          targetGeneration.current !== ownedGeneration
+        ) {
+          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;
-        const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
+        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") {
@@ -282,6 +425,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) {
@@ -295,6 +444,7 @@ export function useComposer(
             updatedAt: null,
           };
           draftRef.current = cleared;
+          restoredResourcesRef.current = [];
           setDraft(cleared);
           setRestoredResources([]);
           lastSavedSignature.current = draftSignature(draftPayload(cleared));
@@ -302,26 +452,41 @@ 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;
       } 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);
+        }
       }
     },
     [
       client,
       currentDraftPayload,
+      durableDrafts,
       onSent,
       options.effectiveControl?.controlEtag,
       persistPayload,
       restoredResources,
       sending,
       sessionId,
+      targetKey,
       value,
       workspaceId,
     ],
@@ -341,7 +506,9 @@ export function useComposer(
 
   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 +521,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,17 +554,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 {
-        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 {
@@ -393,6 +584,11 @@ export function useComposer(
           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(),
@@ -400,6 +596,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 +613,69 @@ 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;
+      valueRef.current = next;
+      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;
+      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> => {
-      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 +686,56 @@ 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,
+    hasDraftContent,
     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,
   };
 }
 
@@ -543,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);