@opengeni/react 0.23.0 → 0.25.5

package/dist/{chunk-UQS7OQDE.js → chunk-F4CFWKVI.js}

@@ -1,15 +1,116 @@
 import {
   useEmbeddedSession,
   useSessionEventTrigger
-} from "./chunk-I3BJZIG5.js";
+} from "./chunk-HIWPQYWI.js";
 
 // src/hooks/use-composer.ts
 import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+var PENDING_COMPOSER_STORAGE_PREFIX = "opengeni.pending-composer.v1:";
+var pendingComposerOperations = /* @__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 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 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) || typeof shadowRecord.text !== "string" || !resourceList(shadowRecord.resources) || typeof record.clearDraftOnAccept !== "boolean" || typeof record.hasMcpCredentialUpdates !== "boolean" || typeof inputRecord.text !== "string" || typeof inputRecord.clientEventId !== "string" || "mcpCredentialUpdates" in inputRecord || "resources" in inputRecord && !resourceList(inputRecord.resources)) {
+      return null;
+    }
+    return record;
+  } 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
+    },
+    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]
+    }
+  };
+  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] } };
+  rememberPendingComposerOperation(key, next);
+  return next;
+}
 function useComposer(sessionId, options = {}) {
   const { client, workspaceId, registerSessionReconciler } = useEmbeddedSession(options);
   const durableDrafts = options.draftPersistence !== "disabled";
   const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${durableDrafts ? "durable" : "disabled"}`;
-  const [value, setValue] = useState("");
+  const pendingOperationKey = pendingComposerOperationKey(workspaceId, sessionId);
+  const initialPendingOperation = restorePendingComposerOperation(pendingOperationKey);
+  const initialShadow = initialPendingOperation?.newerShadow;
+  const [value, setValue] = useState(() => initialShadow?.text ?? "");
   const [stateTargetKey, setStateTargetKey] = useState(targetKey);
   const [sending, setSending] = useState(false);
   const [pausing, setPausing] = useState(false);
@@ -19,20 +120,31 @@ function useComposer(sessionId, options = {}) {
   const [draftLoading, setDraftLoading] = useState(Boolean(sessionId) && durableDrafts);
   const [draftSaving, setDraftSaving] = useState(false);
   const [draftConflict, setDraftConflict] = useState(null);
-  const [restoredResources, setRestoredResources] = useState([]);
-  const pendingClientEventId = useRef(null);
-  const valueRef = useRef("");
+  const [restoredResources, setRestoredResources] = useState(
+    () => initialShadow?.resources ?? []
+  );
+  const pendingOperationRef = useRef(initialPendingOperation);
+  const pendingClientEventId = useRef(
+    initialPendingOperation?.input.clientEventId ?? null
+  );
+  const valueRef = useRef(initialShadow?.text ?? "");
   const draftRef = useRef(null);
-  const restoredResourcesRef = useRef([]);
-  const localEditRevision = useRef(0);
+  const restoredResourcesRef = useRef(initialShadow?.resources ?? []);
+  const localEditRevision = useRef(initialShadow ? 1 : 0);
   const targetGeneration = useRef(0);
   const draftReadGeneration = useRef(0);
   const lastSavedSignature = useRef(null);
   const saveChain = useRef(Promise.resolve());
   const onSent = options.onSent;
   const onDraftApplied = options.onDraftApplied;
+  const onDraftAppliedRef = useRef(onDraftApplied);
+  useLayoutEffect(() => {
+    onDraftAppliedRef.current = onDraftApplied;
+  }, [onDraftApplied]);
   const sendExtrasRef = useRef(options.sendExtras);
   sendExtrasRef.current = options.sendExtras;
+  const sendBlockedRef = useRef(options.sendBlocked);
+  sendBlockedRef.current = options.sendBlocked;
   const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
   const targetKeyRef = useRef(targetKey);
   useLayoutEffect(() => {
@@ -40,15 +152,17 @@ function useComposer(sessionId, options = {}) {
     targetKeyRef.current = targetKey;
     targetGeneration.current += 1;
     draftReadGeneration.current += 1;
-    pendingClientEventId.current = null;
-    localEditRevision.current = 0;
-    valueRef.current = "";
+    pendingOperationRef.current = restorePendingComposerOperation(pendingOperationKey);
+    pendingClientEventId.current = pendingOperationRef.current?.input.clientEventId ?? null;
+    const shadow = pendingOperationRef.current?.newerShadow;
+    localEditRevision.current = shadow ? 1 : 0;
+    valueRef.current = shadow?.text ?? "";
     draftRef.current = null;
-    restoredResourcesRef.current = [];
+    restoredResourcesRef.current = shadow?.resources ?? [];
     lastSavedSignature.current = null;
     saveChain.current = Promise.resolve();
     setStateTargetKey(targetKey);
-    setValue("");
+    setValue(shadow?.text ?? "");
     setSending(false);
     setPausing(false);
     setResuming(false);
@@ -57,13 +171,12 @@ function useComposer(sessionId, options = {}) {
     setDraftLoading(Boolean(sessionId) && durableDrafts);
     setDraftSaving(false);
     setDraftConflict(null);
-    setRestoredResources([]);
-  }, [durableDrafts, sessionId, targetKey]);
+    setRestoredResources(shadow?.resources ?? []);
+  }, [durableDrafts, pendingOperationKey, sessionId, targetKey]);
   const applyDraft = useCallback(
     (next) => {
       if (targetKeyRef.current !== targetKey) return;
       if (!durableDrafts) {
-        pendingClientEventId.current = null;
         localEditRevision.current += 1;
         valueRef.current = next.text;
         restoredResourcesRef.current = next.resources;
@@ -72,6 +185,17 @@ function useComposer(sessionId, options = {}) {
         setDraft(null);
         setValue(next.text);
         setRestoredResources(next.resources);
+        pendingOperationRef.current = updatePendingComposerShadow(
+          pendingOperationKey,
+          pendingOperationRef.current,
+          {
+            text: next.text,
+            resources: mergeResources(
+              next.resources,
+              resolveSendExtras(sendExtrasRef.current).resources ?? []
+            )
+          }
+        );
         setDraftConflict(null);
         return;
       }
@@ -80,14 +204,24 @@ function useComposer(sessionId, options = {}) {
       restoredResourcesRef.current = next.resources;
       lastSavedSignature.current = draftSignature(draftPayload(next));
       localEditRevision.current += 1;
-      pendingClientEventId.current = null;
       setDraft(next);
       setValue(next.text);
       setRestoredResources(next.resources);
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next.text,
+          resources: mergeResources(
+            next.resources,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          )
+        }
+      );
       setDraftConflict(null);
-      onDraftApplied?.(next);
+      onDraftAppliedRef.current?.(next);
     },
-    [durableDrafts, onDraftApplied, targetKey]
+    [durableDrafts, pendingOperationKey, targetKey]
   );
   const loadDraft = useCallback(
     async (replaceLocal) => {
@@ -121,13 +255,20 @@ function useComposer(sessionId, options = {}) {
           draftRef.current = fetched;
           setDraft(fetched);
           setDraftConflict(null);
-          if (replaceLocal || !localWasDirtyAtStart && localAtStart === localEditRevision.current) {
+          const shadow = pendingOperationRef.current?.newerShadow;
+          if (shadow) {
+            valueRef.current = shadow.text;
+            restoredResourcesRef.current = shadow.resources;
+            localEditRevision.current ||= 1;
+            setValue(shadow.text);
+            setRestoredResources(shadow.resources);
+          } else if (replaceLocal || !localWasDirtyAtStart && localAtStart === localEditRevision.current) {
             valueRef.current = fetched.text;
             restoredResourcesRef.current = fetched.resources;
             lastSavedSignature.current = draftSignature(draftPayload(fetched));
             setValue(fetched.text);
             setRestoredResources(fetched.resources);
-            onDraftApplied?.(fetched);
+            onDraftAppliedRef.current?.(fetched);
           }
         }
       } catch (cause) {
@@ -140,7 +281,7 @@ function useComposer(sessionId, options = {}) {
         }
       }
     },
-    [client, durableDrafts, onDraftApplied, sessionId, targetKey, workspaceId]
+    [client, durableDrafts, sessionId, targetKey, workspaceId]
   );
   useEffect(() => {
     if (!sessionId || !durableDrafts) {
@@ -205,7 +346,7 @@ function useComposer(sessionId, options = {}) {
         } catch (cause) {
           if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
             const problem = asError(cause);
-            setDraftConflict(problem);
+            if (isDraftConflictError(problem)) setDraftConflict(problem);
             setError(problem);
           }
         } finally {
@@ -221,6 +362,24 @@ function useComposer(sessionId, options = {}) {
     [client, durableDrafts, sessionId, targetKey, workspaceId]
   );
   useEffect(() => {
+    const pending = pendingOperationRef.current;
+    if (pending) {
+      const shadow = {
+        text: valueRef.current,
+        resources: mergeResources(
+          restoredResourcesRef.current,
+          resolveSendExtras(sendExtrasRef.current).resources ?? []
+        )
+      };
+      if (pending.newerShadow.text !== shadow.text || JSON.stringify(pending.newerShadow.resources) !== JSON.stringify(shadow.resources)) {
+        pendingOperationRef.current = updatePendingComposerShadow(
+          pendingOperationKey,
+          pending,
+          shadow
+        );
+      }
+      return;
+    }
     if (!durableDrafts || !sessionId || draftLoading || sending || !draftRef.current || draftConflict)
       return;
     const payload = currentDraftPayload();
@@ -233,6 +392,7 @@ function useComposer(sessionId, options = {}) {
     draftConflict,
     draftLoading,
     liveExtrasVersion,
+    pendingOperationKey,
     persistPayload,
     sending,
     sessionId
@@ -241,18 +401,110 @@ function useComposer(sessionId, options = {}) {
     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 rawText = explicit ?? draftAtSend;
       const hasText = rawText.trim().length > 0;
-      const extras = resolveSendExtras(sendExtrasRef.current);
+      const extras = pending ? {} : resolveSendExtras(sendExtrasRef.current);
       const hasResources = restoredResources.length > 0 || (extras.resources?.length ?? 0) > 0;
-      if (!hasText && !hasResources || !sessionId || sending || targetKeyRef.current !== ownedTargetKey) {
+      if (!pending && !hasText && !hasResources || !sessionId || sending || sendBlockedRef.current?.() === true || targetKeyRef.current !== ownedTargetKey) {
         return false;
       }
-      pendingClientEventId.current ??= generateClientEventId();
+      const clearPending = () => {
+        pendingOperationRef.current = null;
+        pendingClientEventId.current = null;
+        forgetPendingComposerOperation(operationKey);
+      };
+      const settleAccepted = (operation) => {
+        clearPending();
+        const draftWasUnchanged = valueRef.current === operation.draftAtSend;
+        const resourcesWereUnchanged = JSON.stringify(restoredResourcesRef.current) === JSON.stringify(operation.resourcesAtSend);
+        const previousDraft = draftRef.current;
+        if (previousDraft) {
+          const cleared = {
+            ...previousDraft,
+            revision: 0,
+            text: "",
+            resources: [],
+            sourceTurnId: null,
+            sourceTurnVersion: null,
+            updatedAt: null
+          };
+          draftRef.current = cleared;
+          setDraft(cleared);
+          lastSavedSignature.current = draftSignature(draftPayload(cleared));
+        }
+        if (resourcesWereUnchanged) {
+          restoredResourcesRef.current = [];
+          setRestoredResources([]);
+        }
+        if (operation.clearDraftOnAccept && draftWasUnchanged) {
+          valueRef.current = "";
+          setValue("");
+        }
+        onSent?.(operation.input.text, operation.input);
+      };
+      const deliver = async (operation) => {
+        if (operation.delivery === "steer") {
+          await client.steerMessage(workspaceId, sessionId, operation.input);
+        } else {
+          await client.sendMessage(workspaceId, sessionId, operation.input);
+        }
+      };
       setSending(true);
       setError(null);
       try {
+        if (pending) {
+          let accepted = false;
+          try {
+            const events = await client.listEvents(workspaceId, sessionId, {
+              includeTypes: ["user.message"],
+              limit: 100,
+              payloadMode: "none"
+            });
+            accepted = events.some(
+              (event) => event.type === "user.message" && event.clientEventId === pending.input.clientEventId
+            );
+          } catch (cause) {
+            if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+              setError(asError(cause));
+            }
+            return false;
+          }
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return false;
+          }
+          if (accepted) {
+            settleAccepted(pending);
+            return true;
+          }
+          if (!pending.canRetry) {
+            setError(
+              new Error(
+                "OpenGeni cannot safely retry this uncertain request after remount; reconcile the session before sending again."
+              )
+            );
+            return false;
+          }
+          try {
+            await deliver(pending);
+          } catch (cause) {
+            if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+              setError(asError(cause));
+            }
+            return false;
+          }
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return false;
+          }
+          settleAccepted(pending);
+          return true;
+        }
         const sendText = hasText ? rawText : FILE_ONLY_MESSAGE_TEXT;
         const currentPayload = currentDraftPayload();
         const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
@@ -262,50 +514,42 @@ function useComposer(sessionId, options = {}) {
         }
         const acknowledgedDraft = draftRef.current;
         const sendExtras = acknowledgedDraft?.toolsProvided === true && !Object.prototype.hasOwnProperty.call(extras, "tools") ? { ...extras, tools: acknowledgedDraft.tools } : extras;
+        pendingClientEventId.current ??= generateClientEventId();
         const input = composeSendInput(sendText, pendingClientEventId.current, sendExtras, {
           ...options.effectiveControl?.controlEtag ? { controlEtag: options.effectiveControl.controlEtag } : {},
           ...durableDrafts && draftRef.current ? { expectedDraftRevision: draftRef.current.revision } : {},
           resources: mergeResources(restoredResources, extras.resources ?? [])
         });
-        if (delivery === "steer") {
-          await client.steerMessage(workspaceId, sessionId, input);
-        } else {
-          await client.sendMessage(workspaceId, sessionId, input);
+        const operation = {
+          delivery,
+          input,
+          draftAtSend,
+          resourcesAtSend: [...restoredResources],
+          newerShadow: {
+            text: draftAtSend,
+            resources: mergeResources(restoredResources, extras.resources ?? [])
+          },
+          clearDraftOnAccept: explicit === void 0,
+          canRetry: true
+        };
+        pendingOperationRef.current = operation;
+        rememberPendingComposerOperation(operationKey, operation);
+        try {
+          await deliver(operation);
+        } catch (cause) {
+          if (!isOutcomeUnknownError(cause)) {
+            clearPending();
+          }
+          if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+            setError(asError(cause));
+          }
+          return false;
         }
         if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
           return false;
         }
-        pendingClientEventId.current = null;
-        const previousDraft = draftRef.current;
-        if (previousDraft) {
-          const cleared = {
-            ...previousDraft,
-            revision: 0,
-            text: "",
-            resources: [],
-            sourceTurnId: null,
-            sourceTurnVersion: null,
-            updatedAt: null
-          };
-          draftRef.current = cleared;
-          restoredResourcesRef.current = [];
-          setDraft(cleared);
-          setRestoredResources([]);
-          lastSavedSignature.current = draftSignature(draftPayload(cleared));
-        }
-        if (explicit === void 0) {
-          if (valueRef.current === draftAtSend) {
-            valueRef.current = "";
-            setValue("");
-          }
-        }
-        onSent?.(sendText);
+        settleAccepted(operation);
         return true;
-      } catch (cause) {
-        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
-        }
-        return false;
       } finally {
         if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
           setSending(false);
@@ -330,6 +574,7 @@ function useComposer(sessionId, options = {}) {
   const send = useCallback(async (text) => await dispatch("send", text), [dispatch]);
   const steer = useCallback(async (text) => await dispatch("steer", text), [dispatch]);
   const hasReadyResources = restoredResources.length > 0 || (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
+  const hasPendingOperation = pendingOperationRef.current !== null;
   const pause = useCallback(
     async (reason) => {
       const ownedTargetKey = targetKey;
@@ -430,12 +675,22 @@ function useComposer(sessionId, options = {}) {
   const updateValue = useCallback(
     (next) => {
       if (targetKeyRef.current !== targetKey) return;
-      pendingClientEventId.current = null;
       localEditRevision.current += 1;
       valueRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: next,
+          resources: mergeResources(
+            restoredResourcesRef.current,
+            resolveSendExtras(sendExtrasRef.current).resources ?? []
+          )
+        }
+      );
       setValue(next);
     },
-    [targetKey]
+    [pendingOperationKey, targetKey]
   );
   const removeRestoredResource = useCallback(
     (index) => {
@@ -443,9 +698,17 @@ function useComposer(sessionId, options = {}) {
       localEditRevision.current += 1;
       const next = restoredResourcesRef.current.filter((_, candidate) => candidate !== index);
       restoredResourcesRef.current = next;
+      pendingOperationRef.current = updatePendingComposerShadow(
+        pendingOperationKey,
+        pendingOperationRef.current,
+        {
+          text: valueRef.current,
+          resources: mergeResources(next, resolveSendExtras(sendExtrasRef.current).resources ?? [])
+        }
+      );
       setRestoredResources(next);
     },
-    [targetKey]
+    [pendingOperationKey, targetKey]
   );
   const hasDraftContent = useCallback(() => {
     const current = draftRef.current;
@@ -498,7 +761,7 @@ function useComposer(sessionId, options = {}) {
     send,
     steer,
     sending: identityMatches ? sending : false,
-    canSend: identityMatches && Boolean(sessionId) && !sending && (value.trim().length > 0 || hasReadyResources),
+    canSend: identityMatches && Boolean(sessionId) && !sending && sendBlockedRef.current?.() !== true && (hasPendingOperation || value.trim().length > 0 || hasReadyResources),
     pause,
     pausing: identityMatches ? pausing : false,
     resume,
@@ -541,9 +804,16 @@ function shouldSteerOnKey(event) {
 function generateClientEventId() {
   return globalThis.crypto.randomUUID();
 }
+function isOutcomeUnknownError(cause) {
+  return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
+}
 function asError(cause) {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
+function isDraftConflictError(error) {
+  const apiError = error;
+  return apiError.status === 409 && apiError.outcomeUnknown === false && (apiError.code === void 0 || apiError.code === "conflict" || apiError.code === "idempotency_conflict");
+}
 function draftPayload(draft) {
   return {
     expectedRevision: draft.revision,
@@ -588,4 +858,4 @@ export {
   shouldSubmitOnKey,
   shouldSteerOnKey
 };
-//# sourceMappingURL=chunk-UQS7OQDE.js.map
+//# sourceMappingURL=chunk-F4CFWKVI.js.map