@opengeni/react 0.23.0 → 0.25.5

package/src/hooks/use-composer.ts

@@ -2,6 +2,7 @@ import type {
   ComposerDraft,
   EffectiveControlResumeOption,
   EffectiveSessionControl,
+  OpenGeniApiError,
   ResourceRef,
   SaveComposerDraftRequest,
   SendMessageInput,
@@ -15,14 +16,20 @@ export type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId"
 
 export type UseComposerOptions = EmbeddedSessionClientOverride &
   SessionEventFeedOptions & {
-    /** Called with the accepted text after a successful send. */
-    onSent?: ((text: string) => void) | undefined;
+    /** Called with the exact accepted wire input after a successful send. */
+    onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
     /**
      * Extra message fields (resources, tools, model, reasoningEffort) merged
      * into every send. A function is evaluated at send time so it can read the
      * surrounding UI state (attachment pickers, model selectors, ...).
      */
     sendExtras?: ComposerSendExtras | (() => ComposerSendExtras) | undefined;
+    /**
+     * Fail-closed delivery guard evaluated at send time. Attachment hosts use
+     * this to preserve unresolved upload cards until the operator waits,
+     * retries, or removes them; direct hook callers cannot bypass the UI gate.
+     */
+    sendBlocked?: (() => boolean) | undefined;
     /** Latest server-derived workstream control; bound into Send/Steer OCC. */
     effectiveControl?: EffectiveSessionControl | null | undefined;
     /** Apply durable model/tool/reasoning settings in the host's controlled UI. */
@@ -31,6 +38,184 @@ export type UseComposerOptions = EmbeddedSessionClientOverride &
     draftPersistence?: "durable" | "disabled" | undefined;
   };
 
+type ComposerDraftShadow = {
+  text: string;
+  resources: ResourceRef[];
+};
+
+type PendingComposerOperation = {
+  delivery: "send" | "steer";
+  input: SendMessageInput;
+  draftAtSend: string;
+  resourcesAtSend: ResourceRef[];
+  /** Latest local text/resources that must survive an uncertain delivery. */
+  newerShadow: ComposerDraftShadow;
+  clearDraftOnAccept: boolean;
+  /** False after remount when the original input carried secret credentials. */
+  canRetry: boolean;
+};
+
+type StoredPendingComposerOperation = Omit<PendingComposerOperation, "input" | "canRetry"> & {
+  input: Omit<SendMessageInput, "mcpCredentialUpdates">;
+  hasMcpCredentialUpdates: boolean;
+};
+
+const PENDING_COMPOSER_STORAGE_PREFIX = "opengeni.pending-composer.v1:";
+
+// A remount must not manufacture a new operation while the previous mutation
+// is still outcome-unknown. Keep only non-credential request fields here; the
+// mounted hook retains the exact input, including any credential updates. The
+// safe shadow is also session-scoped so a refresh cannot lose newer edits.
+const pendingComposerOperations = new Map<string, StoredPendingComposerOperation>();
+
+function pendingComposerOperationKey(
+  workspaceId: string,
+  sessionId: string | null | undefined,
+): string | null {
+  return sessionId ? `${workspaceId}\u0000${sessionId}` : null;
+}
+
+function pendingComposerStorage(): Storage | null {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
+function pendingComposerStorageKey(key: string): string {
+  return `${PENDING_COMPOSER_STORAGE_PREFIX}${encodeURIComponent(key)}`;
+}
+
+function resourceList(value: unknown): value is ResourceRef[] {
+  return (
+    Array.isArray(value) &&
+    value.every((candidate) => {
+      if (typeof candidate !== "object" || candidate === null) return false;
+      const resource = candidate as Record<string, unknown>;
+      return resource.kind === "file"
+        ? typeof resource.fileId === "string"
+        : resource.kind === "repository" &&
+            typeof resource.uri === "string" &&
+            typeof resource.ref === "string";
+    })
+  );
+}
+
+function readStoredPendingComposerOperation(
+  key: string | null,
+): StoredPendingComposerOperation | null {
+  const storage = key ? pendingComposerStorage() : null;
+  if (!storage || !key) return null;
+  try {
+    const parsed: unknown = JSON.parse(storage.getItem(pendingComposerStorageKey(key)) ?? "null");
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed as Record<string, unknown>;
+    const input = record.input;
+    const shadow = record.newerShadow;
+    if (
+      typeof input !== "object" ||
+      input === null ||
+      typeof shadow !== "object" ||
+      shadow === null
+    ) {
+      return null;
+    }
+    const inputRecord = input as Record<string, unknown>;
+    const shadowRecord = shadow as Record<string, unknown>;
+    if (
+      (record.delivery !== "send" && record.delivery !== "steer") ||
+      typeof record.draftAtSend !== "string" ||
+      !resourceList(record.resourcesAtSend) ||
+      typeof shadowRecord.text !== "string" ||
+      !resourceList(shadowRecord.resources) ||
+      typeof record.clearDraftOnAccept !== "boolean" ||
+      typeof record.hasMcpCredentialUpdates !== "boolean" ||
+      typeof inputRecord.text !== "string" ||
+      typeof inputRecord.clientEventId !== "string" ||
+      "mcpCredentialUpdates" in inputRecord ||
+      ("resources" in inputRecord && !resourceList(inputRecord.resources))
+    ) {
+      return null;
+    }
+    return record as StoredPendingComposerOperation;
+  } catch {
+    return null;
+  }
+}
+
+function writePendingComposerOperation(
+  key: string,
+  operation: StoredPendingComposerOperation,
+): void {
+  const storage = pendingComposerStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(pendingComposerStorageKey(key), JSON.stringify(operation));
+  } catch {
+    // Storage is best effort; the in-memory record still protects remounts.
+  }
+}
+
+function restorePendingComposerOperation(key: string | null): PendingComposerOperation | null {
+  const stored =
+    (key && pendingComposerOperations.get(key)) ?? readStoredPendingComposerOperation(key);
+  if (!stored) return null;
+  return {
+    ...stored,
+    input: stored.input,
+    newerShadow: stored.newerShadow ?? {
+      text: stored.draftAtSend,
+      resources: stored.resourcesAtSend,
+    },
+    canRetry: !stored.hasMcpCredentialUpdates,
+  };
+}
+
+function rememberPendingComposerOperation(
+  key: string | null,
+  operation: PendingComposerOperation,
+): void {
+  if (!key) return;
+  const { canRetry: _retry, ...safeOperation } = operation;
+  const { input: originalInput, ...withoutInput } = safeOperation;
+  const { mcpCredentialUpdates: _storedMcp, ...safeInput } = originalInput;
+  const stored = {
+    ...withoutInput,
+    input: safeInput,
+    hasMcpCredentialUpdates: operation.input.mcpCredentialUpdates !== undefined,
+    newerShadow: {
+      text: operation.newerShadow.text,
+      resources: [...operation.newerShadow.resources],
+    },
+  } satisfies StoredPendingComposerOperation;
+  pendingComposerOperations.set(key, stored);
+  writePendingComposerOperation(key, stored);
+}
+
+function forgetPendingComposerOperation(key: string | null): void {
+  if (!key) return;
+  pendingComposerOperations.delete(key);
+  const storage = pendingComposerStorage();
+  if (!storage) return;
+  try {
+    storage.removeItem(pendingComposerStorageKey(key));
+  } catch {
+    // Ignore a blocked storage implementation; delivery has already settled.
+  }
+}
+
+function updatePendingComposerShadow(
+  key: string | null,
+  operation: PendingComposerOperation | null,
+  shadow: ComposerDraftShadow,
+): PendingComposerOperation | null {
+  if (!key || !operation) return operation;
+  const next = { ...operation, newerShadow: { ...shadow, resources: [...shadow.resources] } };
+  rememberPendingComposerOperation(key, next);
+  return next;
+}
+
 export type ComposerState = {
   value: string;
   setValue: (value: string) => void;
@@ -78,7 +263,10 @@ export function useComposer(
   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 pendingOperationKey = pendingComposerOperationKey(workspaceId, sessionId);
+  const initialPendingOperation = restorePendingComposerOperation(pendingOperationKey);
+  const initialShadow = initialPendingOperation?.newerShadow;
+  const [value, setValue] = useState(() => initialShadow?.text ?? "");
   // 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);
@@ -90,22 +278,37 @@ export function useComposer(
   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 [restoredResources, setRestoredResources] = useState<ResourceRef[]>(
+    () => initialShadow?.resources ?? [],
+  );
+  const pendingOperationRef = useRef<PendingComposerOperation | null>(initialPendingOperation);
+  const pendingClientEventId = useRef<string | null>(
+    initialPendingOperation?.input.clientEventId ?? null,
+  );
+  const valueRef = useRef(initialShadow?.text ?? "");
   const draftRef = useRef<ComposerDraft | null>(null);
-  const restoredResourcesRef = useRef<ResourceRef[]>([]);
-  const localEditRevision = useRef(0);
+  const restoredResourcesRef = useRef<ResourceRef[]>(initialShadow?.resources ?? []);
+  const localEditRevision = useRef(initialShadow ? 1 : 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;
   const onDraftApplied = options.onDraftApplied;
+  // Read through a ref so live session/policy projections can replace their
+  // apply callback without invalidating the draft loader and re-running its
+  // initial-load effect. Publish only committed callbacks: a suspended target
+  // render must not retarget an in-flight read owned by the committed session.
+  const onDraftAppliedRef = useRef(onDraftApplied);
+  useLayoutEffect(() => {
+    onDraftAppliedRef.current = onDraftApplied;
+  }, [onDraftApplied]);
   // 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 sendBlockedRef = useRef(options.sendBlocked);
+  sendBlockedRef.current = options.sendBlocked;
   const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
 
   // A composer is bound to one session: switching targets must not leak the
@@ -116,17 +319,19 @@ export function useComposer(
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
     draftReadGeneration.current += 1;
-    pendingClientEventId.current = null;
-    localEditRevision.current = 0;
-    valueRef.current = "";
+    pendingOperationRef.current = restorePendingComposerOperation(pendingOperationKey);
+    pendingClientEventId.current = pendingOperationRef.current?.input.clientEventId ?? null;
+    const shadow = pendingOperationRef.current?.newerShadow;
+    localEditRevision.current = shadow ? 1 : 0;
+    valueRef.current = shadow?.text ?? "";
     draftRef.current = null;
-    restoredResourcesRef.current = [];
+    restoredResourcesRef.current = shadow?.resources ?? [];
     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("");
+    setValue(shadow?.text ?? "");
     setSending(false);
     setPausing(false);
     setResuming(false);
@@ -135,14 +340,13 @@ export function useComposer(
     setDraftLoading(Boolean(sessionId) && durableDrafts);
     setDraftSaving(false);
     setDraftConflict(null);
-    setRestoredResources([]);
-  }, [durableDrafts, sessionId, targetKey]);
+    setRestoredResources(shadow?.resources ?? []);
+  }, [durableDrafts, pendingOperationKey, 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;
@@ -151,6 +355,17 @@ export function useComposer(
         setDraft(null);
         setValue(next.text);
         setRestoredResources(next.resources);
+        pendingOperationRef.current = updatePendingComposerShadow(
+          pendingOperationKey,
+          pendingOperationRef.current,
+          {
+            text: next.text,
+            resources: mergeResources(
+              next.resources,
+              resolveSendExtras(sendExtrasRef.current).resources ?? [],
+            ),
+          },
+        );
         setDraftConflict(null);
         return;
       }
@@ -159,14 +374,24 @@ export function useComposer(
       restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
       localEditRevision.current += 1;
-      pendingClientEventId.current = null;
       setDraft(next);
       setValue(next.text);
       setRestoredResources(next.resources);
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next.text,
+          resources: mergeResources(
+            next.resources,
+            resolveSendExtras(sendExtrasRef.current).resources ?? [],
+          ),
+        },
+      );
       setDraftConflict(null);
-      onDraftApplied?.(next);
+      onDraftAppliedRef.current?.(next);
     },
-    [durableDrafts, onDraftApplied, targetKey],
+    [durableDrafts, pendingOperationKey, targetKey],
   );
 
   const loadDraft = useCallback(
@@ -210,7 +435,16 @@ export function useComposer(
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
-          if (
+          const shadow = pendingOperationRef.current?.newerShadow;
+          if (shadow) {
+            // The server can only know the original operation. Never replace
+            // newer local edits while that operation is still uncertain.
+            valueRef.current = shadow.text;
+            restoredResourcesRef.current = shadow.resources;
+            localEditRevision.current ||= 1;
+            setValue(shadow.text);
+            setRestoredResources(shadow.resources);
+          } else if (
             replaceLocal ||
             (!localWasDirtyAtStart && localAtStart === localEditRevision.current)
           ) {
@@ -219,7 +453,7 @@ export function useComposer(
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
-            onDraftApplied?.(fetched);
+            onDraftAppliedRef.current?.(fetched);
           }
         }
       } catch (cause) {
@@ -240,7 +474,7 @@ export function useComposer(
         }
       }
     },
-    [client, durableDrafts, onDraftApplied, sessionId, targetKey, workspaceId],
+    [client, durableDrafts, sessionId, targetKey, workspaceId],
   );
 
   useEffect(() => {
@@ -317,7 +551,7 @@ export function useComposer(
             targetGeneration.current === ownedGeneration
           ) {
             const problem = asError(cause);
-            setDraftConflict(problem);
+            if (isDraftConflictError(problem)) setDraftConflict(problem);
             setError(problem);
           }
         } finally {
@@ -339,6 +573,27 @@ export function useComposer(
   // Private durable autosave. A newer local edit is never replaced by an older
   // response; saves serialize and each reads the latest acknowledged revision.
   useEffect(() => {
+    const pending = pendingOperationRef.current;
+    if (pending) {
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? [],
+        ),
+      };
+      if (
+        pending.newerShadow.text !== shadow.text ||
+        JSON.stringify(pending.newerShadow.resources) !== JSON.stringify(shadow.resources)
+      ) {
+        pendingOperationRef.current = updatePendingComposerShadow(
+          pendingOperationKey,
+          pending,
+          shadow,
+        );
+      }
+      return;
+    }
     if (
       !durableDrafts ||
       !sessionId ||
@@ -358,6 +613,7 @@ export function useComposer(
     draftConflict,
     draftLoading,
     liveExtrasVersion,
+    pendingOperationKey,
     persistPayload,
     sending,
     sessionId,
@@ -367,27 +623,139 @@ export function useComposer(
     async (delivery: "send" | "steer", explicit?: string): Promise<boolean> => {
       const ownedTargetKey = targetKey;
       const ownedGeneration = targetGeneration.current;
+      const operationKey = pendingComposerOperationKey(workspaceId, sessionId);
+      const pending = pendingOperationRef.current ?? restorePendingComposerOperation(operationKey);
+      if (pending && !pendingOperationRef.current) {
+        pendingOperationRef.current = pending;
+        pendingClientEventId.current = pending.input.clientEventId ?? null;
+      }
       const draftAtSend = value;
       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 extras = pending ? {} : resolveSendExtras(sendExtrasRef.current);
       const hasResources = restoredResources.length > 0 || (extras.resources?.length ?? 0) > 0;
       if (
-        (!hasText && !hasResources) ||
+        (!pending && !hasText && !hasResources) ||
         !sessionId ||
         sending ||
+        sendBlockedRef.current?.() === true ||
         targetKeyRef.current !== ownedTargetKey
       ) {
         return false;
       }
-      // Reuse the clientEventId across retries of the same draft so a
-      // timeout + resend cannot double-deliver the message.
-      pendingClientEventId.current ??= generateClientEventId();
+
+      const clearPending = (): void => {
+        pendingOperationRef.current = null;
+        pendingClientEventId.current = null;
+        forgetPendingComposerOperation(operationKey);
+      };
+
+      const settleAccepted = (operation: PendingComposerOperation): void => {
+        clearPending();
+        const draftWasUnchanged = valueRef.current === operation.draftAtSend;
+        const resourcesWereUnchanged =
+          JSON.stringify(restoredResourcesRef.current) ===
+          JSON.stringify(operation.resourcesAtSend);
+        const previousDraft = draftRef.current;
+        if (previousDraft) {
+          const cleared = {
+            ...previousDraft,
+            revision: 0,
+            text: "",
+            resources: [],
+            sourceTurnId: null,
+            sourceTurnVersion: null,
+            updatedAt: null,
+          };
+          draftRef.current = cleared;
+          setDraft(cleared);
+          lastSavedSignature.current = draftSignature(draftPayload(cleared));
+        }
+        if (resourcesWereUnchanged) {
+          restoredResourcesRef.current = [];
+          setRestoredResources([]);
+        }
+        if (operation.clearDraftOnAccept && draftWasUnchanged) {
+          valueRef.current = "";
+          setValue("");
+        }
+        onSent?.(operation.input.text, operation.input);
+      };
+
+      const deliver = async (operation: PendingComposerOperation): Promise<void> => {
+        if (operation.delivery === "steer") {
+          await client.steerMessage(workspaceId, sessionId, operation.input);
+        } else {
+          await client.sendMessage(workspaceId, sessionId, operation.input);
+        }
+      };
+
       setSending(true);
       setError(null);
       try {
+        if (pending) {
+          let accepted = false;
+          try {
+            const events = await client.listEvents(workspaceId, sessionId, {
+              includeTypes: ["user.message"],
+              limit: 100,
+              payloadMode: "none",
+            });
+            accepted = events.some(
+              (event) =>
+                event.type === "user.message" &&
+                event.clientEventId === pending.input.clientEventId,
+            );
+          } catch (cause) {
+            if (
+              targetKeyRef.current === ownedTargetKey &&
+              targetGeneration.current === ownedGeneration
+            ) {
+              setError(asError(cause));
+            }
+            return false;
+          }
+          if (
+            targetKeyRef.current !== ownedTargetKey ||
+            targetGeneration.current !== ownedGeneration
+          ) {
+            return false;
+          }
+          if (accepted) {
+            settleAccepted(pending);
+            return true;
+          }
+          if (!pending.canRetry) {
+            setError(
+              new Error(
+                "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again.",
+              ),
+            );
+            return false;
+          }
+          try {
+            await deliver(pending);
+          } catch (cause) {
+            if (
+              targetKeyRef.current === ownedTargetKey &&
+              targetGeneration.current === ownedGeneration
+            ) {
+              setError(asError(cause));
+            }
+            return false;
+          }
+          if (
+            targetKeyRef.current !== ownedTargetKey ||
+            targetGeneration.current !== ownedGeneration
+          ) {
+            return false;
+          }
+          settleAccepted(pending);
+          return true;
+        }
+
         // 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
@@ -411,6 +779,7 @@ export function useComposer(
           !Object.prototype.hasOwnProperty.call(extras, "tools")
             ? { ...extras, tools: acknowledgedDraft.tools }
             : extras;
+        pendingClientEventId.current ??= generateClientEventId();
         const input = composeSendInput(sendText, pendingClientEventId.current, sendExtras, {
           ...(options.effectiveControl?.controlEtag
             ? { controlEtag: options.effectiveControl.controlEtag }
@@ -420,10 +789,33 @@ export function useComposer(
             : {}),
           resources: mergeResources(restoredResources, extras.resources ?? []),
         });
-        if (delivery === "steer") {
-          await client.steerMessage(workspaceId, sessionId, input);
-        } else {
-          await client.sendMessage(workspaceId, sessionId, input);
+        const operation: PendingComposerOperation = {
+          delivery,
+          input,
+          draftAtSend,
+          resourcesAtSend: [...restoredResources],
+          newerShadow: {
+            text: draftAtSend,
+            resources: mergeResources(restoredResources, extras.resources ?? []),
+          },
+          clearDraftOnAccept: explicit === undefined,
+          canRetry: true,
+        };
+        pendingOperationRef.current = operation;
+        rememberPendingComposerOperation(operationKey, operation);
+        try {
+          await deliver(operation);
+        } catch (cause) {
+          if (!isOutcomeUnknownError(cause)) {
+            clearPending();
+          }
+          if (
+            targetKeyRef.current === ownedTargetKey &&
+            targetGeneration.current === ownedGeneration
+          ) {
+            setError(asError(cause));
+          }
+          return false;
         }
         if (
           targetKeyRef.current !== ownedTargetKey ||
@@ -431,42 +823,8 @@ export function useComposer(
         ) {
           return false;
         }
-        pendingClientEventId.current = null;
-        const previousDraft = draftRef.current;
-        if (previousDraft) {
-          const cleared = {
-            ...previousDraft,
-            revision: 0,
-            text: "",
-            resources: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null,
-          };
-          draftRef.current = cleared;
-          restoredResourcesRef.current = [];
-          setDraft(cleared);
-          setRestoredResources([]);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
-        if (explicit === undefined) {
-          // Clear only the draft that was sent: edits made while the request
-          // was in flight were never delivered and must survive.
-          if (valueRef.current === draftAtSend) {
-            valueRef.current = "";
-            setValue("");
-          }
-        }
-        onSent?.(sendText);
+        settleAccepted(operation);
         return true;
-      } catch (cause) {
-        if (
-          targetKeyRef.current === ownedTargetKey &&
-          targetGeneration.current === ownedGeneration
-        ) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
-        }
-        return false;
       } finally {
         if (
           targetKeyRef.current === ownedTargetKey &&
@@ -498,11 +856,12 @@ export function useComposer(
   // A send is possible with non-empty text OR with ≥1 attached resource (a
   // file-only message). Resources ride in `sendExtras`, so we resolve them here
   // — 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.
+  // affordance the moment a file is ready. Attachment hosts bind `sendBlocked`
+  // to unresolved uploads so direct send()/steer() calls fail closed too.
   const hasReadyResources =
     restoredResources.length > 0 ||
     (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
+  const hasPendingOperation = pendingOperationRef.current !== null;
 
   const pause = useCallback(
     async (reason?: string): Promise<void> => {
@@ -634,12 +993,22 @@ export function useComposer(
   const updateValue = useCallback(
     (next: string) => {
       if (targetKeyRef.current !== targetKey) return;
-      pendingClientEventId.current = null;
       localEditRevision.current += 1;
       valueRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next,
+          resources: mergeResources(
+            restoredResourcesRef.current,
+            resolveSendExtras(sendExtrasRef.current).resources ?? [],
+          ),
+        },
+      );
       setValue(next);
     },
-    [targetKey],
+    [pendingOperationKey, targetKey],
   );
 
   const removeRestoredResource = useCallback(
@@ -648,9 +1017,17 @@ export function useComposer(
       localEditRevision.current += 1;
       const next = restoredResourcesRef.current.filter((_, candidate) => candidate !== index);
       restoredResourcesRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: valueRef.current,
+          resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
+        },
+      );
       setRestoredResources(next);
     },
-    [targetKey],
+    [pendingOperationKey, targetKey],
   );
 
   const hasDraftContent = useCallback((): boolean => {
@@ -717,7 +1094,8 @@ export function useComposer(
       identityMatches &&
       Boolean(sessionId) &&
       !sending &&
-      (value.trim().length > 0 || hasReadyResources),
+      sendBlockedRef.current?.() !== true &&
+      (hasPendingOperation || value.trim().length > 0 || hasReadyResources),
     pause,
     pausing: identityMatches ? pausing : false,
     resume,
@@ -795,10 +1173,29 @@ function generateClientEventId(): string {
   return globalThis.crypto.randomUUID();
 }
 
+function isOutcomeUnknownError(cause: unknown): boolean {
+  return (
+    typeof cause === "object" &&
+    cause !== null &&
+    (cause as { outcomeUnknown?: unknown }).outcomeUnknown === true
+  );
+}
+
 function asError(cause: unknown): Error {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
 
+function isDraftConflictError(error: Error): boolean {
+  const apiError = error as Partial<OpenGeniApiError>;
+  return (
+    apiError.status === 409 &&
+    apiError.outcomeUnknown === false &&
+    (apiError.code === undefined ||
+      apiError.code === "conflict" ||
+      apiError.code === "idempotency_conflict")
+  );
+}
+
 function draftPayload(draft: ComposerDraft): SaveComposerDraftRequest {
   return {
     expectedRevision: draft.revision,