@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-MIHN76LX.js

@@ -0,0 +1,2656 @@
+"use client";
+import {
+  useSessionEventTrigger
+} from "./chunk-RV3O5OCQ.js";
+import {
+  normalizeError,
+  useErrorMessage
+} from "./chunk-CM7LVUKC.js";
+import {
+  COMPOSER_ACCOUNT_UNAVAILABLE_MESSAGE,
+  COMPOSER_MODEL_UNAVAILABLE_MESSAGE,
+  ComposerReconciliationRequiredError,
+  ComposerStateError,
+  ComposerWorkspaceControlUnavailableError,
+  composerSubmissionCanRetry,
+  composerSubmissionErrorMessage
+} from "./chunk-5MOJZORA.js";
+import {
+  TRANSIENT_RECONNECT_INTERVAL_MS,
+  isActionFailure,
+  isCalmServiceFailure,
+  isTransientServiceFailure,
+  markActionFailure
+} from "./chunk-5AIMVW6Y.js";
+import {
+  useEmbeddedSession
+} from "./chunk-TVQCDDSZ.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/hooks/use-composer.ts
+import {
+  DEFAULT_FILE_RESOURCE_MOUNT_ROOT,
+  OpenGeniApiError,
+  isMaintenanceError
+} from "@opengeni/sdk";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+
+// src/lib/notify-observer.ts
+function notifyObserver(observer, ...args) {
+  const report = (cause) => globalThis.reportError?.(cause);
+  try {
+    const result = observer?.(...args);
+    if (result && typeof result.then === "function") {
+      void Promise.resolve(result).catch(report);
+    }
+  } catch (cause) {
+    report(cause);
+  }
+}
+
+// src/hooks/use-composer.ts
+function initialComposerShadow(seed) {
+  if (!seed || !seed.text && !seed.resources?.length && !seed.annotations?.length && !seed.policy)
+    return void 0;
+  return {
+    text: seed.text,
+    resources: [...seed.resources ?? []],
+    annotations: cloneAnnotations(seed.annotations ?? []),
+    ...seed.policy ? { policy: { ...seed.policy } } : {}
+  };
+}
+var PENDING_COMPOSER_STORAGE_PREFIX = "opengeni.pending-composer.v1:";
+var OPTIMISTIC_SEND_STORAGE_PREFIX = "opengeni.optimistic-sends.v1:";
+var pendingComposerOperations = /* @__PURE__ */ new Map();
+var optimisticSendOperations = /* @__PURE__ */ new Map();
+function pendingComposerOperationKey(workspaceId, sessionId) {
+  return sessionId ? `${workspaceId}\0${sessionId}` : null;
+}
+function pendingComposerStorage() {
+  try {
+    return typeof window === "undefined" ? null : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function pendingComposerStorageKey(key) {
+  return `${PENDING_COMPOSER_STORAGE_PREFIX}${encodeURIComponent(key)}`;
+}
+function optimisticSendStorageKey(key) {
+  return `${OPTIMISTIC_SEND_STORAGE_PREFIX}${encodeURIComponent(key)}`;
+}
+function restoreOptimisticSendOperations(t, key, canBuyCredits = true) {
+  if (!key) return [];
+  let stored = optimisticSendOperations.get(key);
+  if (!stored) {
+    const storage = pendingComposerStorage();
+    try {
+      const parsed = JSON.parse(storage?.getItem(optimisticSendStorageKey(key)) ?? "[]");
+      stored = Array.isArray(parsed) ? parsed.filter(
+        (candidate) => typeof candidate === "object" && candidate !== null && typeof candidate.clientEventId === "string" && typeof candidate.text === "string" && typeof candidate.occurredAt === "string" && (candidate.state === "sending" || candidate.state === "failed") && typeof candidate.input === "object" && candidate.input !== null && typeof candidate.input.text === "string" && typeof candidate.hasMcpCredentialUpdates === "boolean"
+      ) : [];
+    } catch {
+      stored = [];
+    }
+  }
+  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,
+    correlationId: restoredCorrelationId(operation.correlationId),
+    error: restoredErrorReference(
+      t,
+      operation.correlationId,
+      hasMcpCredentialUpdates && (operation.state === "sending" || operation.outcomeUnknown) ? composerSubmissionErrorMessage(t, new ComposerReconciliationRequiredError()) : operation.state === "sending" ? t("hooks.useComposer.deliveryWasInterruptedRetryTo") : operation.outcomeUnknown ? t("hooks.useComposer.theRequestCouldNotBe") : operation.error ? composerSubmissionErrorMessage(t, new Error(operation.error), canBuyCredits) : 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(t, reference, message) {
+  const correlationId = restoredCorrelationId(reference);
+  return message && correlationId && message !== COMPOSER_MODEL_UNAVAILABLE_MESSAGE && message !== t("lib.format.modelUnavailable") && message !== COMPOSER_ACCOUNT_UNAVAILABLE_MESSAGE && message !== t("lib.format.accountUnavailable") ? t("hooks.useComposer.messageReferenceCorrelationid", { message, correlationId }) : message;
+}
+function rememberOptimisticSendOperations(key, operations) {
+  if (!key) return;
+  const stored = operations.filter((operation) => operation.state !== "queued").map((operation) => {
+    const { canRetry: _canRetry, input, ...rest } = operation;
+    const { mcpCredentialUpdates: _credentials, ...safeInput } = input;
+    return {
+      ...rest,
+      input: safeInput,
+      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));
+  } catch {
+  }
+}
+function resourceList(value) {
+  return Array.isArray(value) && value.every((candidate) => {
+    if (typeof candidate !== "object" || candidate === null) return false;
+    const resource = candidate;
+    return resource.kind === "file" ? typeof resource.fileId === "string" : resource.kind === "repository" && typeof resource.uri === "string" && typeof resource.ref === "string";
+  });
+}
+function timelineAnnotationList(value) {
+  return Array.isArray(value) && value.every((candidate) => {
+    if (typeof candidate !== "object" || candidate === null) return false;
+    const annotation = candidate;
+    const source = annotation.source;
+    if (typeof source !== "object" || source === null) return false;
+    const sourceRecord = source;
+    return typeof annotation.id === "string" && typeof annotation.quote === "string" && typeof annotation.note === "string" && typeof sourceRecord.eventId === "string" && typeof sourceRecord.eventType === "string" && typeof sourceRecord.sequence === "number" && (typeof sourceRecord.turnId === "string" || sourceRecord.turnId === null) && typeof sourceRecord.startOffset === "number" && typeof sourceRecord.endOffset === "number" && typeof sourceRecord.contextBefore === "string" && typeof sourceRecord.contextAfter === "string";
+  });
+}
+function cloneAnnotations(annotations) {
+  return annotations.map((annotation) => ({
+    ...annotation,
+    source: { ...annotation.source }
+  }));
+}
+function readStoredPendingComposerOperation(key) {
+  const storage = key ? pendingComposerStorage() : null;
+  if (!storage || !key) return null;
+  try {
+    const parsed = JSON.parse(storage.getItem(pendingComposerStorageKey(key)) ?? "null");
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const record = parsed;
+    const input = record.input;
+    const shadow = record.newerShadow;
+    if (typeof input !== "object" || input === null || typeof shadow !== "object" || shadow === null) {
+      return null;
+    }
+    const inputRecord = input;
+    const shadowRecord = shadow;
+    if (record.delivery !== "send" && record.delivery !== "steer" || typeof record.draftAtSend !== "string" || !resourceList(record.resourcesAtSend) || record.annotationsAtSend !== void 0 && !timelineAnnotationList(record.annotationsAtSend) || typeof shadowRecord.text !== "string" || !resourceList(shadowRecord.resources) || shadowRecord.annotations !== void 0 && !timelineAnnotationList(shadowRecord.annotations) || 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) || "annotations" in inputRecord && !timelineAnnotationList(inputRecord.annotations)) {
+      return null;
+    }
+    return {
+      ...record,
+      annotationsAtSend: timelineAnnotationList(record.annotationsAtSend) ? record.annotationsAtSend : [],
+      newerShadow: {
+        ...shadow,
+        annotations: timelineAnnotationList(shadowRecord.annotations) ? shadowRecord.annotations : []
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function writePendingComposerOperation(key, operation) {
+  const storage = pendingComposerStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(pendingComposerStorageKey(key), JSON.stringify(operation));
+  } catch {
+  }
+}
+function restorePendingComposerOperation(key) {
+  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,
+      annotations: stored.annotationsAtSend
+    },
+    canRetry: !stored.hasMcpCredentialUpdates
+  };
+}
+function rememberPendingComposerOperation(key, operation) {
+  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 !== void 0,
+    newerShadow: {
+      text: operation.newerShadow.text,
+      resources: [...operation.newerShadow.resources],
+      annotations: cloneAnnotations(operation.newerShadow.annotations),
+      ...operation.newerShadow.policy ? { policy: { ...operation.newerShadow.policy } } : {}
+    }
+  };
+  pendingComposerOperations.set(key, stored);
+  writePendingComposerOperation(key, stored);
+}
+function forgetPendingComposerOperation(key) {
+  if (!key) return;
+  pendingComposerOperations.delete(key);
+  const storage = pendingComposerStorage();
+  if (!storage) return;
+  try {
+    storage.removeItem(pendingComposerStorageKey(key));
+  } catch {
+  }
+}
+function updatePendingComposerShadow(key, operation, shadow) {
+  if (!key || !operation) return operation;
+  const next = {
+    ...operation,
+    newerShadow: {
+      ...shadow,
+      resources: [...shadow.resources],
+      annotations: cloneAnnotations(shadow.annotations)
+    }
+  };
+  rememberPendingComposerOperation(key, next);
+  return next;
+}
+var SERVICE_SEND_RETRY_MAX_DELAY_MS = 8e3;
+var STEERING_SETTLEMENT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "turn.started",
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.superseded"
+]);
+function isSteeringSettlementEvent(event) {
+  return STEERING_SETTLEMENT_EVENT_TYPES.has(event.type);
+}
+function steeringAcceptedEvent(steering, events) {
+  return events.find(
+    (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) => {
+    if (steering.turnId && event.turnId === steering.turnId && isSteeringSettlementEvent(event)) {
+      return true;
+    }
+    if (event.type !== "turn.started" || !acceptedEventId) return false;
+    const payload = event.payload;
+    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 t = useOpenGeniText();
+  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);
+  const initialOptimisticSends = restoreOptimisticSendOperations(
+    t,
+    pendingOperationKey,
+    options.canBuyCredits ?? true
+  );
+  const initialShadow = initialPendingOperation?.newerShadow ?? initialOptimisticSends.at(-1)?.newerShadow ?? initialComposerShadow(options.initialDraft);
+  const [value, setValue] = useState(() => initialShadow?.text ?? "");
+  const [annotations, setAnnotations] = useState(
+    () => initialShadow?.annotations ?? []
+  );
+  const [annotationReviewTargetId, setAnnotationReviewTargetId] = useState(null);
+  const [stateTargetKey, setStateTargetKey] = useState(targetKey);
+  const [sending, setSending] = useState(false);
+  const [optimisticSends, setOptimisticSends] = useState(initialOptimisticSends);
+  const [steering, setSteering] = useState(
+    () => initialPendingOperation?.delivery === "steer" ? {
+      phase: "failed",
+      text: initialPendingOperation.input.text,
+      clientEventId: initialPendingOperation.input.clientEventId ?? null,
+      triggerEventId: null,
+      turnId: null,
+      error: t("hooks.useComposer.notConfirmedRetryToCheck"),
+      outcomeUnknown: true
+    } : null
+  );
+  const [pausing, setPausing] = useState(false);
+  const [acceptedControl, setAcceptedControl] = useState(null);
+  const [resuming, setResuming] = useState(false);
+  const [error, setError] = useState(null);
+  const [draftReadError, setDraftReadError] = useState(null);
+  const [draftHydrationRetrying, setDraftHydrationRetrying] = useState(false);
+  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 ?? []
+  );
+  const pendingOperationRef = useRef(initialPendingOperation);
+  const optimisticSendsRef = useRef(initialOptimisticSends);
+  const optimisticProcessorBusyRef = useRef(false);
+  const serviceWaitRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const serviceRetryTimerRef = useRef(null);
+  const processOptimisticSendsRef = useRef(() => void 0);
+  const [serviceWaiting, setServiceWaiting] = useState(false);
+  const [autosaveRetry, setAutosaveRetry] = useState(0);
+  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 policyPickedRef = useRef(!durableDrafts || initialShadow?.policy !== void 0);
+  const [policyPicked, setPolicyPicked] = useState(policyPickedRef.current);
+  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 = useCallback(
+    (text, input) => {
+      notifyObserver(options.onSent, text, input);
+    },
+    [options.onSent]
+  );
+  const onSubmitted = useCallback(
+    (text, input) => {
+      notifyObserver(options.onSubmitted, text, input);
+    },
+    [options.onSubmitted]
+  );
+  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 busySend = options.busySend ?? "queue";
+  const busySendRef = useRef(busySend);
+  busySendRef.current = busySend;
+  const singleSend = busySend === "steer" && options.offerQueue !== true;
+  const sendBlockedRef = useRef(options.sendBlocked);
+  sendBlockedRef.current = options.sendBlocked;
+  const canBuyCreditsRef = useRef(options.canBuyCredits ?? true);
+  canBuyCreditsRef.current = options.canBuyCredits ?? true;
+  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;
+    pendingOperationRef.current = restorePendingComposerOperation(pendingOperationKey);
+    const restoredOptimisticSends = restoreOptimisticSendOperations(
+      t,
+      pendingOperationKey,
+      canBuyCreditsRef.current
+    );
+    optimisticSendsRef.current = restoredOptimisticSends;
+    optimisticProcessorBusyRef.current = false;
+    serviceWaitRef.current = /* @__PURE__ */ new Map();
+    if (serviceRetryTimerRef.current !== null) clearTimeout(serviceRetryTimerRef.current);
+    serviceRetryTimerRef.current = null;
+    setServiceWaiting(false);
+    optimisticCallbackIdsRef.current = /* @__PURE__ */ new Set();
+    steeringSettlementEventsRef.current = [];
+    pendingClientEventId.current = pendingOperationRef.current?.input.clientEventId ?? null;
+    const shadow = pendingOperationRef.current?.newerShadow ?? restoredOptimisticSends.at(-1)?.newerShadow ?? initialComposerShadow(options.initialDraft);
+    localEditRevision.current = shadow ? 1 : 0;
+    valueRef.current = shadow?.text ?? "";
+    annotationsRef.current = shadow?.annotations ?? [];
+    policyRef.current = shadow?.policy ?? options.initialPolicy ?? null;
+    policyPickedRef.current = !durableDrafts || shadow?.policy !== void 0;
+    setPolicyPicked(policyPickedRef.current);
+    draftRef.current = null;
+    restoredResourcesRef.current = shadow?.resources ?? [];
+    lastSavedSignature.current = null;
+    saveChain.current = Promise.resolve();
+    setStateTargetKey(targetKey);
+    setValue(shadow?.text ?? "");
+    setAnnotations(shadow?.annotations ?? []);
+    setPolicy(policyRef.current);
+    setAnnotationReviewTargetId(null);
+    setSending(false);
+    setOptimisticSends(restoredOptimisticSends);
+    setSteering(
+      pendingOperationRef.current?.delivery === "steer" ? {
+        phase: "failed",
+        text: pendingOperationRef.current.input.text,
+        clientEventId: pendingOperationRef.current.input.clientEventId ?? null,
+        triggerEventId: null,
+        turnId: null,
+        error: t("hooks.useComposer.notConfirmedRetryToCheck"),
+        outcomeUnknown: true
+      } : null
+    );
+    setPausing(false);
+    setAcceptedControl(null);
+    setResuming(false);
+    setError(null);
+    setDraftReadError(null);
+    setDraftHydrationRetrying(false);
+    setDraft(null);
+    setDraftLoading(Boolean(sessionId) && durableDrafts);
+    setDraftSaving(false);
+    setDraftConflict(null);
+    setRestoredResources(shadow?.resources ?? []);
+  }, [
+    durableDrafts,
+    options.initialPolicy,
+    options.initialDraft,
+    pendingOperationKey,
+    sessionId,
+    targetKey,
+    t
+  ]);
+  useEffect(
+    () => () => {
+      if (draftReadRetryRef.current.timer !== null) {
+        clearTimeout(draftReadRetryRef.current.timer);
+      }
+      if (serviceRetryTimerRef.current !== null) clearTimeout(serviceRetryTimerRef.current);
+      serviceRetryTimerRef.current = null;
+      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;
+      const next = optimisticSendsRef.current.map((operation) => ({
+        ...operation,
+        newerShadow: {
+          text: shadow.text,
+          resources: [...shadow.resources],
+          annotations: cloneAnnotations(shadow.annotations),
+          ...shadow.policy ? { policy: { ...shadow.policy } } : {}
+        }
+      }));
+      optimisticSendsRef.current = next;
+      rememberOptimisticSendOperations(pendingOperationKey, next);
+      setOptimisticSends(next);
+    },
+    [pendingOperationKey]
+  );
+  const applyDraft = useCallback(
+    (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,
+          pendingOperationRef.current,
+          {
+            text: next.text,
+            resources: mergeResources(
+              next.resources,
+              resolveSendExtras(sendExtrasRef.current).resources ?? []
+            ),
+            annotations: next.annotations ?? [],
+            policy: nextPolicy2
+          }
+        );
+        setOptimisticDraftShadow({
+          text: next.text,
+          resources: mergeResources(
+            next.resources,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          ),
+          annotations: next.annotations ?? [],
+          policy: nextPolicy2
+        });
+        setDraftConflict(null);
+        return;
+      }
+      const nextPolicy = policyFromDraft(next);
+      valueRef.current = next.text;
+      annotationsRef.current = next.annotations ?? [];
+      policyRef.current = nextPolicy;
+      policyPickedRef.current = !next.policyFollowsSession;
+      setPolicyPicked(policyPickedRef.current);
+      draftRef.current = next;
+      restoredResourcesRef.current = next.resources;
+      lastSavedSignature.current = draftSignature(draftPayload(next));
+      localEditRevision.current += 1;
+      setDraft(next);
+      setValue(next.text);
+      setAnnotations(next.annotations ?? []);
+      setPolicy(nextPolicy);
+      setRestoredResources(next.resources);
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next.text,
+          resources: mergeResources(
+            next.resources,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          ),
+          annotations: next.annotations ?? [],
+          policy: pickedPolicy(policyPickedRef, policyRef)
+        }
+      );
+      setOptimisticDraftShadow({
+        text: next.text,
+        resources: mergeResources(
+          next.resources,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: next.annotations ?? [],
+        policy: pickedPolicy(policyPickedRef, policyRef)
+      });
+      setDraftConflict(null);
+    },
+    [durableDrafts, pendingOperationKey, setOptimisticDraftShadow, targetKey]
+  );
+  const loadDraft = useCallback(
+    async (replaceLocal) => {
+      if (targetKeyRef.current !== targetKey) return;
+      if (!sessionId || !durableDrafts) {
+        setDraftLoading(false);
+        setDraftReadError(null);
+        setDraftHydrationRetrying(false);
+        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 policyAtStart = policyRef.current;
+      const localSignatureAtStart = baseAtStart ? policyAtStart ? draftSignature(
+        composerDraftPayload(
+          baseAtStart,
+          valueRef.current,
+          restoredResourcesRef.current,
+          annotationsRef.current,
+          pickedPolicy(policyPickedRef, policyRef),
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        )
+      ) : 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, {
+          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);
+        setDraftHydrationRetrying(false);
+        const currentRevision = draftRef.current?.revision ?? -1;
+        const adoptFetchedPolicy = () => {
+          const fetchedPolicy = policyFromDraft(fetched);
+          policyPickedRef.current = !fetched.policyFollowsSession;
+          setPolicyPicked(policyPickedRef.current);
+          if (samePolicy(policyRef.current, fetchedPolicy)) return;
+          policyRef.current = fetchedPolicy;
+          setPolicy(fetchedPolicy);
+        };
+        if (replaceLocal || fetched.revision > currentRevision) {
+          draftRef.current = fetched;
+          setDraft(fetched);
+          setDraftConflict(null);
+          const shadow = pendingOperationRef.current?.newerShadow ?? optimisticSendsRef.current.at(-1)?.newerShadow;
+          if (shadow) {
+            valueRef.current = shadow.text;
+            restoredResourcesRef.current = shadow.resources;
+            annotationsRef.current = shadow.annotations;
+            if (shadow.policy) {
+              policyRef.current = shadow.policy;
+              policyPickedRef.current = true;
+              setPolicyPicked(policyPickedRef.current);
+            } else if (!policyPickedRef.current) {
+              adoptFetchedPolicy();
+            }
+            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) {
+            valueRef.current = fetched.text;
+            restoredResourcesRef.current = fetched.resources;
+            annotationsRef.current = fetched.annotations ?? [];
+            policyRef.current = policyFromDraft(fetched);
+            policyPickedRef.current = !fetched.policyFollowsSession;
+            setPolicyPicked(policyPickedRef.current);
+            lastSavedSignature.current = draftSignature(draftPayload(fetched));
+            setValue(fetched.text);
+            setRestoredResources(fetched.resources);
+            setAnnotations(fetched.annotations ?? []);
+            setPolicy(policyRef.current);
+          } else {
+            lastSavedSignature.current = draftSignature(draftPayload(fetched));
+            if (!policyRef.current || !policyPickedRef.current) adoptFetchedPolicy();
+          }
+        } else if (fetched.revision === currentRevision && fetched.policyFollowsSession && !policyPickedRef.current && !samePolicy(policyRef.current, policyFromDraft(fetched))) {
+          draftRef.current = fetched;
+          setDraft(fetched);
+          adoptFetchedPolicy();
+        }
+      } catch (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(t("hooks.useComposer.draftSyncTimedOutRetrying"), { cause }) : problem
+          );
+          if (timedOut || cause instanceof TypeError || cause && typeof cause === "object" && "retryable" in cause && cause.retryable === true) {
+            retry.failures += 1;
+            scheduleRetry();
+            if (draftRef.current === null) setDraftHydrationRetrying(true);
+          } else {
+            if (retry.timer !== null) clearTimeout(retry.timer);
+            retry.failures = 0;
+            retry.timer = null;
+            setDraftHydrationRetrying(false);
+          }
+        }
+      } 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, t]
+  );
+  useEffect(() => {
+    if (!sessionId || !durableDrafts) {
+      setDraftLoading(false);
+      return;
+    }
+    void loadDraft(false);
+  }, [durableDrafts, loadDraft, sessionId]);
+  useEffect(() => {
+    if (!sessionId || !durableDrafts) return;
+    const onWake = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+      void loadDraft(false);
+    };
+    document.addEventListener("visibilitychange", onWake);
+    window.addEventListener("pageshow", onWake);
+    return () => {
+      document.removeEventListener("visibilitychange", onWake);
+      window.removeEventListener("pageshow", onWake);
+    };
+  }, [durableDrafts, loadDraft, sessionId]);
+  useEffect(() => {
+    if (!sessionId || !durableDrafts) return;
+    return registerSessionReconciler(sessionId, "composer", async () => await loadDraft(false));
+  }, [durableDrafts, loadDraft, registerSessionReconciler, sessionId]);
+  const reconcileSteering = useCallback(async () => {
+    if (!sessionId || !steeringRef.current) return;
+    const ownedTargetKey = targetKey;
+    let events;
+    try {
+      events = await client.listEvents(workspaceId, sessionId, {
+        includeTypes: [
+          "user.message",
+          "turn.started",
+          "turn.completed",
+          "turn.failed",
+          "turn.cancelled",
+          "turn.superseded"
+        ],
+        limit: 250,
+        payloadMode: "full"
+      });
+    } catch {
+      return;
+    }
+    if (targetKeyRef.current !== ownedTargetKey) return;
+    setSteering((current) => {
+      if (!current) return current;
+      if (steeringSettledByEvents(current, events)) {
+        steeringSettlementEventsRef.current = [];
+        return null;
+      }
+      const accepted = steeringAcceptedEvent(current, events);
+      if (!accepted || current.triggerEventId) return current;
+      return {
+        ...current,
+        phase: "accepted",
+        triggerEventId: accepted.id
+      };
+    });
+  }, [client, sessionId, targetKey, workspaceId]);
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    (event) => isComposerDraftEvent(event) || isSteeringSettlementEvent(event),
+    (event) => {
+      if (isComposerDraftEvent(event)) void loadDraft(false);
+      if (!isSteeringSettlementEvent(event)) return;
+      steeringSettlementEventsRef.current = [
+        ...steeringSettlementEventsRef.current.slice(-15),
+        event
+      ];
+      setSteering((current) => {
+        if (!current || !steeringSettledByEvents(current, [event])) return current;
+        steeringSettlementEventsRef.current = [];
+        return null;
+      });
+    },
+    {
+      enabled: Boolean(sessionId) && (durableDrafts || steering !== null),
+      ...options.events !== void 0 ? { events: options.events } : {}
+    },
+    reconcileSteering
+  );
+  useEffect(() => {
+    if (!steering) return;
+    const observed = [...options.events ?? [], ...steeringSettlementEventsRef.current];
+    if (!steeringSettledByEvents(steering, observed)) return;
+    steeringSettlementEventsRef.current = [];
+    setSteering(null);
+  }, [options.events, steering]);
+  useEffect(() => {
+    if (!acceptedControl) return;
+    const effectiveControl = options.effectiveControl;
+    if (!effectiveControl || effectiveControl.controlVersion < acceptedControl.controlVersion) {
+      return;
+    }
+    setAcceptedControl((current) => current === acceptedControl ? null : current);
+  }, [acceptedControl, options.effectiveControl]);
+  const pendingAcceptedControl = acceptedControl && (!options.effectiveControl || options.effectiveControl.controlVersion < acceptedControl.controlVersion) ? acceptedControl : null;
+  const currentDraftPayload = useCallback(() => {
+    if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
+    const base = draftRef.current;
+    const currentPolicy = policyRef.current;
+    if (!base || !currentPolicy) return null;
+    return composerDraftPayload(
+      base,
+      value,
+      restoredResources,
+      annotations,
+      pickedPolicy(policyPickedRef, policyRef),
+      resolveSendExtras(sendExtrasRef.current).resources ?? []
+    );
+  }, [annotations, durableDrafts, restoredResources, targetKey, value]);
+  const adoptDraftBase = useCallback(
+    (next) => {
+      if (targetKeyRef.current !== targetKey) return;
+      draftRef.current = next;
+      setDraft(next);
+      const nextPolicy = policyFromDraft(next);
+      if (next.policyFollowsSession) {
+        if (samePolicy(policyRef.current, nextPolicy)) {
+          policyPickedRef.current = false;
+          setPolicyPicked(false);
+        }
+        if (!policyPickedRef.current && !samePolicy(policyRef.current, nextPolicy)) {
+          policyRef.current = nextPolicy;
+          setPolicy(nextPolicy);
+        }
+      }
+      lastSavedSignature.current = draftSignature(draftPayload(next));
+      setDraftConflict(null);
+      setError(null);
+    },
+    [targetKey]
+  );
+  const acquireDraftSlot = useCallback(async () => {
+    let release;
+    const released = new Promise((resolve) => {
+      release = resolve;
+    });
+    const previous = saveChain.current;
+    saveChain.current = previous.then(
+      () => released,
+      () => released
+    );
+    await previous.catch(() => void 0);
+    return release;
+  }, []);
+  const saveDraftInSlot = useCallback(
+    async (payload, owner, onFailure) => {
+      const owned = () => targetKeyRef.current === owner.targetKey && targetGeneration.current === owner.generation;
+      if (!sessionId || !durableDrafts || !owned()) return false;
+      const current = draftRef.current;
+      if (!current) return false;
+      const request = { ...payload, expectedRevision: current.revision };
+      if (draftSignature(request) === lastSavedSignature.current) return true;
+      setDraftSaving(true);
+      try {
+        const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
+        if (!owned()) return false;
+        adoptDraftBase(saved);
+        return true;
+      } catch (cause) {
+        if (owned()) {
+          const problem = asError(cause);
+          if (isDraftConflictError(problem)) setDraftConflict(problem);
+          setError(problem);
+          onFailure?.(problem);
+        }
+        return false;
+      } finally {
+        if (owned()) setDraftSaving(false);
+      }
+    },
+    [adoptDraftBase, client, durableDrafts, sessionId, workspaceId]
+  );
+  const persistPayload = useCallback(
+    async (payload, onFailure) => {
+      const owner = { targetKey, generation: targetGeneration.current };
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== owner.targetKey) {
+        return false;
+      }
+      const release = await acquireDraftSlot();
+      try {
+        return await saveDraftInSlot(payload, owner, onFailure);
+      } finally {
+        release();
+      }
+    },
+    [acquireDraftSlot, durableDrafts, saveDraftInSlot, sessionId, targetKey]
+  );
+  const flushDraft = useCallback(async () => {
+    if (draftLoading || sending || draftConflict) return;
+    const payload = currentDraftPayload();
+    if (!payload || draftSignature(payload) === lastSavedSignature.current) return;
+    await persistPayload(payload);
+  }, [currentDraftPayload, draftConflict, draftLoading, persistPayload, sending]);
+  const replaceOptimisticSends = useCallback(
+    (update) => {
+      const next = update(optimisticSendsRef.current);
+      optimisticSendsRef.current = next;
+      rememberOptimisticSendOperations(pendingOperationKey, next);
+      setOptimisticSends(next);
+      return next;
+    },
+    [pendingOperationKey]
+  );
+  const markOptimisticAccepted = useCallback(
+    (operation) => {
+      if (!optimisticCallbackIdsRef.current.has(operation.clientEventId)) {
+        optimisticCallbackIdsRef.current.add(operation.clientEventId);
+        onSent?.(operation.input.text, operation.input);
+      }
+      replaceOptimisticSends(
+        (current) => current.filter((candidate) => candidate.clientEventId !== operation.clientEventId)
+      );
+    },
+    [onSent, replaceOptimisticSends]
+  );
+  useEffect(() => {
+    const events = options.events ?? [];
+    if (events.length === 0 || optimisticSendsRef.current.length === 0) return;
+    const reconciled = optimisticSendsRef.current.map(
+      (operation) => reconcileOptimisticSendFromEvents(operation, events)
+    );
+    const settledIds = new Set(
+      reconciled.filter((item) => item.settled).map((item) => item.operation.clientEventId)
+    );
+    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;
+    const operationIndex = currentOperations.findIndex(
+      (candidate) => candidate.state === "sending"
+    );
+    const operation = operationIndex < 0 ? void 0 : currentOperations[operationIndex];
+    if (!operation) return;
+    const held = serviceWaitRef.current.get(operation.clientEventId);
+    if (held && held.retryAt > Date.now()) {
+      if (serviceRetryTimerRef.current === null) {
+        serviceRetryTimerRef.current = setTimeout(
+          () => {
+            serviceRetryTimerRef.current = null;
+            processOptimisticSendsRef.current();
+          },
+          Math.max(0, held.retryAt - Date.now())
+        );
+      }
+      return;
+    }
+    const ownedTargetKey = targetKey;
+    const ownedGeneration = targetGeneration.current;
+    optimisticProcessorBusyRef.current = true;
+    void (async () => {
+      let mutationFailureObserved = false;
+      let notSubmitted = false;
+      let holding = false;
+      let releaseDraftSlot = null;
+      const holdForService = (cause, outcomeUnknown) => {
+        if (outcomeUnknown && !operation.canRetry) return false;
+        const now = Date.now();
+        const previous = serviceWaitRef.current.get(operation.clientEventId);
+        const since = isMaintenanceError(cause) ? now : previous?.since ?? now;
+        if (!isCalmServiceFailure(cause, since, now)) return false;
+        const attempts = (previous?.attempts ?? 0) + 1;
+        const delayMs = Math.round(
+          Math.min(SERVICE_SEND_RETRY_MAX_DELAY_MS, 1e3 * 2 ** (attempts - 1)) * (0.8 + Math.random() * 0.4)
+        );
+        serviceWaitRef.current.set(operation.clientEventId, {
+          since,
+          attempts,
+          retryAt: now + delayMs
+        });
+        holding = true;
+        setServiceWaiting(true);
+        replaceOptimisticSends(
+          (current) => current.map(
+            (candidate) => candidate.clientEventId === operation.clientEventId ? { ...candidate, state: "sending", outcomeUnknown } : candidate
+          )
+        );
+        return true;
+      };
+      const markFailed = (cause, outcomeUnknown) => {
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return false;
+        }
+        if (holdForService(cause, outcomeUnknown)) return true;
+        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) ? problem instanceof OpenGeniApiError && problem.correlationId ? t("hooks.useComposer.notConfirmedCheckStatusWithReference", {
+                  reference: problem.correlationId
+                }) : t("hooks.useComposer.notConfirmedCheckStatus") : composerSubmissionErrorMessage(t, problem, canBuyCreditsRef.current)
+              ),
+              retryable: outcomeUnknown || composerSubmissionCanRetry(problem),
+              outcomeUnknown,
+              correlationId: problem instanceof OpenGeniApiError ? problem.correlationId : candidate.correlationId
+            } : candidate
+          )
+        );
+        return false;
+      };
+      try {
+        if (operation.outcomeUnknown) {
+          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) {
+            const wasHeld = serviceWaitRef.current.has(operation.clientEventId);
+            if (!markFailed(cause, true) && wasHeld) {
+              notifyObserver(
+                onDeliveryErrorRef.current,
+                asError(cause),
+                operation.input,
+                "send"
+              );
+            }
+            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 ComposerReconciliationRequiredError();
+          }
+        }
+        let expectedDraftRevision;
+        if (durableDrafts && operation.draftPayload) {
+          releaseDraftSlot = await acquireDraftSlot();
+          let persistFailure = null;
+          if (!await saveDraftInSlot(
+            operation.draftPayload,
+            { targetKey: ownedTargetKey, generation: ownedGeneration },
+            (problem) => {
+              persistFailure = problem;
+            }
+          )) {
+            if (persistFailure && isTransientServiceFailure(persistFailure)) {
+              notSubmitted = true;
+              throw persistFailure;
+            }
+            throw new ComposerStateError(t("hooks.useComposer.theMessageDraftCouldNot"));
+          }
+          expectedDraftRevision = draftRef.current?.revision;
+        }
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return;
+        }
+        const wireInput = {
+          ...operation.input,
+          ...expectedDraftRevision !== void 0 ? { expectedDraftRevision } : {}
+        };
+        let acceptedResult = null;
+        let acceptedEvent = null;
+        if (durableDrafts) {
+          if (!operation.draftPayload || expectedDraftRevision === void 0) {
+            throw new ComposerStateError(t("hooks.useComposer.theDurableComposerDraftIs"));
+          }
+          const result = await client.submitComposerDraft(workspaceId, sessionId, {
+            text: operation.draftPayload.text,
+            annotations: operation.draftPayload.annotations,
+            resources: operation.draftPayload.resources,
+            // Absent while the draft follows the chat's settings.
+            ...operation.draftPayload.model !== void 0 ? { model: operation.draftPayload.model } : {},
+            ...operation.draftPayload.reasoningEffort !== void 0 ? { reasoningEffort: operation.draftPayload.reasoningEffort } : {},
+            ...operation.draftPayload.latencyMode !== void 0 ? { 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);
+          releaseDraftSlot?.();
+        } else {
+          acceptedEvent = await client.sendMessage(workspaceId, sessionId, wireInput).catch((cause) => {
+            mutationFailureObserved = true;
+            throw cause;
+          });
+        }
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return;
+        }
+        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,
+                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
+            )
+          );
+        }
+        if (!optimisticCallbackIdsRef.current.has(operation.clientEventId)) {
+          optimisticCallbackIdsRef.current.add(operation.clientEventId);
+          onSent?.(wireInput.text, wireInput);
+        }
+      } catch (cause) {
+        const current = optimisticSendsRef.current.find(
+          (candidate) => candidate.clientEventId === operation.clientEventId
+        );
+        if (!current || current.state === "queued" && current.outcomeUnknown === false) {
+          return;
+        }
+        const problem = asError(cause);
+        const outcomeUnknown = operation.outcomeUnknown && !mutationFailureObserved ? true : !notSubmitted && isOutcomeUnknownError(cause);
+        if (!markFailed(cause, outcomeUnknown)) {
+          notifyObserver(onDeliveryErrorRef.current, problem, operation.input, "send");
+        }
+      } finally {
+        releaseDraftSlot?.();
+        optimisticProcessorBusyRef.current = false;
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          if (!holding) serviceWaitRef.current.delete(operation.clientEventId);
+          for (const id of serviceWaitRef.current.keys()) {
+            if (!optimisticSendsRef.current.some(
+              (candidate) => candidate.clientEventId === id && candidate.state === "sending"
+            )) {
+              serviceWaitRef.current.delete(id);
+            }
+          }
+          setServiceWaiting(serviceWaitRef.current.size > 0);
+        }
+        if (targetKeyRef.current === ownedTargetKey) {
+          setOptimisticSends([...optimisticSendsRef.current]);
+        }
+      }
+    })();
+  }, [
+    acquireDraftSlot,
+    adoptDraftBase,
+    client,
+    durableDrafts,
+    formatError,
+    markOptimisticAccepted,
+    loadDraft,
+    onSent,
+    options.events,
+    replaceOptimisticSends,
+    saveDraftInSlot,
+    sessionId,
+    targetKey,
+    workspaceId,
+    t
+  ]);
+  processOptimisticSendsRef.current = processOptimisticSends;
+  useEffect(() => {
+    processOptimisticSends();
+  }, [optimisticSends, processOptimisticSends]);
+  useEffect(() => {
+    for (const id of serviceWaitRef.current.keys()) {
+      if (!optimisticSends.some(
+        (candidate) => candidate.clientEventId === id && candidate.state === "sending"
+      )) {
+        serviceWaitRef.current.delete(id);
+      }
+    }
+    setServiceWaiting(serviceWaitRef.current.size > 0);
+  }, [optimisticSends]);
+  useEffect(() => {
+    const pending = pendingOperationRef.current;
+    if (pending) {
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: annotationsRef.current,
+        ...pickedPolicy(policyPickedRef, policyRef) ? { policy: pickedPolicy(policyPickedRef, policyRef) } : {}
+      };
+      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,
+          shadow
+        );
+      }
+      return;
+    }
+    const optimistic = optimisticSendsRef.current.at(-1);
+    if (optimistic) {
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: annotationsRef.current,
+        ...pickedPolicy(policyPickedRef, policyRef) ? { policy: pickedPolicy(policyPickedRef, policyRef) } : {}
+      };
+      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);
+      }
+    }
+    if (optimisticSendsRef.current.some((operation) => operation.state === "sending")) {
+      return;
+    }
+    if (!durableDrafts || !sessionId || draftLoading || sending || !draftRef.current || draftConflict)
+      return;
+    const payload = currentDraftPayload();
+    if (!payload || draftSignature(payload) === lastSavedSignature.current) return;
+    const timer = window.setTimeout(() => void persistPayload(payload), 500);
+    return () => window.clearTimeout(timer);
+  }, [
+    autosaveRetry,
+    currentDraftPayload,
+    durableDrafts,
+    draftConflict,
+    draftLoading,
+    liveExtrasVersion,
+    pendingOperationKey,
+    persistPayload,
+    setOptimisticDraftShadow,
+    sending,
+    sessionId
+  ]);
+  useEffect(() => {
+    if (!error || !sessionId || !isTransientServiceFailure(error) || isActionFailure(error)) {
+      return;
+    }
+    const ownedTargetKey = targetKey;
+    const ownedError = error;
+    let cancelled = false;
+    let inFlight = false;
+    const timer = setInterval(() => {
+      if (inFlight) return;
+      inFlight = true;
+      const probe = durableDrafts ? client.getComposerDraft(workspaceId, sessionId) : client.listEvents(workspaceId, sessionId, { limit: 1, payloadMode: "none" });
+      probe.then(
+        () => {
+          inFlight = false;
+          if (cancelled || targetKeyRef.current !== ownedTargetKey) return;
+          setError((current) => current === ownedError ? null : current);
+          setAutosaveRetry((nonce) => nonce + 1);
+        },
+        () => {
+          inFlight = false;
+        }
+      );
+    }, TRANSIENT_RECONNECT_INTERVAL_MS);
+    return () => {
+      cancelled = true;
+      clearInterval(timer);
+    };
+  }, [client, durableDrafts, error, sessionId, targetKey, workspaceId]);
+  const dispatch = useCallback(
+    async (delivery, explicit) => {
+      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 annotationsAtSend = annotations;
+      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 || !currentPolicy || sending || sendBlockedRef.current?.() === true || targetKeyRef.current !== ownedTargetKey) {
+        return false;
+      }
+      const clearPending = () => {
+        pendingOperationRef.current = null;
+        pendingClientEventId.current = null;
+        forgetPendingComposerOperation(operationKey);
+      };
+      let keepSteering = pending?.delivery === "steer";
+      let releaseDraftSlot = null;
+      const settleAccepted = (operation) => {
+        clearPending();
+        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);
+        if (resourcesWereUnchanged) {
+          restoredResourcesRef.current = [];
+          setRestoredResources([]);
+        }
+        if (annotationsWereUnchanged) {
+          annotationsRef.current = [];
+          setAnnotations([]);
+          setAnnotationReviewTargetId(null);
+        }
+        if (operation.clearDraftOnAccept && draftWasUnchanged) {
+          valueRef.current = "";
+          setValue("");
+        }
+        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) {
+            throw new ComposerStateError(t("hooks.useComposer.theDurableComposerDraftIs"));
+          }
+          const result = await client.submitComposerDraft(workspaceId, sessionId, {
+            text: input.text,
+            annotations: input.annotations ?? [],
+            resources: input.resources ?? [],
+            // Absent while the draft follows the chat's settings.
+            ...input.model ? { model: input.model } : {},
+            ...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {},
+            ...input.latencyMode ? { 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);
+        }
+        await client.sendMessage(workspaceId, sessionId, operation.input);
+        return null;
+      };
+      if (delivery === "steer") {
+        if (steeringRef.current?.clientEventId !== pending?.input.clientEventId) {
+          steeringOccurredAtRef.current = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        setSteering({
+          phase: "submitting",
+          text: rawText,
+          clientEventId: pending?.input.clientEventId ?? pendingClientEventId.current,
+          triggerEventId: null,
+          turnId: null
+        });
+      }
+      setSending(true);
+      setError(null);
+      try {
+        if (pending) {
+          let acceptedEvent = null;
+          try {
+            const events = await client.listEvents(workspaceId, sessionId, {
+              includeTypes: ["user.message"],
+              limit: 100,
+              payloadMode: "none"
+            });
+            acceptedEvent = events.find(
+              (event) => event.type === "user.message" && event.clientEventId === pending.input.clientEventId
+            ) ?? null;
+          } catch (cause) {
+            if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+              const problem = markActionFailure(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: t("hooks.useComposer.notConfirmedRetry"),
+                  outcomeUnknown: true
+                });
+              }
+            }
+            return false;
+          }
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return false;
+          }
+          if (acceptedEvent) {
+            if (durableDrafts) await loadDraft(false);
+            if (pending.delivery === "steer") {
+              keepSteering = true;
+              setSteering({
+                phase: "accepted",
+                text: pending.input.text,
+                clientEventId: pending.input.clientEventId ?? null,
+                triggerEventId: acceptedEvent.id,
+                turnId: null
+              });
+            }
+            settleAccepted(pending);
+            return true;
+          }
+          if (!pending.canRetry) {
+            setError(new ComposerReconciliationRequiredError());
+            return false;
+          }
+          try {
+            if (durableDrafts) releaseDraftSlot = await acquireDraftSlot();
+            const result = await deliver(pending);
+            if (pending.delivery === "steer" && result) {
+              keepSteering = true;
+              setSteering({
+                phase: "accepted",
+                text: pending.input.text,
+                clientEventId: pending.input.clientEventId ?? null,
+                triggerEventId: result.accepted.id,
+                turnId: result.turn.id,
+                stoppingPreviousAttempt: result.replay !== true && (result.interruptionCount ?? 0) > 0
+              });
+            }
+          } catch (cause) {
+            const problem = asError(cause);
+            const outcomeUnknown = isOutcomeUnknownError(cause);
+            notifyObserver(
+              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: t("hooks.useComposer.notConfirmedRetry"),
+                outcomeUnknown: true
+              });
+            }
+            if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+              setError(markActionFailure(problem));
+            }
+            return false;
+          }
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return false;
+          }
+          settleAccepted(pending);
+          return true;
+        }
+        const sendText = hasText ? rawText : hasAnnotations ? "" : FILE_ONLY_MESSAGE_TEXT(t);
+        const currentPayload = currentDraftPayload();
+        const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
+        if (payload) {
+          releaseDraftSlot = await acquireDraftSlot();
+          if (!await saveDraftInSlot(payload, {
+            targetKey: ownedTargetKey,
+            generation: ownedGeneration
+          })) {
+            return false;
+          }
+        }
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return false;
+        }
+        pendingClientEventId.current ??= generateClientEventId();
+        const effectiveControl = effectiveControlRef.current;
+        const input = composeSendInput(sendText, pendingClientEventId.current, extras, {
+          ...pickedPolicy(policyPickedRef, policyRef),
+          ...effectiveControl?.controlEtag ? { controlEtag: effectiveControl.controlEtag } : {},
+          ...durableDrafts && draftRef.current ? { expectedDraftRevision: draftRef.current.revision } : {},
+          resources: mergeResources(restoredResources, extras.resources ?? []),
+          annotations: cloneAnnotations(annotationsAtSend)
+        });
+        const operation = {
+          delivery,
+          input,
+          draftAtSend,
+          resourcesAtSend: [...restoredResources],
+          annotationsAtSend: cloneAnnotations(annotationsAtSend),
+          newerShadow: {
+            text: draftAtSend,
+            resources: mergeResources(restoredResources, extras.resources ?? []),
+            annotations: cloneAnnotations(annotationsAtSend),
+            policy: pickedPolicy(policyPickedRef, policyRef)
+          },
+          clearDraftOnAccept: explicit === void 0,
+          canRetry: true
+        };
+        pendingOperationRef.current = operation;
+        rememberPendingComposerOperation(operationKey, operation);
+        if (delivery === "steer") {
+          setSteering({
+            phase: "submitting",
+            text: sendText,
+            clientEventId: input.clientEventId ?? null,
+            triggerEventId: null,
+            turnId: null
+          });
+        }
+        try {
+          const result = await deliver(operation);
+          if (delivery === "steer" && result) {
+            keepSteering = true;
+            setSteering({
+              phase: "accepted",
+              text: sendText,
+              clientEventId: input.clientEventId ?? null,
+              triggerEventId: result.accepted.id,
+              turnId: result.turn.id,
+              stoppingPreviousAttempt: result.replay !== true && (result.interruptionCount ?? 0) > 0
+            });
+          }
+        } catch (cause) {
+          notifyObserver(
+            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: t("hooks.useComposer.notConfirmedRetry"),
+              outcomeUnknown: true
+            });
+          }
+          if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+            setError(markActionFailure(asError(cause)));
+          }
+          return false;
+        }
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return false;
+        }
+        settleAccepted(operation);
+        return true;
+      } finally {
+        releaseDraftSlot?.();
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setSending(false);
+          if (delivery === "steer" && !keepSteering) setSteering(null);
+        }
+      }
+    },
+    [
+      acquireDraftSlot,
+      client,
+      currentDraftPayload,
+      durableDrafts,
+      onSent,
+      restoredResources,
+      annotations,
+      adoptDraftBase,
+      saveDraftInSlot,
+      sending,
+      sessionId,
+      targetKey,
+      value,
+      workspaceId,
+      loadDraft,
+      t
+    ]
+  );
+  const sendToQueue = useCallback(
+    async (explicit) => {
+      if (pendingOperationRef.current?.delivery === "send") {
+        return await dispatch("send", explicit);
+      }
+      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(
+        (annotation) => annotation.note.trim().length > 0
+      );
+      const extras = resolveSendExtras(sendExtrasRef.current);
+      const resources = mergeResources(restoredResourcesRef.current, extras.resources ?? []);
+      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(t);
+      const clientEventId = generateClientEventId();
+      const effectiveControl = effectiveControlRef.current;
+      const input = composeSendInput(sendText, clientEventId, extras, {
+        ...pickedPolicy(policyPickedRef, policyRef),
+        ...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,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        state: "sending",
+        input,
+        draftPayload: currentPayload ? { ...currentPayload, text: sendText } : null,
+        newerShadow: {
+          text: explicit === void 0 ? "" : valueRef.current,
+          resources: explicit === void 0 ? [] : [...restoredResourcesRef.current],
+          annotations: explicit === void 0 ? [] : cloneAnnotations(annotationsRef.current),
+          policy: pickedPolicy(policyPickedRef, policyRef)
+        },
+        canRetry: true
+      };
+      if (explicit === void 0) {
+        valueRef.current = "";
+        annotationsRef.current = [];
+        restoredResourcesRef.current = [];
+        localEditRevision.current += 1;
+        setValue("");
+        setAnnotations([]);
+        setAnnotationReviewTargetId(null);
+        setRestoredResources([]);
+      }
+      replaceOptimisticSends((current) => [...current, operation]);
+      queueMicrotask(processOptimisticSends);
+      setError(null);
+      onSubmitted?.(sendText, input);
+      return true;
+    },
+    [
+      currentDraftPayload,
+      dispatch,
+      onSubmitted,
+      processOptimisticSends,
+      replaceOptimisticSends,
+      sending,
+      sessionId,
+      targetKey,
+      t
+    ]
+  );
+  const steer = useCallback(async (text) => await dispatch("steer", text), [dispatch]);
+  const takesBusyPath = useCallback(
+    () => effectiveControlRef.current?.state !== "paused" && sendDestinationRef.current?.() === "queue",
+    []
+  );
+  const send = useCallback(
+    async (explicit) => {
+      if (busySendRef.current === "steer" && pendingOperationRef.current?.delivery !== "send" && takesBusyPath()) {
+        return await steer(explicit);
+      }
+      return await sendToQueue(explicit);
+    },
+    [sendToQueue, steer, takesBusyPath]
+  );
+  const sendAlternate = useCallback(
+    async (explicit) => busySendRef.current === "steer" ? await sendToQueue(explicit) : await steer(explicit),
+    [sendToQueue, steer]
+  );
+  const alternateSend = !singleSend && takesBusyPath() ? busySend === "steer" ? "queue" : "steer" : null;
+  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") {
+            return operation;
+          }
+          if (operation.outcomeUnknown) {
+            return { ...operation, state: "sending", error: void 0 };
+          }
+          if (operation.retryable === false) return operation;
+          const nextClientEventId = generateClientEventId();
+          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,
+            occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            state: "sending",
+            error: void 0,
+            retryable: void 0,
+            outcomeUnknown: false,
+            canRetry: true
+          };
+        })
+      );
+      queueMicrotask(processOptimisticSends);
+    },
+    [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, sessionId, workspaceId]
+  );
+  const hasReadyResources = restoredResources.length > 0 || (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
+  const hasPendingOperation = pendingOperationRef.current !== null;
+  const annotationsComplete = annotations.every((annotation) => annotation.note.trim().length > 0);
+  const pause = useCallback(
+    async (reason) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || pausing || targetKeyRef.current !== ownedTargetKey) {
+        return;
+      }
+      setPausing(true);
+      setError(null);
+      try {
+        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) {
+          setAcceptedControl(result.effectiveControl);
+        }
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setError(markActionFailure(normalizeError(cause)));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setPausing(false);
+        }
+      }
+    },
+    [client, workspaceId, sessionId, pausing, targetKey]
+  );
+  const resume = useCallback(
+    async (reason) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || resuming || targetKeyRef.current !== ownedTargetKey) return;
+      setResuming(true);
+      setError(null);
+      try {
+        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(markActionFailure(normalizeError(cause)));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setResuming(false);
+        }
+      }
+    },
+    [client, workspaceId, sessionId, resuming, targetKey]
+  );
+  const resumeScope = useCallback(
+    async (option) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || resuming || targetKeyRef.current !== ownedTargetKey) return;
+      setResuming(true);
+      setError(null);
+      try {
+        if (option.scope === "workspace") {
+          const workspaceBlocker = effectiveControlRef.current?.blockers.find(
+            (blocker) => blocker.kind === "workspace"
+          );
+          if (!client.setWorkspaceInferenceState) {
+            throw new ComposerWorkspaceControlUnavailableError();
+          }
+          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;
+          }
+          const clientEventId = generateClientEventId();
+          await replayOutcomeUnknown(
+            () => client.resumeSession(workspaceId, option.targetId, {
+              clientEventId,
+              expectedControlEtag: target.effectiveControl.controlEtag
+            })
+          );
+        } else {
+          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) {
+          setError(markActionFailure(asError(cause)));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setResuming(false);
+        }
+      }
+    },
+    [client, resuming, sessionId, targetKey, workspaceId]
+  );
+  const updateValue = useCallback(
+    (next) => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      valueRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next,
+          resources: mergeResources(
+            restoredResourcesRef.current,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          ),
+          annotations: annotationsRef.current,
+          policy: pickedPolicy(policyPickedRef, policyRef)
+        }
+      );
+      setOptimisticDraftShadow({
+        text: next,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: annotationsRef.current,
+        policy: pickedPolicy(policyPickedRef, policyRef)
+      });
+      setValue(next);
+    },
+    [pendingOperationKey, setOptimisticDraftShadow, targetKey]
+  );
+  const updateAnnotations = useCallback(
+    (next, reviewTargetId = null) => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      annotationsRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: valueRef.current,
+          resources: mergeResources(
+            restoredResourcesRef.current,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          ),
+          annotations: next,
+          policy: pickedPolicy(policyPickedRef, policyRef)
+        }
+      );
+      setOptimisticDraftShadow({
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        ),
+        annotations: next,
+        policy: pickedPolicy(policyPickedRef, policyRef)
+      });
+      setAnnotations(next);
+      setAnnotationReviewTargetId(reviewTargetId);
+    },
+    [pendingOperationKey, setOptimisticDraftShadow, targetKey]
+  );
+  const addAnnotation = useCallback(
+    (annotation) => {
+      const next = [...annotationsRef.current, annotation];
+      updateAnnotations(next, annotation.id);
+    },
+    [updateAnnotations]
+  );
+  const updateAnnotation = useCallback(
+    (id, note) => {
+      updateAnnotations(
+        annotationsRef.current.map(
+          (annotation) => annotation.id === id ? { ...annotation, note } : annotation
+        )
+      );
+    },
+    [updateAnnotations]
+  );
+  const removeAnnotation = useCallback(
+    (id) => {
+      updateAnnotations(annotationsRef.current.filter((annotation) => annotation.id !== id));
+    },
+    [updateAnnotations]
+  );
+  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;
+      policyPickedRef.current = true;
+      setPolicyPicked(policyPickedRef.current);
+      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;
+      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 ?? []),
+          annotations: annotationsRef.current,
+          policy: pickedPolicy(policyPickedRef, policyRef)
+        }
+      );
+      setOptimisticDraftShadow({
+        text: valueRef.current,
+        resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? []),
+        annotations: annotationsRef.current,
+        policy: pickedPolicy(policyPickedRef, policyRef)
+      });
+      setRestoredResources(next);
+    },
+    [pendingOperationKey, setOptimisticDraftShadow, targetKey]
+  );
+  const hasDraftContent = useCallback(() => {
+    const current = draftRef.current;
+    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: pickedPolicy(policyPickedRef, policyRef)
+      });
+      replaceOptimisticSends(
+        (current) => current.filter((candidate) => candidate.clientEventId !== clientEventId)
+      );
+    },
+    [draftLoading, hasDraftContent, replaceOptimisticSends, setOptimisticDraftShadow, targetKey]
+  );
+  const resolveDraftConflict = useCallback(
+    async (choice) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== ownedTargetKey) return;
+      const remote = await client.getComposerDraft(workspaceId, sessionId);
+      if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+        return;
+      }
+      if (choice === "use_remote") {
+        applyDraft(remote);
+        setError(null);
+        return;
+      }
+      draftRef.current = remote;
+      setDraft(remote);
+      setDraftConflict(null);
+      setError(null);
+      const payload = currentDraftPayload();
+      if (payload) await persistPayload({ ...payload, expectedRevision: remote.revision });
+    },
+    [
+      applyDraft,
+      client,
+      currentDraftPayload,
+      durableDrafts,
+      persistPayload,
+      sessionId,
+      targetKey,
+      workspaceId
+    ]
+  );
+  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: visibleValue,
+    setValue: updateValue,
+    annotations: identityMatches ? annotations : [],
+    addAnnotation,
+    updateAnnotation,
+    removeAnnotation,
+    annotationReviewTargetId: identityMatches ? annotationReviewTargetId : null,
+    clearAnnotationReviewTarget,
+    requestAnnotationReview,
+    hasDraftContent,
+    send,
+    sendToQueue,
+    busySend,
+    singleSend,
+    alternateSend: identityMatches ? alternateSend : null,
+    working: identityMatches && takesBusyPath(),
+    sendAlternate: singleSend ? void 0 : sendAlternate,
+    optimisticMessages: visibleOptimisticMessages,
+    retryOptimisticMessage,
+    restoreOptimisticMessage: !draftLoading && !pendingOperationRef.current && !hasDraftContent() ? restoreOptimisticMessage : void 0,
+    removeOptimisticMessage,
+    steer,
+    steering: visibleSteering,
+    // Receipt-backed: an accepted Steer stops the previous attempt, and an
+    // accepted Pause whose receipt still reports physical settlement stops the
+    // current one. Once the authoritative control catches up, the queue
+    // snapshot owns this projection.
+    stoppingAttempt: identityMatches ? visibleSteering?.phase === "accepted" && visibleSteering.stoppingPreviousAttempt === true ? "previous" : pendingAcceptedControl?.state === "paused" && pendingAcceptedControl.settlement !== null ? "current" : null : null,
+    sending: identityMatches ? sending : false,
+    canSend: identityMatches && Boolean(sessionId) && !sending && !draftLoading && policy !== null && sendBlockedRef.current?.() !== true && annotationsComplete && (hasPendingOperation || visibleValue.trim().length > 0 || hasReadyResources || annotations.length > 0),
+    // The saved draft is still loading, or its first read is being retried:
+    // an early Send waits for it (the composer bounds how long).
+    preparing: identityMatches ? Boolean(sessionId) && (draftLoading || draftHydrationRetrying) : Boolean(sessionId) && durableDrafts,
+    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,
+    flushDraft,
+    policy: identityMatches ? policy : null,
+    sendPolicy: identityMatches && policyPicked ? policy : null,
+    setModel: updateModel,
+    setReasoningEffort: updateReasoningEffort,
+    setLatencyMode: updateLatencyMode,
+    draftPersistence: durableDrafts ? "durable" : "disabled",
+    applyDraft,
+    reloadDraft,
+    resolveDraftConflict,
+    restoredResources: identityMatches ? restoredResources : [],
+    removeRestoredResource,
+    error: identityMatches ? error ?? draftReadError : null,
+    clearError,
+    canBuyCredits: options.canBuyCredits ?? true,
+    reconnecting: identityMatches ? serviceWaiting : false
+  };
+}
+function isComposerDraftEvent(event) {
+  return event.type === "user.message" || event.type === "session.queue.changed" || // A following draft shows the chat's settings, which this event changes.
+  event.type === "session.model_settings.updated";
+}
+var FILE_ONLY_MESSAGE_TEXT = (t) => t("hooks.useComposer.seeAttachedContext");
+function resolveSendExtras(extras) {
+  return (typeof extras === "function" ? extras() : extras) ?? {};
+}
+function composeSendInput(text, clientEventId, extras, bound = {}) {
+  return { ...resolveSendExtras(extras), ...bound, text, clientEventId };
+}
+function shouldSubmitOnKey(event) {
+  if (event.key !== "Enter" || event.shiftKey) {
+    return false;
+  }
+  return event.nativeEvent?.isComposing !== true;
+}
+function shouldSteerOnKey(event) {
+  return event.metaKey === true || event.ctrlKey === true;
+}
+function generateClientEventId() {
+  return globalThis.crypto.randomUUID();
+}
+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 normalizeError(cause);
+}
+function promptRoutingFromAcceptedEvent(event) {
+  if (typeof event?.payload !== "object" || event.payload === null || Array.isArray(event.payload)) {
+    return null;
+  }
+  const routing = event.payload.routing;
+  return routing === "accepted_for_execution" || routing === "queued_for_execution" || routing === "accepted_for_steering" ? routing : null;
+}
+function isDraftConflictError(error) {
+  const apiError = error;
+  return apiError.status === 409 && apiError.outcomeUnknown !== true && apiError.code === "DRAFT_CHANGED";
+}
+function draftPayload(draft) {
+  return {
+    expectedRevision: draft.revision,
+    text: draft.text,
+    resources: draft.resources,
+    annotations: draft.annotations ?? [],
+    // A draft that follows the chat's settings is saved without them.
+    ...draft.policyFollowsSession ? {} : {
+      model: draft.model,
+      reasoningEffort: draft.reasoningEffort,
+      latencyMode: draft.latencyMode
+    }
+  };
+}
+function policyFromDraft(draft) {
+  return {
+    model: draft.model,
+    reasoningEffort: draft.reasoningEffort,
+    latencyMode: draft.latencyMode
+  };
+}
+function pickedPolicy(picked, policy) {
+  return picked.current ? policy.current ?? void 0 : void 0;
+}
+function samePolicy(a, b) {
+  return a !== null && a.model === b.model && a.reasoningEffort === b.reasoningEffort && a.latencyMode === b.latencyMode;
+}
+function composerDraftPayload(base, text, restoredResources, annotations, policy, additionalResources) {
+  return {
+    expectedRevision: base.revision,
+    text,
+    resources: mergeResources(restoredResources, additionalResources),
+    annotations,
+    ...policy ? {
+      model: policy.model,
+      reasoningEffort: policy.reasoningEffort,
+      latencyMode: policy.latencyMode
+    } : {}
+  };
+}
+function draftSignature(payload) {
+  const { expectedRevision: _revision, ...content } = payload;
+  return JSON.stringify(content);
+}
+function mergeResources(base, additions) {
+  const seen = /* @__PURE__ */ new Set();
+  return [...base, ...additions].filter((resource) => {
+    const key = resource.kind === "file" ? `file:${resource.fileId}\0${resource.mountPath ?? `${DEFAULT_FILE_RESOURCE_MOUNT_ROOT}/${resource.fileId}`}` : JSON.stringify(resource);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/hooks/use-queued-prompt-recall.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef as useRef2 } from "react";
+var QUEUED_RECALL_SETTLE_TIMEOUT_MS = 1e4;
+function shouldRecallQueuedOnKey(event, field) {
+  if (event.key !== "ArrowUp") return false;
+  if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey) return false;
+  if (event.nativeEvent?.isComposing === true) return false;
+  if (event.keyCode === 229 || event.nativeEvent?.keyCode === 229) return false;
+  if (field.popupOpen || field.hasOtherContent) return false;
+  if (field.value.length > 0) return false;
+  return (field.selectionStart ?? 0) === 0 && (field.selectionEnd ?? 0) === 0;
+}
+function latestRecallableQueuedTurn(turns, mutationFor, subjectId) {
+  for (let index = turns.length - 1; index >= 0; index -= 1) {
+    const turn = turns[index];
+    if (turn.status !== "queued") continue;
+    if (turn.source !== "user" && turn.source !== "api") continue;
+    if (mutationFor(turn.id) !== null) continue;
+    if (turn.personalResources?.mode === "once") continue;
+    if (subjectId && turn.initiator?.subjectId !== subjectId) continue;
+    return turn;
+  }
+  return null;
+}
+function hasQueuedSendInFlight(messages, queuedTurnIds, queueVersion) {
+  return (messages ?? []).some(
+    (message) => isQueuedSendInFlight(message, queuedTurnIds, queueVersion)
+  );
+}
+function isQueuedSendInFlight(message, queuedTurnIds, queueVersion) {
+  return message.delivery === "send" && message.destination === "queue" && message.state !== "failed" && (!message.turnId || !queuedTurnIds.has(message.turnId)) && !(message.turnId && message.appliedQueueVersion != null && queueVersion != null && queueVersion >= message.appliedQueueVersion);
+}
+function useQueuedPromptRecall({
+  queue,
+  composer,
+  subjectId,
+  enabled = true
+}) {
+  const candidate = latestRecallableQueuedTurn(queue.queue, queue.mutationFor, subjectId);
+  const settling = composer ? recallSettling(composer, queue) : false;
+  const queueSendInFlight = composer ? hasQueuedSendInFlight(
+    composer.optimisticMessages,
+    new Set(queue.queue.map((turn) => turn.id)),
+    queue.snapshot?.version
+  ) : false;
+  const live = useRef2({ queue, composer, subjectId });
+  live.current = { queue, composer, subjectId };
+  const settleWaiters = useRef2(/* @__PURE__ */ new Set());
+  useEffect2(() => {
+    for (const waiter of [...settleWaiters.current]) waiter.check();
+  });
+  useEffect2(() => {
+    const waiters = settleWaiters.current;
+    return () => {
+      for (const waiter of [...waiters]) waiter.cancel();
+    };
+  }, []);
+  const supported = enabled && composer !== void 0 && composer.draftPersistence !== "disabled" && queue.recallTurn !== void 0;
+  const recall = useCallback2(async () => {
+    let current = live.current;
+    let target = current.composer;
+    if (!target || target.draftPersistence === "disabled" || !current.queue.recallTurn) {
+      return "unavailable";
+    }
+    if (target.draftLoading || target.hasDraftContent()) return "unavailable";
+    let queued = current.queue.queue;
+    const tracked = inFlightQueueSends(target, current.queue);
+    if (tracked.size > 0) {
+      const settled = await waitForTrackedSends(settleWaiters.current, live, tracked);
+      if (!settled) return "unavailable";
+      current = live.current;
+      target = current.composer;
+      if (!target || target.draftPersistence === "disabled") return "unavailable";
+      if (target.draftLoading || target.hasDraftContent()) return "unavailable";
+      const trackedTurnIds = new Set(
+        [...tracked.values()].filter((turnId) => turnId !== null)
+      );
+      queued = current.queue.queue.filter((turn2) => trackedTurnIds.has(turn2.id));
+      if (latestRecallableQueuedTurn(queued, current.queue.mutationFor, current.subjectId) === null) {
+        const waitingIds = new Set(current.queue.queue.map((turn2) => turn2.id));
+        return [...trackedTurnIds].some((turnId) => !waitingIds.has(turnId)) ? "already_sent" : "unavailable";
+      }
+    } else if (recallSettling(target, current.queue)) {
+      return "unavailable";
+    }
+    const recallTurn = current.queue.recallTurn;
+    if (!recallTurn) return "unavailable";
+    const turn = latestRecallableQueuedTurn(queued, current.queue.mutationFor, current.subjectId);
+    if (!turn) return "unavailable";
+    const result = await recallTurn(turn.id, { expectedDraftRevision: target.draftRevision });
+    if (result.status === "recalled") {
+      const latest = live.current.composer ?? target;
+      const typedMeanwhile = latest.value;
+      latest.applyDraft(result.draft);
+      if (typedMeanwhile.length > 0) {
+        latest.setValue(
+          result.draft.text.length > 0 ? `${result.draft.text}
+${typedMeanwhile}` : typedMeanwhile
+        );
+      }
+      return "recalled";
+    }
+    return result.status === "already_sent" ? "already_sent" : "unavailable";
+  }, []);
+  return useMemo(
+    () => supported ? {
+      // The row already shows a send on its way as queued, so Up is
+      // taken now and `recall` waits for it to land.
+      available: candidate !== null && !settling || queueSendInFlight,
+      turnId: settling ? null : candidate?.id ?? null,
+      recall
+    } : void 0,
+    [candidate, queueSendInFlight, recall, settling, supported]
+  );
+}
+function recallSettling(composer, queue) {
+  if (composer.sending) return true;
+  if (!composer.optimisticMessages?.length) return false;
+  return hasQueuedSendInFlight(
+    composer.optimisticMessages,
+    new Set(queue.queue.map((turn) => turn.id)),
+    queue.snapshot?.version
+  );
+}
+function inFlightQueueSends(composer, queue) {
+  const queuedTurnIds = new Set(queue.queue.map((turn) => turn.id));
+  return new Map(
+    (composer.optimisticMessages ?? []).filter((message) => isQueuedSendInFlight(message, queuedTurnIds, queue.snapshot?.version)).map((message) => [message.clientEventId, message.turnId ?? null])
+  );
+}
+function waitForTrackedSends(waiters, live, tracked) {
+  const known = new Set(
+    (live.current.composer?.optimisticMessages ?? []).map((message) => message.clientEventId)
+  );
+  return new Promise((resolve) => {
+    const finish = (settled) => {
+      clearTimeout(timer);
+      waiters.delete(waiter);
+      resolve(settled);
+    };
+    const waiter = {
+      cancel: () => finish(false),
+      check: () => {
+        const { composer, queue } = live.current;
+        if (!composer || composer.hasDraftContent()) return finish(false);
+        const messages = composer.optimisticMessages ?? [];
+        if (messages.some((message) => !known.has(message.clientEventId))) return finish(false);
+        const queuedTurnIds = new Set(queue.queue.map((turn) => turn.id));
+        let pending = false;
+        for (const clientEventId of tracked.keys()) {
+          const message = messages.find((candidate) => candidate.clientEventId === clientEventId);
+          if (message?.turnId) tracked.set(clientEventId, message.turnId);
+          if (message && isQueuedSendInFlight(message, queuedTurnIds, queue.snapshot?.version)) {
+            pending = true;
+          }
+        }
+        if (!pending) finish(true);
+      }
+    };
+    const timer = setTimeout(() => finish(false), QUEUED_RECALL_SETTLE_TIMEOUT_MS);
+    waiters.add(waiter);
+  });
+}
+
+export {
+  notifyObserver,
+  useComposer,
+  FILE_ONLY_MESSAGE_TEXT,
+  composeSendInput,
+  shouldSubmitOnKey,
+  shouldSteerOnKey,
+  shouldRecallQueuedOnKey,
+  latestRecallableQueuedTurn,
+  useQueuedPromptRecall
+};
+//# sourceMappingURL=chunk-MIHN76LX.js.map