@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-AXBSYWKX.js

@@ -1,2656 +0,0 @@
-"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-TNUSPXPW.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-AXBSYWKX.js.map