@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

package/dist/{chunk-IGC6A2ZI.js → chunk-Q5QBEZIQ.js}

@@ -1,13 +1,26 @@
+import {
+  COMPOSER_MODEL_UNAVAILABLE_MESSAGE,
+  ComposerReconciliationRequiredError,
+  ComposerStateError,
+  ComposerWorkspaceControlUnavailableError,
+  composerSubmissionCanRetry,
+  composerSubmissionErrorMessage
+} from "./chunk-UTRTG6LH.js";
 import {
   useSessionEventTrigger
-} from "./chunk-KZ73RL76.js";
+} from "./chunk-YQEAA6LT.js";
+import {
+  normalizeError,
+  useErrorMessage
+} from "./chunk-UGLEYEMP.js";
 import {
   useEmbeddedSession
-} from "./chunk-C5ZPSSS5.js";
+} from "./chunk-NEXLLTP4.js";
 
 // src/hooks/use-composer.ts
 import {
-  DEFAULT_FILE_RESOURCE_MOUNT_ROOT
+  DEFAULT_FILE_RESOURCE_MOUNT_ROOT,
+  OpenGeniApiError
 } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 var PENDING_COMPOSER_STORAGE_PREFIX = "opengeni.pending-composer.v1:";
@@ -46,14 +59,28 @@ function restoreOptimisticSendOperations(key) {
   }
   return stored.map(({ hasMcpCredentialUpdates, ...operation }) => ({
     ...operation,
+    delivery: "send",
+    destination: operation.destination === "queue" ? "queue" : "chat",
     newerShadow: operation.newerShadow ?? { text: "", resources: [], annotations: [] },
     state: operation.state === "sending" || operation.state === "queued" ? "sending" : operation.state,
     outcomeUnknown: operation.state === "sending" || operation.state === "queued" ? true : operation.outcomeUnknown,
-    error: operation.state === "sending" ? "Delivery was interrupted; retry to reconcile this message." : operation.error,
+    correlationId: restoredCorrelationId(operation.correlationId),
+    error: restoredErrorReference(
+      operation.correlationId,
+      hasMcpCredentialUpdates && (operation.state === "sending" || operation.outcomeUnknown) ? composerSubmissionErrorMessage(new ComposerReconciliationRequiredError()) : operation.state === "sending" ? "Delivery was interrupted; retry to reconcile this message." : operation.outcomeUnknown ? "The request could not be confirmed. Check its status before retrying." : operation.error ? composerSubmissionErrorMessage(new Error(operation.error)) : void 0
+    ),
+    retryable: operation.state === "sending" || operation.outcomeUnknown ? true : operation.retryable ?? (operation.error ? composerSubmissionCanRetry(new Error(operation.error)) : true),
     input: operation.input,
     canRetry: !hasMcpCredentialUpdates
   }));
 }
+function restoredCorrelationId(value) {
+  return typeof value === "string" && /^[\w.:-]{1,128}$/u.test(value) ? value : void 0;
+}
+function restoredErrorReference(reference, message) {
+  const correlationId = restoredCorrelationId(reference);
+  return message && correlationId && message !== COMPOSER_MODEL_UNAVAILABLE_MESSAGE ? `${message} Reference: ${correlationId}.` : message;
+}
 function rememberOptimisticSendOperations(key, operations) {
   if (!key) return;
   const stored = operations.filter((operation) => operation.state !== "queued").map((operation) => {
@@ -65,6 +92,14 @@ function rememberOptimisticSendOperations(key, operations) {
       hasMcpCredentialUpdates: input.mcpCredentialUpdates !== void 0
     };
   });
+  if (stored.length === 0) {
+    optimisticSendOperations.delete(key);
+    try {
+      pendingComposerStorage()?.removeItem(optimisticSendStorageKey(key));
+    } catch {
+    }
+    return;
+  }
   optimisticSendOperations.set(key, stored);
   try {
     pendingComposerStorage()?.setItem(optimisticSendStorageKey(key), JSON.stringify(stored));
@@ -157,7 +192,8 @@ function rememberPendingComposerOperation(key, operation) {
     newerShadow: {
       text: operation.newerShadow.text,
       resources: [...operation.newerShadow.resources],
-      annotations: cloneAnnotations(operation.newerShadow.annotations)
+      annotations: cloneAnnotations(operation.newerShadow.annotations),
+      ...operation.newerShadow.policy ? { policy: { ...operation.newerShadow.policy } } : {}
     }
   };
   pendingComposerOperations.set(key, stored);
@@ -201,6 +237,18 @@ function steeringAcceptedEvent(steering, events) {
     (event) => event.type === "user.message" && steering.clientEventId !== null && event.clientEventId === steering.clientEventId
   );
 }
+function promptTurnIdForTrigger(triggerEventId, events) {
+  if (!triggerEventId) return null;
+  const queued = events.find((event) => {
+    if (event.type !== "turn.queued") return false;
+    const payload2 = event.payload;
+    return typeof payload2 === "object" && payload2 !== null && "triggerEventId" in payload2 && payload2.triggerEventId === triggerEventId;
+  });
+  if (!queued) return null;
+  if (queued.turnId) return queued.turnId;
+  const payload = queued.payload;
+  return typeof payload === "object" && payload !== null && "turnId" in payload && typeof payload.turnId === "string" ? payload.turnId : null;
+}
 function steeringSettledByEvents(steering, events) {
   const acceptedEventId = steering.triggerEventId ?? steeringAcceptedEvent(steering, events)?.id ?? null;
   return events.some((event) => {
@@ -212,9 +260,57 @@ function steeringSettledByEvents(steering, events) {
     return typeof payload === "object" && payload !== null && "triggerEventId" in payload && payload.triggerEventId === acceptedEventId;
   });
 }
+function reconcileOptimisticSendFromEvents(operation, events) {
+  const accepted = events.find(
+    (event) => event.type === "user.message" && event.clientEventId === operation.clientEventId
+  );
+  const triggerEventId = operation.triggerEventId ?? accepted?.id ?? null;
+  const turnId = operation.turnId ?? promptTurnIdForTrigger(triggerEventId, events);
+  const acceptedRouting = promptRoutingFromAcceptedEvent(accepted ?? null);
+  const destination = acceptedRouting === "queued_for_execution" ? "queue" : acceptedRouting === "accepted_for_execution" || acceptedRouting === "accepted_for_steering" ? "chat" : operation.destination;
+  const needsAdmissionUpdate = accepted !== void 0 && (operation.state !== "queued" || operation.destination !== destination || operation.triggerEventId !== triggerEventId || operation.turnId !== turnId || operation.error !== void 0 || operation.outcomeUnknown !== false);
+  const reconciled = needsAdmissionUpdate ? {
+    ...operation,
+    state: "queued",
+    destination,
+    triggerEventId,
+    turnId,
+    error: void 0,
+    outcomeUnknown: false
+  } : operation;
+  const withdrawnFromQueue = events.some((event) => {
+    if (event.type !== "session.queue.changed" || !turnId) return false;
+    const payload = event.payload;
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return false;
+    const record = payload;
+    return record.turnId === turnId && (record.operation === "edit" || record.operation === "delete");
+  });
+  return {
+    operation: reconciled,
+    admitted: accepted !== void 0,
+    // Edit/Delete atomically withdraw the queued turn. Keeping its optimistic
+    // send alive after that point lets its old `newerShadow` become the newest
+    // composer draft again when a later turn settles, duplicating submitted
+    // text. The queue mutation is the durable terminal fact for this send.
+    settled: withdrawnFromQueue || steeringSettledByEvents(
+      {
+        phase: "accepted",
+        text: reconciled.text,
+        clientEventId: reconciled.clientEventId,
+        triggerEventId: reconciled.triggerEventId ?? null,
+        turnId: reconciled.turnId ?? null
+      },
+      events
+    )
+  };
+}
 function useComposer(sessionId, options = {}) {
   const { client, workspaceId, registerSessionReconciler } = useEmbeddedSession(options);
+  const formatError = useErrorMessage();
   const durableDrafts = options.draftPersistence !== "disabled";
+  if (!durableDrafts && !options.initialPolicy) {
+    throw new Error("useComposer requires initialPolicy when draft persistence is disabled");
+  }
   const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${durableDrafts ? "durable" : "disabled"}`;
   const pendingOperationKey = pendingComposerOperationKey(workspaceId, sessionId);
   const initialPendingOperation = restorePendingComposerOperation(pendingOperationKey);
@@ -230,21 +326,27 @@ function useComposer(sessionId, options = {}) {
   const [optimisticSends, setOptimisticSends] = useState(initialOptimisticSends);
   const [steering, setSteering] = useState(
     () => initialPendingOperation?.delivery === "steer" ? {
-      phase: "submitting",
+      phase: "failed",
       text: initialPendingOperation.input.text,
       clientEventId: initialPendingOperation.input.clientEventId ?? null,
       triggerEventId: null,
-      turnId: null
+      turnId: null,
+      error: "Not confirmed. Retry to check the same direction change.",
+      outcomeUnknown: true
     } : null
   );
   const [pausing, setPausing] = useState(false);
-  const [controlStopping, setControlStopping] = useState(null);
+  const [acceptedControl, setAcceptedControl] = useState(null);
   const [resuming, setResuming] = useState(false);
   const [error, setError] = useState(null);
+  const [draftReadError, setDraftReadError] = useState(null);
   const [draft, setDraft] = useState(null);
   const [draftLoading, setDraftLoading] = useState(Boolean(sessionId) && durableDrafts);
   const [draftSaving, setDraftSaving] = useState(false);
   const [draftConflict, setDraftConflict] = useState(null);
+  const [policy, setPolicy] = useState(
+    () => initialShadow?.policy ?? options.initialPolicy ?? null
+  );
   const [restoredResources, setRestoredResources] = useState(
     () => initialShadow?.resources ?? []
   );
@@ -254,36 +356,52 @@ function useComposer(sessionId, options = {}) {
   const optimisticCallbackIdsRef = useRef(/* @__PURE__ */ new Set());
   const steeringSettlementEventsRef = useRef([]);
   const steeringRef = useRef(steering);
+  const steeringOccurredAtRef = useRef((/* @__PURE__ */ new Date()).toISOString());
   const pendingClientEventId = useRef(
     initialPendingOperation?.input.clientEventId ?? null
   );
   const valueRef = useRef(initialShadow?.text ?? "");
   const annotationsRef = useRef(initialShadow?.annotations ?? []);
+  const policyRef = useRef(
+    initialShadow?.policy ?? options.initialPolicy ?? null
+  );
   const draftRef = useRef(null);
   const restoredResourcesRef = useRef(initialShadow?.resources ?? []);
   const localEditRevision = useRef(initialShadow ? 1 : 0);
   const targetGeneration = useRef(0);
   const draftReadGeneration = useRef(0);
+  const draftReadInFlightRef = useRef(null);
+  const draftReadAbortRef = useRef(null);
+  const draftReadRetryRef = useRef({ targetKey, failures: 0, timer: null });
   const lastSavedSignature = useRef(null);
   const saveChain = useRef(Promise.resolve());
   const onSent = options.onSent;
   const onSubmitted = options.onSubmitted;
-  const onDraftApplied = options.onDraftApplied;
-  const onDraftAppliedRef = useRef(onDraftApplied);
-  useLayoutEffect(() => {
-    onDraftAppliedRef.current = onDraftApplied;
-  }, [onDraftApplied]);
+  const onDeliveryErrorRef = useRef(options.onDeliveryError);
+  onDeliveryErrorRef.current = options.onDeliveryError;
   useLayoutEffect(() => {
     steeringRef.current = steering;
   }, [steering]);
   const sendExtrasRef = useRef(options.sendExtras);
   sendExtrasRef.current = options.sendExtras;
+  const sendDestinationRef = useRef(options.sendDestination);
+  sendDestinationRef.current = options.sendDestination;
   const sendBlockedRef = useRef(options.sendBlocked);
   sendBlockedRef.current = options.sendBlocked;
+  const effectiveControlRef = useRef(
+    acceptedControl ?? options.effectiveControl ?? null
+  );
+  effectiveControlRef.current = acceptedControl ?? options.effectiveControl ?? null;
   const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
   const targetKeyRef = useRef(targetKey);
   useLayoutEffect(() => {
     if (targetKeyRef.current === targetKey) return;
+    if (draftReadRetryRef.current.timer !== null) {
+      clearTimeout(draftReadRetryRef.current.timer);
+    }
+    draftReadAbortRef.current?.abort();
+    draftReadAbortRef.current = null;
+    draftReadRetryRef.current = { targetKey, failures: 0, timer: null };
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
     draftReadGeneration.current += 1;
@@ -298,6 +416,7 @@ function useComposer(sessionId, options = {}) {
     localEditRevision.current = shadow ? 1 : 0;
     valueRef.current = shadow?.text ?? "";
     annotationsRef.current = shadow?.annotations ?? [];
+    policyRef.current = shadow?.policy ?? options.initialPolicy ?? null;
     draftRef.current = null;
     restoredResourcesRef.current = shadow?.resources ?? [];
     lastSavedSignature.current = null;
@@ -305,28 +424,45 @@ function useComposer(sessionId, options = {}) {
     setStateTargetKey(targetKey);
     setValue(shadow?.text ?? "");
     setAnnotations(shadow?.annotations ?? []);
+    setPolicy(policyRef.current);
     setAnnotationReviewTargetId(null);
     setSending(false);
     setOptimisticSends(restoredOptimisticSends);
     setSteering(
       pendingOperationRef.current?.delivery === "steer" ? {
-        phase: "submitting",
+        phase: "failed",
         text: pendingOperationRef.current.input.text,
         clientEventId: pendingOperationRef.current.input.clientEventId ?? null,
         triggerEventId: null,
-        turnId: null
+        turnId: null,
+        error: "Not confirmed. Retry to check the same direction change.",
+        outcomeUnknown: true
       } : null
     );
     setPausing(false);
-    setControlStopping(null);
+    setAcceptedControl(null);
     setResuming(false);
     setError(null);
+    setDraftReadError(null);
     setDraft(null);
     setDraftLoading(Boolean(sessionId) && durableDrafts);
     setDraftSaving(false);
     setDraftConflict(null);
     setRestoredResources(shadow?.resources ?? []);
-  }, [durableDrafts, pendingOperationKey, sessionId, targetKey]);
+  }, [durableDrafts, options.initialPolicy, pendingOperationKey, sessionId, targetKey]);
+  useEffect(
+    () => () => {
+      if (draftReadRetryRef.current.timer !== null) {
+        clearTimeout(draftReadRetryRef.current.timer);
+      }
+      targetGeneration.current += 1;
+      draftReadGeneration.current += 1;
+      draftReadInFlightRef.current = null;
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = null;
+    },
+    []
+  );
   const setOptimisticDraftShadow = useCallback(
     (shadow) => {
       if (optimisticSendsRef.current.length === 0) return;
@@ -335,7 +471,8 @@ function useComposer(sessionId, options = {}) {
         newerShadow: {
           text: shadow.text,
           resources: [...shadow.resources],
-          annotations: cloneAnnotations(shadow.annotations)
+          annotations: cloneAnnotations(shadow.annotations),
+          ...shadow.policy ? { policy: { ...shadow.policy } } : {}
         }
       }));
       optimisticSendsRef.current = next;
@@ -348,15 +485,18 @@ function useComposer(sessionId, options = {}) {
     (next) => {
       if (targetKeyRef.current !== targetKey) return;
       if (!durableDrafts) {
+        const nextPolicy2 = policyFromDraft(next);
         localEditRevision.current += 1;
         valueRef.current = next.text;
         annotationsRef.current = next.annotations ?? [];
+        policyRef.current = nextPolicy2;
         restoredResourcesRef.current = next.resources;
         draftRef.current = null;
         lastSavedSignature.current = null;
         setDraft(null);
         setValue(next.text);
         setAnnotations(next.annotations ?? []);
+        setPolicy(nextPolicy2);
         setRestoredResources(next.resources);
         pendingOperationRef.current = updatePendingComposerShadow(
           pendingOperationKey,
@@ -367,7 +507,8 @@ function useComposer(sessionId, options = {}) {
               next.resources,
               resolveSendExtras(sendExtrasRef.current).resources ?? []
             ),
-            annotations: next.annotations ?? []
+            annotations: next.annotations ?? [],
+            policy: nextPolicy2
           }
         );
         setOptimisticDraftShadow({
@@ -376,13 +517,16 @@ function useComposer(sessionId, options = {}) {
             next.resources,
             resolveSendExtras(sendExtrasRef.current).resources ?? []
           ),
-          annotations: next.annotations ?? []
+          annotations: next.annotations ?? [],
+          policy: nextPolicy2
         });
         setDraftConflict(null);
         return;
       }
+      const nextPolicy = policyFromDraft(next);
       valueRef.current = next.text;
       annotationsRef.current = next.annotations ?? [];
+      policyRef.current = nextPolicy;
       draftRef.current = next;
       restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
@@ -390,6 +534,7 @@ function useComposer(sessionId, options = {}) {
       setDraft(next);
       setValue(next.text);
       setAnnotations(next.annotations ?? []);
+      setPolicy(nextPolicy);
       setRestoredResources(next.resources);
       pendingOperationRef.current = updatePendingComposerShadow(
         pendingOperationKey,
@@ -400,7 +545,8 @@ function useComposer(sessionId, options = {}) {
             next.resources,
             resolveSendExtras(sendExtrasRef.current).resources ?? []
           ),
-          annotations: next.annotations ?? []
+          annotations: next.annotations ?? [],
+          policy: nextPolicy
         }
       );
       setOptimisticDraftShadow({
@@ -409,10 +555,10 @@ function useComposer(sessionId, options = {}) {
           next.resources,
           resolveSendExtras(sendExtrasRef.current).resources ?? []
         ),
-        annotations: next.annotations ?? []
+        annotations: next.annotations ?? [],
+        policy: nextPolicy
       });
       setDraftConflict(null);
-      onDraftAppliedRef.current?.(next);
     },
     [durableDrafts, pendingOperationKey, setOptimisticDraftShadow, targetKey]
   );
@@ -421,34 +567,69 @@ function useComposer(sessionId, options = {}) {
       if (targetKeyRef.current !== targetKey) return;
       if (!sessionId || !durableDrafts) {
         setDraftLoading(false);
+        setDraftReadError(null);
         return;
       }
+      let retry = draftReadRetryRef.current;
+      if (retry.targetKey !== targetKey) {
+        if (retry.timer !== null) clearTimeout(retry.timer);
+        retry = { targetKey, failures: 0, timer: null };
+        draftReadRetryRef.current = retry;
+      }
+      const scheduleRetry = () => {
+        if (retry.timer !== null) return;
+        retry.timer = setTimeout(
+          () => {
+            if (draftReadRetryRef.current !== retry || targetKeyRef.current !== targetKey) return;
+            retry.timer = null;
+            void loadDraft(false);
+          },
+          Math.min(25e3, 1e3 * 2 ** (retry.failures - 1)) * (0.8 + Math.random() * 0.4)
+        );
+      };
+      if (!replaceLocal && retry.timer !== null) return;
+      if (draftReadInFlightRef.current === targetKey) return;
+      if (retry.timer !== null) {
+        clearTimeout(retry.timer);
+        retry.timer = null;
+      }
+      draftReadInFlightRef.current = targetKey;
       const generation = targetGeneration.current;
       const readTicket = ++draftReadGeneration.current;
+      const requestAbort = new AbortController();
+      draftReadAbortRef.current?.abort();
+      draftReadAbortRef.current = requestAbort;
       const localAtStart = localEditRevision.current;
       const baseAtStart = draftRef.current;
-      const extrasAtStart = resolveSendExtras(sendExtrasRef.current);
-      const localSignatureAtStart = baseAtStart ? draftSignature(
+      const policyAtStart = policyRef.current;
+      const localSignatureAtStart = baseAtStart ? policyAtStart ? draftSignature(
         composerDraftPayload(
           baseAtStart,
           valueRef.current,
           restoredResourcesRef.current,
           annotationsRef.current,
-          extrasAtStart
+          policyAtStart,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
         )
-      ) : null;
+      ) : null : null;
       const localWasDirtyAtStart = localSignatureAtStart === null ? localAtStart !== 0 : localSignatureAtStart !== lastSavedSignature.current;
       const showLoading = replaceLocal || draftRef.current === null;
       if (showLoading) {
         setDraftLoading(true);
       }
       try {
-        const fetched = await client.getComposerDraft(workspaceId, sessionId);
+        const fetched = await client.getComposerDraft(workspaceId, sessionId, {
+          signal: requestAbort.signal
+        });
         if (generation !== targetGeneration.current || targetKeyRef.current !== targetKey || readTicket !== draftReadGeneration.current) {
           return;
         }
+        if (retry.timer !== null) clearTimeout(retry.timer);
+        retry.failures = 0;
+        retry.timer = null;
+        setDraftReadError(null);
         const currentRevision = draftRef.current?.revision ?? -1;
-        if (fetched.revision >= currentRevision) {
+        if (replaceLocal || fetched.revision > currentRevision) {
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
@@ -457,33 +638,58 @@ function useComposer(sessionId, options = {}) {
             valueRef.current = shadow.text;
             restoredResourcesRef.current = shadow.resources;
             annotationsRef.current = shadow.annotations;
+            if (shadow.policy) policyRef.current = shadow.policy;
             localEditRevision.current ||= 1;
             setValue(shadow.text);
             setRestoredResources(shadow.resources);
             setAnnotations(shadow.annotations);
+            if (shadow.policy) setPolicy(shadow.policy);
           } else if (replaceLocal || !localWasDirtyAtStart && localAtStart === localEditRevision.current) {
-            const extrasNow = resolveSendExtras(sendExtrasRef.current);
-            const pickerChangedDuringFetch = extrasNow.model !== extrasAtStart.model || extrasNow.reasoningEffort !== extrasAtStart.reasoningEffort || extrasNow.latencyMode !== extrasAtStart.latencyMode;
+            const fetchedPolicy = policyFromDraft(fetched);
             valueRef.current = fetched.text;
             restoredResourcesRef.current = fetched.resources;
             annotationsRef.current = fetched.annotations ?? [];
+            policyRef.current = fetchedPolicy;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
             setAnnotations(fetched.annotations ?? []);
-            if (replaceLocal || !pickerChangedDuringFetch) {
-              onDraftAppliedRef.current?.(fetched);
+            setPolicy(fetchedPolicy);
+          } else {
+            lastSavedSignature.current = draftSignature(draftPayload(fetched));
+            if (!policyRef.current) {
+              const fetchedPolicy = policyFromDraft(fetched);
+              policyRef.current = fetchedPolicy;
+              setPolicy(fetchedPolicy);
             }
           }
         }
       } catch (cause) {
-        if (generation === targetGeneration.current && targetKeyRef.current === targetKey && readTicket === draftReadGeneration.current) {
-          setError(asError(cause));
+        if (!requestAbort.signal.aborted && generation === targetGeneration.current && targetKeyRef.current === targetKey && readTicket === draftReadGeneration.current) {
+          const problem = asError(cause);
+          const timedOut = problem.name === "TimeoutError";
+          setDraftReadError(
+            timedOut ? new ComposerStateError("Draft sync timed out. Retrying\u2026", { cause }) : problem
+          );
+          if (timedOut || cause instanceof TypeError || cause && typeof cause === "object" && "retryable" in cause && cause.retryable === true) {
+            retry.failures += 1;
+            scheduleRetry();
+          } else {
+            if (retry.timer !== null) clearTimeout(retry.timer);
+            retry.failures = 0;
+            retry.timer = null;
+          }
         }
       } finally {
         if (generation === targetGeneration.current && targetKeyRef.current === targetKey && readTicket === draftReadGeneration.current) {
           setDraftLoading(false);
         }
+        if (draftReadInFlightRef.current === targetKey) {
+          draftReadInFlightRef.current = null;
+        }
+        if (draftReadAbortRef.current === requestAbort) {
+          draftReadAbortRef.current = null;
+        }
       }
     },
     [client, durableDrafts, sessionId, targetKey, workspaceId]
@@ -580,23 +786,38 @@ function useComposer(sessionId, options = {}) {
     setSteering(null);
   }, [options.events, steering]);
   useEffect(() => {
-    if (!controlStopping) return;
+    if (!acceptedControl) return;
     const effectiveControl = options.effectiveControl;
-    if (!effectiveControl || effectiveControl.controlVersion < controlStopping.controlVersion) {
+    if (!effectiveControl || effectiveControl.controlVersion < acceptedControl.controlVersion) {
       return;
     }
-    if (effectiveControl.controlVersion === controlStopping.controlVersion && effectiveControl.controlEtag === controlStopping.controlEtag && effectiveControl.settlement !== null) {
-      return;
-    }
-    setControlStopping((current) => current === controlStopping ? null : current);
-  }, [controlStopping, options.effectiveControl]);
+    setAcceptedControl((current) => current === acceptedControl ? null : current);
+  }, [acceptedControl, options.effectiveControl]);
   const currentDraftPayload = useCallback(() => {
     if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
     const base = draftRef.current;
-    if (!base) return null;
-    const extras = resolveSendExtras(sendExtrasRef.current);
-    return composerDraftPayload(base, value, restoredResources, annotations, extras);
+    const currentPolicy = policyRef.current;
+    if (!base || !currentPolicy) return null;
+    return composerDraftPayload(
+      base,
+      value,
+      restoredResources,
+      annotations,
+      currentPolicy,
+      resolveSendExtras(sendExtrasRef.current).resources ?? []
+    );
   }, [annotations, durableDrafts, restoredResources, targetKey, value]);
+  const adoptDraftBase = useCallback(
+    (next) => {
+      if (targetKeyRef.current !== targetKey) return;
+      draftRef.current = next;
+      setDraft(next);
+      lastSavedSignature.current = draftSignature(draftPayload(next));
+      setDraftConflict(null);
+      setError(null);
+    },
+    [targetKey]
+  );
   const persistPayload = useCallback(
     async (payload) => {
       const ownedTargetKey = targetKey;
@@ -619,27 +840,11 @@ function useComposer(sessionId, options = {}) {
         }
         setDraftSaving(true);
         try {
-          const saved = await saveComposerDraftWithStaleRetry({
-            client,
-            workspaceId,
-            sessionId,
-            request,
-            onAdoptRemote: (remote) => {
-              draftRef.current = remote;
-              setDraft(remote);
-            }
-          });
+          const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
           if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
             return;
           }
-          draftRef.current = saved;
-          setDraft(saved);
-          lastSavedSignature.current = draftSignature({
-            ...request,
-            expectedRevision: saved.revision
-          });
-          setDraftConflict(null);
-          setError(null);
+          adoptDraftBase(saved);
           success = true;
         } catch (cause) {
           if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
@@ -657,7 +862,7 @@ function useComposer(sessionId, options = {}) {
       await saveChain.current;
       return success;
     },
-    [client, durableDrafts, sessionId, targetKey, workspaceId]
+    [adoptDraftBase, client, durableDrafts, sessionId, targetKey, workspaceId]
   );
   const replaceOptimisticSends = useCallback(
     (update) => {
@@ -682,15 +887,40 @@ function useComposer(sessionId, options = {}) {
     [onSent, replaceOptimisticSends]
   );
   useEffect(() => {
-    const acceptedIds = new Set(
-      (options.events ?? []).filter((event) => event.type === "user.message" && event.clientEventId).map((event) => event.clientEventId)
+    const events = options.events ?? [];
+    if (events.length === 0 || optimisticSendsRef.current.length === 0) return;
+    const reconciled = optimisticSendsRef.current.map(
+      (operation) => reconcileOptimisticSendFromEvents(operation, events)
     );
-    if (acceptedIds.size === 0) return;
-    const accepted = optimisticSendsRef.current.filter(
-      (operation) => acceptedIds.has(operation.clientEventId)
+    const settledIds = new Set(
+      reconciled.filter((item) => item.settled).map((item) => item.operation.clientEventId)
     );
-    for (const operation of accepted) markOptimisticAccepted(operation);
-  }, [markOptimisticAccepted, options.events]);
+    const changed = reconciled.some(
+      (item, index) => item.operation !== optimisticSendsRef.current[index] && !settledIds.has(item.operation.clientEventId)
+    );
+    for (const item of reconciled) {
+      if (item.admitted && !optimisticCallbackIdsRef.current.has(item.operation.clientEventId)) {
+        optimisticCallbackIdsRef.current.add(item.operation.clientEventId);
+        onSent?.(item.operation.input.text, item.operation.input);
+      }
+      if (item.settled) markOptimisticAccepted(item.operation);
+    }
+    if (changed) {
+      replaceOptimisticSends(
+        (current) => current.map(
+          (operation) => reconciled.find((item) => item.operation.clientEventId === operation.clientEventId)?.operation ?? operation
+        ).filter((operation) => !settledIds.has(operation.clientEventId))
+      );
+    }
+    if (durableDrafts && reconciled.some((item) => item.admitted)) void loadDraft(false);
+  }, [
+    durableDrafts,
+    loadDraft,
+    markOptimisticAccepted,
+    onSent,
+    options.events,
+    replaceOptimisticSends
+  ]);
   const processOptimisticSends = useCallback(() => {
     if (!sessionId || optimisticProcessorBusyRef.current) return;
     const currentOperations = optimisticSendsRef.current;
@@ -703,29 +933,75 @@ function useComposer(sessionId, options = {}) {
     const ownedGeneration = targetGeneration.current;
     optimisticProcessorBusyRef.current = true;
     void (async () => {
+      let mutationFailureObserved = false;
+      const markFailed = (cause, outcomeUnknown) => {
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return;
+        }
+        const problem = asError(cause);
+        replaceOptimisticSends(
+          (current) => current.map(
+            (candidate) => candidate.clientEventId === operation.clientEventId ? {
+              ...candidate,
+              state: "failed",
+              error: formatError(
+                cause,
+                outcomeUnknown && !isOutcomeUnknownError(problem) && !(problem instanceof ComposerReconciliationRequiredError) ? `The request could not be confirmed. Check its status before retrying.${problem instanceof OpenGeniApiError && problem.correlationId ? ` Reference: ${problem.correlationId}.` : ""}` : composerSubmissionErrorMessage(problem)
+              ),
+              retryable: outcomeUnknown || composerSubmissionCanRetry(problem),
+              outcomeUnknown,
+              correlationId: problem instanceof OpenGeniApiError ? problem.correlationId : candidate.correlationId
+            } : candidate
+          )
+        );
+      };
       try {
         if (operation.outcomeUnknown) {
-          const events = await client.listEvents(workspaceId, sessionId, {
-            includeTypes: ["user.message"],
-            limit: 100,
-            payloadMode: "none"
-          });
-          if (events.some(
-            (event) => event.type === "user.message" && event.clientEventId === operation.clientEventId
-          )) {
-            markOptimisticAccepted(operation);
+          let events;
+          try {
+            events = await client.listEvents(workspaceId, sessionId, {
+              includeTypes: [
+                "user.message",
+                "turn.queued",
+                "turn.started",
+                "turn.completed",
+                "turn.failed",
+                "turn.cancelled",
+                "turn.superseded"
+              ],
+              limit: 250,
+              payloadMode: "full"
+            });
+          } catch (cause) {
+            markFailed(cause, true);
+            return;
+          }
+          const reconciled = reconcileOptimisticSendFromEvents(operation, events);
+          if (reconciled.admitted) {
+            if (durableDrafts) await loadDraft(false);
+            if (reconciled.settled) {
+              markOptimisticAccepted(reconciled.operation);
+            } else {
+              replaceOptimisticSends(
+                (current) => current.map(
+                  (candidate) => candidate.clientEventId === operation.clientEventId ? reconciled.operation : candidate
+                )
+              );
+              if (!optimisticCallbackIdsRef.current.has(operation.clientEventId)) {
+                optimisticCallbackIdsRef.current.add(operation.clientEventId);
+                onSent?.(reconciled.operation.input.text, reconciled.operation.input);
+              }
+            }
             return;
           }
           if (!operation.canRetry) {
-            throw new Error(
-              "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again."
-            );
+            throw new ComposerReconciliationRequiredError();
           }
         }
         let expectedDraftRevision;
         if (durableDrafts && operation.draftPayload) {
           if (!await persistPayload(operation.draftPayload)) {
-            throw new Error("The message draft could not be saved before delivery.");
+            throw new ComposerStateError("The message draft could not be saved before delivery.");
           }
           expectedDraftRevision = draftRef.current?.revision;
         }
@@ -736,16 +1012,59 @@ function useComposer(sessionId, options = {}) {
           ...operation.input,
           ...expectedDraftRevision !== void 0 ? { expectedDraftRevision } : {}
         };
-        await client.sendMessage(workspaceId, sessionId, wireInput);
+        let acceptedResult = null;
+        let acceptedEvent = null;
+        if (durableDrafts) {
+          if (!operation.draftPayload || expectedDraftRevision === void 0) {
+            throw new ComposerStateError("The durable composer draft is not ready for delivery.");
+          }
+          const result = await client.submitComposerDraft(workspaceId, sessionId, {
+            text: operation.draftPayload.text,
+            annotations: operation.draftPayload.annotations,
+            resources: operation.draftPayload.resources,
+            model: operation.draftPayload.model,
+            reasoningEffort: operation.draftPayload.reasoningEffort,
+            latencyMode: operation.draftPayload.latencyMode,
+            expectedDraftRevision,
+            clientEventId: operation.clientEventId,
+            delivery: "send",
+            ...wireInput.controlEtag ? { controlEtag: wireInput.controlEtag } : {},
+            ...wireInput.modelContext ? { modelContext: wireInput.modelContext } : {},
+            ...wireInput.mcpCredentialUpdates ? { mcpCredentialUpdates: wireInput.mcpCredentialUpdates } : {},
+            ...wireInput.connectionAccounts ? { connectionAccounts: wireInput.connectionAccounts } : {},
+            ...wireInput.personalResourceAttachment ? { personalResourceAttachment: wireInput.personalResourceAttachment } : {}
+          }).catch((cause) => {
+            mutationFailureObserved = true;
+            throw cause;
+          });
+          acceptedResult = result;
+          adoptDraftBase(result.draft);
+        } else {
+          acceptedEvent = await client.sendMessage(workspaceId, sessionId, wireInput).catch((cause) => {
+            mutationFailureObserved = true;
+            throw cause;
+          });
+        }
         if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
           return;
         }
-        if (options.events === void 0) {
+        const acceptedRouting = acceptedResult?.routing ?? promptRoutingFromAcceptedEvent(acceptedEvent);
+        const acceptedDestination = acceptedRouting === "queued_for_execution" ? "queue" : acceptedRouting === "accepted_for_execution" || acceptedRouting === "accepted_for_steering" ? "chat" : operation.destination;
+        if (options.events === void 0 && acceptedDestination === "chat") {
           markOptimisticAccepted({ ...operation, input: wireInput });
         } else {
           replaceOptimisticSends(
             (current) => current.map(
-              (candidate) => candidate.clientEventId === operation.clientEventId ? { ...candidate, input: wireInput, state: "queued", error: void 0 } : candidate
+              (candidate) => candidate.clientEventId === operation.clientEventId ? {
+                ...candidate,
+                input: wireInput,
+                destination: acceptedDestination,
+                turnId: acceptedResult?.turn.id ?? candidate.turnId,
+                triggerEventId: acceptedResult?.accepted.id ?? acceptedEvent?.id ?? candidate.triggerEventId,
+                appliedQueueVersion: acceptedResult?.receipt?.appliedQueueVersion ?? candidate.appliedQueueVersion,
+                state: "queued",
+                error: void 0
+              } : candidate
             )
           );
         }
@@ -753,36 +1072,17 @@ function useComposer(sessionId, options = {}) {
           optimisticCallbackIdsRef.current.add(operation.clientEventId);
           onSent?.(wireInput.text, wireInput);
         }
-        if (durableDrafts && draftRef.current) {
-          const cleared = {
-            ...draftRef.current,
-            revision: 0,
-            text: "",
-            resources: [],
-            annotations: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null
-          };
-          draftRef.current = cleared;
-          setDraft(cleared);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
       } catch (cause) {
-        const problem = asError(cause);
-        const outcomeUnknown = isOutcomeUnknownError(cause) || operation.outcomeUnknown === true;
-        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-          replaceOptimisticSends(
-            (current) => current.map(
-              (candidate) => candidate.clientEventId === operation.clientEventId ? {
-                ...candidate,
-                state: "failed",
-                error: problem.message,
-                outcomeUnknown
-              } : candidate
-            )
-          );
+        const current = optimisticSendsRef.current.find(
+          (candidate) => candidate.clientEventId === operation.clientEventId
+        );
+        if (!current || current.state === "queued" && current.outcomeUnknown === false) {
+          return;
         }
+        const problem = asError(cause);
+        onDeliveryErrorRef.current?.(problem, operation.input, "send");
+        const outcomeUnknown = operation.outcomeUnknown && !mutationFailureObserved ? true : isOutcomeUnknownError(cause);
+        markFailed(cause, outcomeUnknown);
       } finally {
         optimisticProcessorBusyRef.current = false;
         if (targetKeyRef.current === ownedTargetKey) {
@@ -791,9 +1091,12 @@ function useComposer(sessionId, options = {}) {
       }
     })();
   }, [
+    adoptDraftBase,
     client,
     durableDrafts,
+    formatError,
     markOptimisticAccepted,
+    loadDraft,
     onSent,
     options.events,
     persistPayload,
@@ -814,9 +1117,10 @@ function useComposer(sessionId, options = {}) {
           restoredResourcesRef.current,
           resolveSendExtras(sendExtrasRef.current).resources ?? []
         ),
-        annotations: annotationsRef.current
+        annotations: annotationsRef.current,
+        ...policyRef.current ? { policy: policyRef.current } : {}
       };
-      if (pending.newerShadow.text !== shadow.text || JSON.stringify(pending.newerShadow.resources) !== JSON.stringify(shadow.resources) || JSON.stringify(pending.newerShadow.annotations) !== JSON.stringify(shadow.annotations)) {
+      if (pending.newerShadow.text !== shadow.text || JSON.stringify(pending.newerShadow.resources) !== JSON.stringify(shadow.resources) || JSON.stringify(pending.newerShadow.annotations) !== JSON.stringify(shadow.annotations) || JSON.stringify(pending.newerShadow.policy) !== JSON.stringify(shadow.policy)) {
         pendingOperationRef.current = updatePendingComposerShadow(
           pendingOperationKey,
           pending,
@@ -833,9 +1137,10 @@ function useComposer(sessionId, options = {}) {
           restoredResourcesRef.current,
           resolveSendExtras(sendExtrasRef.current).resources ?? []
         ),
-        annotations: annotationsRef.current
+        annotations: annotationsRef.current,
+        ...policyRef.current ? { policy: policyRef.current } : {}
       };
-      if (optimistic.newerShadow.text !== shadow.text || JSON.stringify(optimistic.newerShadow.resources) !== JSON.stringify(shadow.resources) || JSON.stringify(optimistic.newerShadow.annotations) !== JSON.stringify(shadow.annotations)) {
+      if (optimistic.newerShadow.text !== shadow.text || JSON.stringify(optimistic.newerShadow.resources) !== JSON.stringify(shadow.resources) || JSON.stringify(optimistic.newerShadow.annotations) !== JSON.stringify(shadow.annotations) || JSON.stringify(optimistic.newerShadow.policy) !== JSON.stringify(shadow.policy)) {
         setOptimisticDraftShadow(shadow);
       }
     }
@@ -875,12 +1180,13 @@ function useComposer(sessionId, options = {}) {
       const rawText = explicit ?? draftAtSend;
       const hasText = rawText.trim().length > 0;
       const hasAnnotations = annotationsAtSend.length > 0;
+      const currentPolicy = policyRef.current;
       const annotationsComplete2 = annotationsAtSend.every(
         (annotation) => annotation.note.trim().length > 0
       );
       const extras = pending ? {} : resolveSendExtras(sendExtrasRef.current);
       const hasResources = restoredResources.length > 0 || (extras.resources?.length ?? 0) > 0;
-      if (!pending && (!annotationsComplete2 || !hasText && !hasResources && !hasAnnotations) || !sessionId || sending || sendBlockedRef.current?.() === true || targetKeyRef.current !== ownedTargetKey) {
+      if (!pending && (!annotationsComplete2 || !hasText && !hasResources && !hasAnnotations) || !sessionId || !currentPolicy || sending || sendBlockedRef.current?.() === true || targetKeyRef.current !== ownedTargetKey) {
         return false;
       }
       const clearPending = () => {
@@ -894,22 +1200,6 @@ function useComposer(sessionId, options = {}) {
         const draftWasUnchanged = valueRef.current === operation.draftAtSend;
         const resourcesWereUnchanged = JSON.stringify(restoredResourcesRef.current) === JSON.stringify(operation.resourcesAtSend);
         const annotationsWereUnchanged = JSON.stringify(annotationsRef.current) === JSON.stringify(operation.annotationsAtSend);
-        const previousDraft = draftRef.current;
-        if (previousDraft) {
-          const cleared = {
-            ...previousDraft,
-            revision: 0,
-            text: "",
-            resources: [],
-            annotations: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null
-          };
-          draftRef.current = cleared;
-          setDraft(cleared);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
         if (resourcesWereUnchanged) {
           restoredResourcesRef.current = [];
           setRestoredResources([]);
@@ -926,6 +1216,30 @@ function useComposer(sessionId, options = {}) {
         onSent?.(operation.input.text, operation.input);
       };
       const deliver = async (operation) => {
+        if (durableDrafts) {
+          const input = operation.input;
+          if (input.expectedDraftRevision === void 0 || input.clientEventId === void 0 || input.model === void 0 || input.reasoningEffort === void 0 || input.latencyMode === void 0) {
+            throw new ComposerStateError("The durable composer draft is not ready for delivery.");
+          }
+          const result = await client.submitComposerDraft(workspaceId, sessionId, {
+            text: input.text,
+            annotations: input.annotations ?? [],
+            resources: input.resources ?? [],
+            model: input.model,
+            reasoningEffort: input.reasoningEffort,
+            latencyMode: input.latencyMode,
+            expectedDraftRevision: input.expectedDraftRevision,
+            clientEventId: input.clientEventId,
+            delivery: operation.delivery,
+            ...input.controlEtag ? { controlEtag: input.controlEtag } : {},
+            ...input.modelContext ? { modelContext: input.modelContext } : {},
+            ...input.mcpCredentialUpdates ? { mcpCredentialUpdates: input.mcpCredentialUpdates } : {},
+            ...input.connectionAccounts ? { connectionAccounts: input.connectionAccounts } : {},
+            ...input.personalResourceAttachment ? { personalResourceAttachment: input.personalResourceAttachment } : {}
+          });
+          adoptDraftBase(result.draft);
+          return result;
+        }
         if (operation.delivery === "steer") {
           return await client.steerMessage(workspaceId, sessionId, operation.input);
         }
@@ -933,6 +1247,9 @@ function useComposer(sessionId, options = {}) {
         return null;
       };
       if (delivery === "steer") {
+        if (steeringRef.current?.clientEventId !== pending?.input.clientEventId) {
+          steeringOccurredAtRef.current = (/* @__PURE__ */ new Date()).toISOString();
+        }
         setSteering({
           phase: "submitting",
           text: rawText,
@@ -957,7 +1274,20 @@ function useComposer(sessionId, options = {}) {
             ) ?? null;
           } catch (cause) {
             if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-              setError(asError(cause));
+              const problem = asError(cause);
+              setError(problem);
+              if (pending.delivery === "steer") {
+                keepSteering = true;
+                setSteering({
+                  phase: "failed",
+                  text: pending.input.text,
+                  clientEventId: pending.input.clientEventId ?? null,
+                  triggerEventId: null,
+                  turnId: null,
+                  error: "Not confirmed. Retry.",
+                  outcomeUnknown: true
+                });
+              }
             }
             return false;
           }
@@ -965,6 +1295,7 @@ function useComposer(sessionId, options = {}) {
             return false;
           }
           if (acceptedEvent) {
+            if (durableDrafts) await loadDraft(false);
             if (pending.delivery === "steer") {
               keepSteering = true;
               setSteering({
@@ -979,11 +1310,7 @@ function useComposer(sessionId, options = {}) {
             return true;
           }
           if (!pending.canRetry) {
-            setError(
-              new Error(
-                "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again."
-              )
-            );
+            setError(new ComposerReconciliationRequiredError());
             return false;
           }
           try {
@@ -1000,9 +1327,26 @@ function useComposer(sessionId, options = {}) {
               });
             }
           } catch (cause) {
-            if (pending.delivery === "steer") keepSteering = true;
+            const problem = asError(cause);
+            const outcomeUnknown = isOutcomeUnknownError(cause);
+            onDeliveryErrorRef.current?.(problem, pending.input, pending.delivery);
+            if (!outcomeUnknown) {
+              clearPending();
+              keepSteering = false;
+            } else if (pending.delivery === "steer") {
+              keepSteering = true;
+              setSteering({
+                phase: "failed",
+                text: pending.input.text,
+                clientEventId: pending.input.clientEventId ?? null,
+                triggerEventId: null,
+                turnId: null,
+                error: "Not confirmed. Retry.",
+                outcomeUnknown: true
+              });
+            }
             if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-              setError(asError(cause));
+              setError(problem);
             }
             return false;
           }
@@ -1020,8 +1364,10 @@ function useComposer(sessionId, options = {}) {
           return false;
         }
         pendingClientEventId.current ??= generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
         const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
-          ...options.effectiveControl?.controlEtag ? { controlEtag: options.effectiveControl.controlEtag } : {},
+          ...currentPolicy,
+          ...effectiveControl?.controlEtag ? { controlEtag: effectiveControl.controlEtag } : {},
           ...durableDrafts && draftRef.current ? { expectedDraftRevision: draftRef.current.revision } : {},
           resources: mergeResources(restoredResources, extras.resources ?? []),
           annotations: cloneAnnotations(annotationsAtSend)
@@ -1035,7 +1381,8 @@ function useComposer(sessionId, options = {}) {
           newerShadow: {
             text: draftAtSend,
             resources: mergeResources(restoredResources, extras.resources ?? []),
-            annotations: cloneAnnotations(annotationsAtSend)
+            annotations: cloneAnnotations(annotationsAtSend),
+            policy: currentPolicy
           },
           clearDraftOnAccept: explicit === void 0,
           canRetry: true
@@ -1065,10 +1412,20 @@ function useComposer(sessionId, options = {}) {
             });
           }
         } catch (cause) {
+          onDeliveryErrorRef.current?.(asError(cause), operation.input, operation.delivery);
           if (!isOutcomeUnknownError(cause)) {
             clearPending();
           } else if (delivery === "steer") {
             keepSteering = true;
+            setSteering({
+              phase: "failed",
+              text: operation.input.text,
+              clientEventId: operation.input.clientEventId ?? null,
+              triggerEventId: null,
+              turnId: null,
+              error: "Not confirmed. Retry.",
+              outcomeUnknown: true
+            });
           }
           if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
             setError(asError(cause));
@@ -1092,15 +1449,16 @@ function useComposer(sessionId, options = {}) {
       currentDraftPayload,
       durableDrafts,
       onSent,
-      options.effectiveControl?.controlEtag,
       persistPayload,
       restoredResources,
       annotations,
+      adoptDraftBase,
       sending,
       sessionId,
       targetKey,
       value,
-      workspaceId
+      workspaceId,
+      loadDraft
     ]
   );
   const send = useCallback(
@@ -1110,6 +1468,7 @@ function useComposer(sessionId, options = {}) {
       }
       const rawText = explicit ?? valueRef.current;
       const annotationsAtSend = cloneAnnotations(annotationsRef.current);
+      const currentPolicy = policyRef.current;
       const hasText = rawText.trim().length > 0;
       const hasAnnotations = annotationsAtSend.length > 0;
       const annotationsComplete2 = annotationsAtSend.every(
@@ -1117,19 +1476,26 @@ function useComposer(sessionId, options = {}) {
       );
       const extras = resolveSendExtras(sendExtrasRef.current);
       const resources = mergeResources(restoredResourcesRef.current, extras.resources ?? []);
-      if (!sessionId || sending || !annotationsComplete2 || !hasText && !hasAnnotations && resources.length === 0 || sendBlockedRef.current?.() === true || targetKeyRef.current !== targetKey) {
+      if (!sessionId || !currentPolicy || sending || !annotationsComplete2 || !hasText && !hasAnnotations && resources.length === 0 || sendBlockedRef.current?.() === true || targetKeyRef.current !== targetKey) {
         return false;
       }
       const sendText = hasText ? rawText : hasAnnotations ? "" : FILE_ONLY_MESSAGE_TEXT;
       const clientEventId = generateClientEventId();
+      const effectiveControl = effectiveControlRef.current;
       const input = composeSendInput(sendText, clientEventId, extras, {
-        ...options.effectiveControl?.controlEtag ? { controlEtag: options.effectiveControl.controlEtag } : {},
+        ...currentPolicy,
+        ...effectiveControl?.controlEtag ? { controlEtag: effectiveControl.controlEtag } : {},
         resources,
         annotations: annotationsAtSend
       });
       const currentPayload = currentDraftPayload();
+      const hasEarlierUnsettledSend = optimisticSendsRef.current.some(
+        (candidate) => candidate.state !== "failed" || candidate.outcomeUnknown === true
+      );
       const operation = {
         clientEventId,
+        delivery: "send",
+        destination: effectiveControl?.state === "paused" || hasEarlierUnsettledSend ? "queue" : sendDestinationRef.current?.() ?? "chat",
         text: sendText,
         annotations: annotationsAtSend,
         resources,
@@ -1140,14 +1506,11 @@ function useComposer(sessionId, options = {}) {
         newerShadow: {
           text: explicit === void 0 ? "" : valueRef.current,
           resources: explicit === void 0 ? [] : [...restoredResourcesRef.current],
-          annotations: explicit === void 0 ? [] : cloneAnnotations(annotationsRef.current)
+          annotations: explicit === void 0 ? [] : cloneAnnotations(annotationsRef.current),
+          policy: currentPolicy
         },
         canRetry: true
       };
-      replaceOptimisticSends((current) => [...current, operation]);
-      queueMicrotask(processOptimisticSends);
-      setError(null);
-      onSubmitted?.(sendText, input);
       if (explicit === void 0) {
         valueRef.current = "";
         annotationsRef.current = [];
@@ -1158,13 +1521,16 @@ function useComposer(sessionId, options = {}) {
         setAnnotationReviewTargetId(null);
         setRestoredResources([]);
       }
+      replaceOptimisticSends((current) => [...current, operation]);
+      queueMicrotask(processOptimisticSends);
+      setError(null);
+      onSubmitted?.(sendText, input);
       return true;
     },
     [
       currentDraftPayload,
       dispatch,
       onSubmitted,
-      options.effectiveControl?.controlEtag,
       processOptimisticSends,
       replaceOptimisticSends,
       sending,
@@ -1175,6 +1541,12 @@ function useComposer(sessionId, options = {}) {
   const steer = useCallback(async (text) => await dispatch("steer", text), [dispatch]);
   const retryOptimisticMessage = useCallback(
     (clientEventId) => {
+      if (sendBlockedRef.current?.() === true) return;
+      const currentSteering = steeringRef.current;
+      if (currentSteering?.phase === "failed" && currentSteering.clientEventId === clientEventId) {
+        void dispatch("steer");
+        return;
+      }
       replaceOptimisticSends(
         (current) => current.map((operation) => {
           if (operation.clientEventId !== clientEventId || operation.state !== "failed") {
@@ -1183,26 +1555,33 @@ function useComposer(sessionId, options = {}) {
           if (operation.outcomeUnknown) {
             return { ...operation, state: "sending", error: void 0 };
           }
+          if (operation.retryable === false) return operation;
           const nextClientEventId = generateClientEventId();
-          const retryExtras = resolveSendExtras(sendExtrasRef.current);
-          const retryInput = composeSendInput(operation.text, nextClientEventId, retryExtras, {
-            ...options.effectiveControl?.controlEtag ? { controlEtag: options.effectiveControl.controlEtag } : {},
-            resources: operation.resources,
-            annotations: operation.annotations
-          });
+          const currentPersonalResourceAttachment = resolveSendExtras(
+            sendExtrasRef.current
+          ).personalResourceAttachment;
+          const retryInput = composeSendInput(
+            operation.text,
+            nextClientEventId,
+            {
+              ...operation.input,
+              ...currentPersonalResourceAttachment ? { personalResourceAttachment: currentPersonalResourceAttachment } : {}
+            },
+            {
+              ...effectiveControlRef.current?.controlEtag ? { controlEtag: effectiveControlRef.current.controlEtag } : {},
+              resources: operation.resources,
+              annotations: operation.annotations
+            }
+          );
           return {
             ...operation,
             clientEventId: nextClientEventId,
             input: retryInput,
-            draftPayload: operation.draftPayload ? {
-              ...operation.draftPayload,
-              model: retryExtras.model ?? operation.draftPayload.model,
-              reasoningEffort: retryExtras.reasoningEffort ?? operation.draftPayload.reasoningEffort,
-              latencyMode: retryExtras.latencyMode ?? operation.draftPayload.latencyMode
-            } : null,
+            draftPayload: operation.draftPayload,
             occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
             state: "sending",
             error: void 0,
+            retryable: void 0,
             outcomeUnknown: false,
             canRetry: true
           };
@@ -1210,15 +1589,23 @@ function useComposer(sessionId, options = {}) {
       );
       queueMicrotask(processOptimisticSends);
     },
-    [options.effectiveControl?.controlEtag, processOptimisticSends, replaceOptimisticSends]
+    [dispatch, processOptimisticSends, replaceOptimisticSends]
   );
   const removeOptimisticMessage = useCallback(
     (clientEventId) => {
+      if (steeringRef.current?.clientEventId === clientEventId) {
+        pendingOperationRef.current = null;
+        pendingClientEventId.current = null;
+        forgetPendingComposerOperation(pendingComposerOperationKey(workspaceId, sessionId));
+        setSteering(null);
+        setError(null);
+        return;
+      }
       replaceOptimisticSends(
         (current) => current.filter((operation) => operation.clientEventId !== clientEventId)
       );
     },
-    [replaceOptimisticSends]
+    [replaceOptimisticSends, sessionId, workspaceId]
   );
   const hasReadyResources = restoredResources.length > 0 || (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
   const hasPendingOperation = pendingOperationRef.current !== null;
@@ -1233,21 +1620,21 @@ function useComposer(sessionId, options = {}) {
       setPausing(true);
       setError(null);
       try {
-        const result = await client.pauseSession(workspaceId, sessionId, {
-          ...reason !== void 0 ? { reason } : {},
-          ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
-        });
+        const clientEventId = generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
+        const result = await replayOutcomeUnknown(
+          () => client.pauseSession(workspaceId, sessionId, {
+            clientEventId,
+            ...reason !== void 0 ? { reason } : {},
+            ...effectiveControl?.controlEtag ? { expectedControlEtag: effectiveControl.controlEtag } : {}
+          })
+        );
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-          setControlStopping(
-            result.interruptionCount > 0 && result.effectiveControl.state === "paused" && result.effectiveControl.settlement !== null ? {
-              controlVersion: result.effectiveControl.controlVersion,
-              controlEtag: result.effectiveControl.controlEtag
-            } : null
-          );
+          setAcceptedControl(result.effectiveControl);
         }
       } catch (cause) {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
         }
       } finally {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
@@ -1255,7 +1642,7 @@ function useComposer(sessionId, options = {}) {
         }
       }
     },
-    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag, targetKey]
+    [client, workspaceId, sessionId, pausing, targetKey]
   );
   const resume = useCallback(
     async (reason) => {
@@ -1265,13 +1652,21 @@ function useComposer(sessionId, options = {}) {
       setResuming(true);
       setError(null);
       try {
-        await client.resumeSession(workspaceId, sessionId, {
-          ...reason !== void 0 ? { reason } : {},
-          ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
-        });
+        const clientEventId = generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
+        const result = await replayOutcomeUnknown(
+          () => client.resumeSession(workspaceId, sessionId, {
+            clientEventId,
+            ...reason !== void 0 ? { reason } : {},
+            ...effectiveControl?.controlEtag ? { expectedControlEtag: effectiveControl.controlEtag } : {}
+          })
+        );
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setAcceptedControl(result.effectiveControl);
+        }
       } catch (cause) {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
         }
       } finally {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
@@ -1279,7 +1674,7 @@ function useComposer(sessionId, options = {}) {
         }
       }
     },
-    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag, targetKey]
+    [client, workspaceId, sessionId, resuming, targetKey]
   );
   const resumeScope = useCallback(
     async (option) => {
@@ -1290,31 +1685,44 @@ function useComposer(sessionId, options = {}) {
       setError(null);
       try {
         if (option.scope === "workspace") {
-          const workspaceBlocker = options.effectiveControl?.blockers.find(
+          const workspaceBlocker = effectiveControlRef.current?.blockers.find(
             (blocker) => blocker.kind === "workspace"
           );
           if (!client.setWorkspaceInferenceState) {
-            throw new Error(
-              "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState."
-            );
+            throw new ComposerWorkspaceControlUnavailableError();
           }
-          await client.setWorkspaceInferenceState(workspaceId, {
-            action: "resume",
-            clientEventId: generateClientEventId(),
-            ...workspaceBlocker ? { expectedRevision: workspaceBlocker.revision } : {}
-          });
+          const clientEventId = generateClientEventId();
+          await replayOutcomeUnknown(
+            () => client.setWorkspaceInferenceState(workspaceId, {
+              action: "resume",
+              clientEventId,
+              ...workspaceBlocker ? { expectedRevision: workspaceBlocker.revision } : {}
+            })
+          );
         } 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
-          });
+          const clientEventId = generateClientEventId();
+          await replayOutcomeUnknown(
+            () => client.resumeSession(workspaceId, option.targetId, {
+              clientEventId,
+              expectedControlEtag: target.effectiveControl.controlEtag
+            })
+          );
         } else {
-          await client.resumeSession(workspaceId, sessionId, {
-            ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
-          });
+          const clientEventId = generateClientEventId();
+          const effectiveControl = effectiveControlRef.current;
+          const result = await replayOutcomeUnknown(
+            () => client.resumeSession(workspaceId, sessionId, {
+              clientEventId,
+              ...effectiveControl?.controlEtag ? { expectedControlEtag: effectiveControl.controlEtag } : {}
+            })
+          );
+          if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+            setAcceptedControl(result.effectiveControl);
+          }
         }
       } catch (cause) {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
@@ -1326,7 +1734,7 @@ function useComposer(sessionId, options = {}) {
         }
       }
     },
-    [client, options.effectiveControl, resuming, sessionId, targetKey, workspaceId]
+    [client, resuming, sessionId, targetKey, workspaceId]
   );
   const updateValue = useCallback(
     (next) => {
@@ -1342,7 +1750,8 @@ function useComposer(sessionId, options = {}) {
             restoredResourcesRef.current,
             resolveSendExtras(sendExtrasRef.current).resources ?? []
           ),
-          annotations: annotationsRef.current
+          annotations: annotationsRef.current,
+          policy: policyRef.current ?? void 0
         }
       );
       setOptimisticDraftShadow({
@@ -1351,7 +1760,8 @@ function useComposer(sessionId, options = {}) {
           restoredResourcesRef.current,
           resolveSendExtras(sendExtrasRef.current).resources ?? []
         ),
-        annotations: annotationsRef.current
+        annotations: annotationsRef.current,
+        policy: policyRef.current ?? void 0
       });
       setValue(next);
     },
@@ -1371,7 +1781,8 @@ function useComposer(sessionId, options = {}) {
             restoredResourcesRef.current,
             resolveSendExtras(sendExtrasRef.current).resources ?? []
           ),
-          annotations: next
+          annotations: next,
+          policy: policyRef.current ?? void 0
         }
       );
       setOptimisticDraftShadow({
@@ -1380,7 +1791,8 @@ function useComposer(sessionId, options = {}) {
           restoredResourcesRef.current,
           resolveSendExtras(sendExtrasRef.current).resources ?? []
         ),
-        annotations: next
+        annotations: next,
+        policy: policyRef.current ?? void 0
       });
       setAnnotations(next);
       setAnnotationReviewTargetId(reviewTargetId);
@@ -1390,7 +1802,7 @@ function useComposer(sessionId, options = {}) {
   const addAnnotation = useCallback(
     (annotation) => {
       if (annotationsRef.current.length >= 12) {
-        setError(new Error("A message can include at most 12 timeline annotations."));
+        setError(new ComposerStateError("A message can include at most 12 timeline annotations."));
         return;
       }
       const next = [...annotationsRef.current, annotation];
@@ -1417,6 +1829,64 @@ function useComposer(sessionId, options = {}) {
   const clearAnnotationReviewTarget = useCallback(() => {
     setAnnotationReviewTargetId(null);
   }, []);
+  const requestAnnotationReview = useCallback((id) => {
+    const current = annotationsRef.current;
+    if (current.length === 0) {
+      setAnnotationReviewTargetId(null);
+      return;
+    }
+    if (id && current.some((annotation) => annotation.id === id)) {
+      setAnnotationReviewTargetId(id);
+      return;
+    }
+    const incomplete = current.find((annotation) => annotation.note.trim().length === 0);
+    setAnnotationReviewTargetId(incomplete?.id ?? current[0].id);
+  }, []);
+  const updatePolicy = useCallback(
+    (next) => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      policyRef.current = next;
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: annotationsRef.current,
+        policy: next
+      };
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        shadow
+      );
+      setOptimisticDraftShadow(shadow);
+      setPolicy(next);
+    },
+    [pendingOperationKey, setOptimisticDraftShadow, targetKey]
+  );
+  const updateModel = useCallback(
+    (model) => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, model });
+    },
+    [updatePolicy]
+  );
+  const updateReasoningEffort = useCallback(
+    (reasoningEffort) => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, reasoningEffort });
+    },
+    [updatePolicy]
+  );
+  const updateLatencyMode = useCallback(
+    (latencyMode) => {
+      const current = policyRef.current;
+      if (current) updatePolicy({ ...current, latencyMode });
+    },
+    [updatePolicy]
+  );
   const removeRestoredResource = useCallback(
     (index) => {
       if (targetKeyRef.current !== targetKey) return;
@@ -1429,13 +1899,15 @@ function useComposer(sessionId, options = {}) {
         {
           text: valueRef.current,
           resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
-          annotations: annotationsRef.current
+          annotations: annotationsRef.current,
+          policy: policyRef.current ?? void 0
         }
       );
       setOptimisticDraftShadow({
         text: valueRef.current,
         resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
-        annotations: annotationsRef.current
+        annotations: annotationsRef.current,
+        policy: policyRef.current ?? void 0
       });
       setRestoredResources(next);
     },
@@ -1446,6 +1918,34 @@ function useComposer(sessionId, options = {}) {
     const extras = resolveSendExtras(sendExtrasRef.current);
     return valueRef.current.length > 0 || annotationsRef.current.length > 0 || restoredResourcesRef.current.length > 0 || (extras.resources?.length ?? 0) > 0 || current?.sourceTurnId !== null && current?.sourceTurnId !== void 0;
   }, []);
+  const restoreOptimisticMessage = useCallback(
+    (clientEventId) => {
+      if (targetKeyRef.current !== targetKey || draftLoading || pendingOperationRef.current || hasDraftContent())
+        return;
+      const operation = optimisticSendsRef.current.find(
+        (candidate) => candidate.clientEventId === clientEventId
+      );
+      if (!operation || operation.state !== "failed" || operation.outcomeUnknown) return;
+      localEditRevision.current += 1;
+      valueRef.current = operation.text;
+      restoredResourcesRef.current = [...operation.resources];
+      annotationsRef.current = cloneAnnotations(operation.annotations);
+      setValue(operation.text);
+      setRestoredResources(restoredResourcesRef.current);
+      setAnnotations(annotationsRef.current);
+      setError(null);
+      setOptimisticDraftShadow({
+        text: operation.text,
+        resources: restoredResourcesRef.current,
+        annotations: annotationsRef.current,
+        policy: policyRef.current ?? void 0
+      });
+      replaceOptimisticSends(
+        (current) => current.filter((candidate) => candidate.clientEventId !== clientEventId)
+      );
+    },
+    [draftLoading, hasDraftContent, replaceOptimisticSends, setOptimisticDraftShadow, targetKey]
+  );
   const resolveDraftConflict = useCallback(
     async (choice) => {
       const ownedTargetKey = targetKey;
@@ -1480,14 +1980,37 @@ function useComposer(sessionId, options = {}) {
   );
   const identityMatches = stateTargetKey === targetKey;
   const visibleSteering = identityMatches ? steering : null;
+  const visibleOptimisticMessages = identityMatches ? [
+    ...optimisticSends.map(
+      ({ input: _input, draftPayload: _payload, canRetry: _retry, ...item }) => item
+    ),
+    ...visibleSteering?.clientEventId ? [
+      {
+        clientEventId: visibleSteering.clientEventId,
+        delivery: "steer",
+        destination: "chat",
+        text: visibleSteering.text,
+        annotations: pendingOperationRef.current?.delivery === "steer" ? pendingOperationRef.current.annotationsAtSend : [],
+        resources: pendingOperationRef.current?.delivery === "steer" ? pendingOperationRef.current.resourcesAtSend : [],
+        occurredAt: steeringOccurredAtRef.current,
+        state: visibleSteering.phase === "submitting" ? "sending" : visibleSteering.phase === "failed" ? "failed" : "queued",
+        turnId: visibleSteering.turnId,
+        triggerEventId: visibleSteering.triggerEventId,
+        ...visibleSteering.error ? { error: visibleSteering.error } : {},
+        ...visibleSteering.outcomeUnknown !== void 0 ? { outcomeUnknown: visibleSteering.outcomeUnknown } : {}
+      }
+    ] : []
+  ] : [];
   const reloadDraft = useCallback(async () => await loadDraft(true), [loadDraft]);
   const clearError = useCallback(() => {
     if (targetKeyRef.current !== targetKey) return;
     setError(null);
+    setDraftReadError(null);
     setDraftConflict(null);
   }, [targetKey]);
+  const visibleValue = identityMatches ? valueRef.current : "";
   return {
-    value: identityMatches ? value : "",
+    value: visibleValue,
     setValue: updateValue,
     annotations: identityMatches ? annotations : [],
     addAnnotation,
@@ -1495,35 +2018,40 @@ function useComposer(sessionId, options = {}) {
     removeAnnotation,
     annotationReviewTargetId: identityMatches ? annotationReviewTargetId : null,
     clearAnnotationReviewTarget,
+    requestAnnotationReview,
     hasDraftContent,
     send,
-    optimisticMessages: identityMatches ? optimisticSends.map(
-      ({ input: _input, draftPayload: _payload, canRetry: _retry, ...item }) => item
-    ) : [],
+    optimisticMessages: visibleOptimisticMessages,
     retryOptimisticMessage,
+    restoreOptimisticMessage: !draftLoading && !pendingOperationRef.current && !hasDraftContent() ? restoreOptimisticMessage : void 0,
     removeOptimisticMessage,
     steer,
     steering: visibleSteering,
-    stoppingAttempt: identityMatches ? controlStopping ? "current" : visibleSteering?.phase === "accepted" && visibleSteering.stoppingPreviousAttempt === true ? "previous" : null : null,
+    stoppingAttempt: identityMatches ? visibleSteering?.phase === "accepted" && visibleSteering.stoppingPreviousAttempt === true ? "previous" : null : null,
     sending: identityMatches ? sending : false,
-    canSend: identityMatches && Boolean(sessionId) && !sending && sendBlockedRef.current?.() !== true && annotationsComplete && (hasPendingOperation || value.trim().length > 0 || hasReadyResources || annotations.length > 0),
+    canSend: identityMatches && Boolean(sessionId) && !sending && !draftLoading && policy !== null && sendBlockedRef.current?.() !== true && annotationsComplete && (hasPendingOperation || visibleValue.trim().length > 0 || hasReadyResources || annotations.length > 0),
     pause,
     pausing: identityMatches ? pausing : false,
     resume,
     resumeScope,
     resuming: identityMatches ? resuming : false,
+    effectiveControl: identityMatches ? effectiveControlRef.current : null,
     draft: identityMatches ? draft : null,
     draftRevision: identityMatches ? draft?.revision ?? 0 : 0,
     draftLoading: identityMatches ? draftLoading : Boolean(sessionId) && durableDrafts,
     draftSaving: identityMatches ? draftSaving : false,
     draftConflict: identityMatches ? draftConflict : null,
+    policy: identityMatches ? policy : null,
+    setModel: updateModel,
+    setReasoningEffort: updateReasoningEffort,
+    setLatencyMode: updateLatencyMode,
     draftPersistence: durableDrafts ? "durable" : "disabled",
     applyDraft,
     reloadDraft,
     resolveDraftConflict,
     restoredResources: identityMatches ? restoredResources : [],
     removeRestoredResource,
-    error: identityMatches ? error : null,
+    error: identityMatches ? error ?? draftReadError : null,
     clearError
   };
 }
@@ -1552,31 +2080,27 @@ function generateClientEventId() {
 function isOutcomeUnknownError(cause) {
   return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
 }
+async function replayOutcomeUnknown(command) {
+  try {
+    return await command();
+  } catch (cause) {
+    if (!isOutcomeUnknownError(cause)) throw cause;
+    return await command();
+  }
+}
 function asError(cause) {
-  return cause instanceof Error ? cause : new Error(String(cause));
+  return normalizeError(cause);
 }
-function isDraftConflictError(error) {
-  const apiError = error;
-  if (apiError.status !== 409 || apiError.outcomeUnknown === true) return false;
-  const code = apiError.code;
-  if (code === void 0 || code === "DRAFT_CHANGED" || code === "conflict" || code === "idempotency_conflict") {
-    return true;
+function promptRoutingFromAcceptedEvent(event) {
+  if (typeof event?.payload !== "object" || event.payload === null || Array.isArray(event.payload)) {
+    return null;
   }
-  return /draft changed/i.test(error.message);
+  const routing = event.payload.routing;
+  return routing === "accepted_for_execution" || routing === "queued_for_execution" || routing === "accepted_for_steering" ? routing : null;
 }
-async function saveComposerDraftWithStaleRetry(input) {
-  try {
-    return await input.client.saveComposerDraft(input.workspaceId, input.sessionId, input.request);
-  } catch (cause) {
-    const problem = asError(cause);
-    if (!isDraftConflictError(problem)) throw problem;
-    const remote = await input.client.getComposerDraft(input.workspaceId, input.sessionId);
-    input.onAdoptRemote(remote);
-    return await input.client.saveComposerDraft(input.workspaceId, input.sessionId, {
-      ...input.request,
-      expectedRevision: remote.revision
-    });
-  }
+function isDraftConflictError(error) {
+  const apiError = error;
+  return apiError.status === 409 && apiError.outcomeUnknown !== true && apiError.code === "DRAFT_CHANGED";
 }
 function draftPayload(draft) {
   return {
@@ -1586,18 +2110,25 @@ function draftPayload(draft) {
     annotations: draft.annotations ?? [],
     model: draft.model,
     reasoningEffort: draft.reasoningEffort,
-    latencyMode: draft.latencyMode ?? "standard"
+    latencyMode: draft.latencyMode
+  };
+}
+function policyFromDraft(draft) {
+  return {
+    model: draft.model,
+    reasoningEffort: draft.reasoningEffort,
+    latencyMode: draft.latencyMode
   };
 }
-function composerDraftPayload(base, text, restoredResources, annotations, extras) {
+function composerDraftPayload(base, text, restoredResources, annotations, policy, additionalResources) {
   return {
     expectedRevision: base.revision,
     text,
-    resources: mergeResources(restoredResources, extras.resources ?? []),
+    resources: mergeResources(restoredResources, additionalResources),
     annotations,
-    model: extras.model ?? base.model,
-    reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort,
-    latencyMode: extras.latencyMode ?? base.latencyMode ?? "standard"
+    model: policy.model,
+    reasoningEffort: policy.reasoningEffort,
+    latencyMode: policy.latencyMode
   };
 }
 function draftSignature(payload) {
@@ -1621,4 +2152,4 @@ export {
   shouldSubmitOnKey,
   shouldSteerOnKey
 };
-//# sourceMappingURL=chunk-IGC6A2ZI.js.map
+//# sourceMappingURL=chunk-Q5QBEZIQ.js.map