@opengeni/react 1.4.4 → 1.4.5-canary.37485542607001

package/dist/new-session-draft.js

@@ -0,0 +1,639 @@
+"use client";
+
+// src/hooks/use-new-session-draft.ts
+import { OpenGeniApiError as OpenGeniApiError2 } from "@opengeni/sdk";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/lib/transient-retry.ts
+import { OpenGeniApiError } from "@opengeni/sdk";
+var TRANSIENT_RETRY_DELAYS_MS = [1e3, 2e3, 3e3, 4e3];
+var TRANSIENT_RECONNECT_INTERVAL_MS = 3e3;
+var OPENGENI_UPDATING_NOTICE = "Opengeni is updating. We'll reconnect automatically.";
+var NETWORK_FAILURE = /failed to fetch|fetch failed|networkerror|load failed|network request failed/iu;
+function isTransientServiceFailure(error) {
+  if (isAbort(error)) return false;
+  if (error instanceof OpenGeniApiError) {
+    if (error.status === 502 || error.status === 503 || error.status === 504) return true;
+    if (error.status === 500) return error.retryable;
+    return error.status === 0 && error.code === "network_error";
+  }
+  return error instanceof TypeError && NETWORK_FAILURE.test(error.message);
+}
+async function retryTransient(operation, options = {}) {
+  const delays = options.delaysMs ?? TRANSIENT_RETRY_DELAYS_MS;
+  const sleep = options.sleep ?? abortableSleep;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      const delay = delays[attempt];
+      if (delay === void 0 || !isTransientServiceFailure(error) || options.signal?.aborted || options.shouldContinue?.() === false) {
+        throw error;
+      }
+      await sleep(delay, options.signal);
+      if (options.signal?.aborted || options.shouldContinue?.() === false) throw error;
+    }
+  }
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function isAbort(error) {
+  return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+
+// src/hooks/use-new-session-draft.ts
+function useNewSessionDraft(options) {
+  const { client, workspaceId } = options;
+  const resourceHydrationReady = options.resourceHydrationReady ?? true;
+  const suspendAutosave = options.suspendAutosave ?? false;
+  const hydrateResources = options.hydrateResources;
+  const retryDelaysMs = options.transientRetry?.delaysMs ?? TRANSIENT_RETRY_DELAYS_MS;
+  const reconnectIntervalMs = options.transientRetry?.reconnectIntervalMs ?? TRANSIENT_RECONNECT_INTERVAL_MS;
+  const [draft, setDraft] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [conflict, setConflict] = useState(null);
+  const [error, setErrorState] = useState(null);
+  const errorRef = useRef(null);
+  const setError = useCallback((next) => {
+    errorRef.current = next;
+    setErrorState(next);
+  }, []);
+  const unloadedValueSignature = useRef(null);
+  const valueRef = useRef(options.value);
+  valueRef.current = options.value;
+  const onApplyRemoteRef = useRef(options.onApplyRemote);
+  onApplyRemoteRef.current = options.onApplyRemote;
+  const restoreReadyFilesRef = useRef(options.restoreReadyFiles);
+  restoreReadyFilesRef.current = options.restoreReadyFiles;
+  const draftRef = useRef(null);
+  const lastSavedSignature = useRef(null);
+  const passiveProjectionSignature = useRef(null);
+  const pendingHydratedBaselineGeneration = useRef(null);
+  const targetGeneration = useRef(0);
+  const persistenceEpoch = useRef(0);
+  const saveChain = useRef(Promise.resolve());
+  const autosaveTimer = useRef(null);
+  const conflictRef = useRef(null);
+  const loadingRef = useRef(true);
+  const activeRemoteReads = useRef(/* @__PURE__ */ new Set());
+  const targetKey = `${workspaceId}\0${clientIdentity(client)}`;
+  const targetKeyRef = useRef(targetKey);
+  const setCurrentConflict = useCallback((next) => {
+    conflictRef.current = next;
+    setConflict(next);
+  }, []);
+  const captureConflict = useCallback(
+    (cause) => {
+      if (!isNewSessionDraftConflict(cause)) return false;
+      const problem = asError(cause);
+      setCurrentConflict(problem);
+      setError(problem);
+      return true;
+    },
+    [setCurrentConflict, setError]
+  );
+  const abortActiveRemoteReads = useCallback(() => {
+    for (const controller of activeRemoteReads.current) controller.abort();
+    activeRemoteReads.current.clear();
+  }, []);
+  const validateRemoteDraft = useCallback(
+    async (remote, generation, signal) => {
+      if (!resourceHydrationReady || signal.aborted) return null;
+      const hydratedResources = hydrateResources ? await hydrateResources(remote.resources) : remote.resources;
+      if (generation !== targetGeneration.current || signal.aborted) return null;
+      const seen = /* @__PURE__ */ new Set();
+      const fileRefs = hydratedResources.flatMap((resource) => {
+        if (resource.kind !== "file" || seen.has(resource.fileId)) return [];
+        seen.add(resource.fileId);
+        return [resource];
+      });
+      const settled = await Promise.allSettled(
+        fileRefs.map(
+          (resource) => retryTransient(() => client.getFile(workspaceId, resource.fileId, { signal }), {
+            signal,
+            delaysMs: retryDelaysMs
+          })
+        )
+      );
+      if (generation !== targetGeneration.current || signal.aborted) return null;
+      const files = settled.flatMap((result, index) => {
+        if (result.status !== "fulfilled") return [];
+        const file = result.value;
+        const expected = fileRefs[index]?.fileId;
+        return file.id === expected && file.workspaceId === workspaceId && file.status === "ready" ? [file] : [];
+      });
+      return {
+        draft: remote,
+        editable: {
+          text: remote.text,
+          resources: [
+            ...hydratedResources.filter((resource) => resource.kind === "repository"),
+            ...files.map(
+              (file) => ({
+                kind: "file",
+                fileId: file.id
+              })
+            )
+          ],
+          tools: remote.tools,
+          toolsProvided: remote.toolsProvided,
+          model: remote.model,
+          reasoningEffort: remote.reasoningEffort,
+          latencyMode: remote.latencyMode ?? "standard",
+          ...remote.modelProvided !== void 0 ? { modelProvided: remote.modelProvided } : {},
+          ...Object.hasOwn(remote, "selectedProjectChannelId") ? { selectedProjectChannelId: remote.selectedProjectChannelId } : {},
+          options: remote.options
+        },
+        files
+      };
+    },
+    [client, hydrateResources, resourceHydrationReady, retryDelaysMs, workspaceId]
+  );
+  const readRemote = useCallback(
+    async (quietRetries = true) => {
+      const controller = new AbortController();
+      activeRemoteReads.current.add(controller);
+      const generation = targetGeneration.current;
+      try {
+        const remote = normalizeLegacyNewSessionDraft(
+          await retryTransient(
+            () => client.getNewSessionDraft(workspaceId, { signal: controller.signal }),
+            {
+              signal: controller.signal,
+              shouldContinue: () => generation === targetGeneration.current,
+              delaysMs: quietRetries ? retryDelaysMs : []
+            }
+          )
+        );
+        if (generation !== targetGeneration.current || controller.signal.aborted) return null;
+        return await validateRemoteDraft(remote, generation, controller.signal);
+      } finally {
+        activeRemoteReads.current.delete(controller);
+      }
+    },
+    [client, retryDelaysMs, validateRemoteDraft, workspaceId]
+  );
+  const applyRemote = useCallback(
+    (remote) => {
+      draftRef.current = remote.draft;
+      lastSavedSignature.current = draftSignature(remote.editable);
+      passiveProjectionSignature.current = null;
+      pendingHydratedBaselineGeneration.current = targetGeneration.current;
+      unloadedValueSignature.current = null;
+      setDraft(remote.draft);
+      setCurrentConflict(null);
+      setError(null);
+      restoreReadyFilesRef.current(remote.files);
+      onApplyRemoteRef.current(remote.editable, remote.draft.selectionHistory);
+    },
+    [setCurrentConflict, setError]
+  );
+  const reload = useCallback(async () => {
+    if (!resourceHydrationReady) return;
+    const generation = targetGeneration.current;
+    const valueAtStart = draftSignature(valueRef.current);
+    loadingRef.current = true;
+    setLoading(true);
+    try {
+      const remote = await readRemote();
+      if (remote && generation === targetGeneration.current) applyRemote(remote);
+    } catch (cause) {
+      if (generation === targetGeneration.current) {
+        if (!draftRef.current) unloadedValueSignature.current = valueAtStart;
+        setError(asError(cause));
+      }
+    } finally {
+      if (generation === targetGeneration.current) {
+        loadingRef.current = false;
+        setLoading(false);
+      }
+    }
+  }, [applyRemote, readRemote, resourceHydrationReady, setError]);
+  const reloadRef = useRef(reload);
+  reloadRef.current = reload;
+  useEffect(() => {
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+    }
+    targetGeneration.current += 1;
+    abortActiveRemoteReads();
+    persistenceEpoch.current += 1;
+    draftRef.current = null;
+    lastSavedSignature.current = null;
+    passiveProjectionSignature.current = null;
+    pendingHydratedBaselineGeneration.current = null;
+    unloadedValueSignature.current = null;
+    saveChain.current = Promise.resolve();
+    if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+    autosaveTimer.current = null;
+    setDraft(null);
+    setCurrentConflict(null);
+    setError(null);
+    setSaving(false);
+    loadingRef.current = true;
+    setLoading(true);
+    return () => {
+      targetGeneration.current += 1;
+      abortActiveRemoteReads();
+      if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+      autosaveTimer.current = null;
+    };
+  }, [abortActiveRemoteReads, setCurrentConflict, setError, targetKey]);
+  useEffect(() => {
+    if (resourceHydrationReady) void reloadRef.current();
+  }, [resourceHydrationReady, targetKey]);
+  const persistSnapshot = useCallback(
+    (snapshot, force = false) => {
+      const generation = targetGeneration.current;
+      const epoch = persistenceEpoch.current;
+      const signature = draftSignature(snapshot);
+      const run = async () => {
+        if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+          return null;
+        }
+        const current = draftRef.current;
+        if (!current) return null;
+        if (!force && signature === lastSavedSignature.current) {
+          return { revision: current.revision, signature };
+        }
+        setSaving(true);
+        try {
+          const save = () => client.saveNewSessionDraft(workspaceId, {
+            ...snapshot,
+            expectedRevision: current.revision
+          });
+          const saved = force ? await retryTransient(save, {
+            shouldContinue: () => generation === targetGeneration.current && epoch === persistenceEpoch.current,
+            delaysMs: retryDelaysMs
+          }) : await save();
+          if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+            return null;
+          }
+          draftRef.current = saved;
+          lastSavedSignature.current = signature;
+          passiveProjectionSignature.current = null;
+          setDraft(saved);
+          setCurrentConflict(null);
+          setError(null);
+          return { revision: saved.revision, signature };
+        } catch (cause) {
+          if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+            return null;
+          }
+          const problem = asError(cause);
+          if (isNewSessionDraftConflict(cause)) setCurrentConflict(problem);
+          setError(problem);
+          return null;
+        } finally {
+          if (generation === targetGeneration.current && epoch === persistenceEpoch.current) {
+            setSaving(false);
+          }
+        }
+      };
+      const operation = saveChain.current.then(run, run);
+      saveChain.current = operation.then(
+        () => void 0,
+        () => void 0
+      );
+      return operation;
+    },
+    [client, retryDelaysMs, setCurrentConflict, setError, workspaceId]
+  );
+  const valueSignature = draftSignature(options.value);
+  useEffect(() => {
+    if (!loading && draftRef.current && pendingHydratedBaselineGeneration.current === targetGeneration.current) {
+      pendingHydratedBaselineGeneration.current = null;
+      passiveProjectionSignature.current = valueSignature;
+      return;
+    }
+    if (loading || suspendAutosave || !draftRef.current || conflictRef.current || valueSignature === lastSavedSignature.current || valueSignature === passiveProjectionSignature.current) {
+      return;
+    }
+    passiveProjectionSignature.current = null;
+    const snapshot = cloneEditable(valueRef.current);
+    autosaveTimer.current = setTimeout(() => {
+      autosaveTimer.current = null;
+      void persistSnapshot(snapshot);
+    }, 500);
+    return () => {
+      if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+      autosaveTimer.current = null;
+    };
+  }, [loading, persistSnapshot, suspendAutosave, valueSignature]);
+  const flush = useCallback(async () => {
+    if (loadingRef.current || conflictRef.current || !draftRef.current) return null;
+    if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+    autosaveTimer.current = null;
+    return await persistSnapshot(cloneEditable(valueRef.current));
+  }, [persistSnapshot]);
+  const flushForSend = useCallback(
+    async (sendSnapshot) => {
+      if (loadingRef.current) return null;
+      if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+      autosaveTimer.current = null;
+      const snapshot = cloneEditable(sendSnapshot ?? valueRef.current);
+      const generation = targetGeneration.current;
+      if (!draftRef.current) {
+        try {
+          const remote = await readRemote();
+          if (!remote || generation !== targetGeneration.current) return null;
+          draftRef.current = remote.draft;
+          lastSavedSignature.current = draftSignature(remote.editable);
+          setDraft(remote.draft);
+        } catch (cause) {
+          if (generation === targetGeneration.current) setError(asError(cause));
+          return null;
+        }
+      }
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (generation !== targetGeneration.current) return null;
+        if (conflictRef.current) {
+          await saveChain.current;
+          try {
+            const remote = await readRemote();
+            if (!remote || generation !== targetGeneration.current) return null;
+            draftRef.current = remote.draft;
+            lastSavedSignature.current = draftSignature(remote.editable);
+            passiveProjectionSignature.current = null;
+            setDraft(remote.draft);
+            setCurrentConflict(null);
+            setError(null);
+          } catch (cause) {
+            if (generation === targetGeneration.current) setError(asError(cause));
+            return null;
+          }
+        }
+        const flushed = await persistSnapshot(snapshot, true);
+        if (flushed) return flushed;
+        if (!conflictRef.current) return null;
+      }
+      return null;
+    },
+    [persistSnapshot, readRemote, setCurrentConflict, setError]
+  );
+  const isCurrentSignature = useCallback(
+    (signature) => draftSignature(valueRef.current) === signature,
+    []
+  );
+  const acknowledgeConsumed = useCallback(
+    async (flushed, visibleSignature = flushed.signature) => {
+      const current = draftRef.current;
+      if (!current || current.revision !== flushed.revision || lastSavedSignature.current !== flushed.signature) {
+        return null;
+      }
+      if (autosaveTimer.current) clearTimeout(autosaveTimer.current);
+      autosaveTimer.current = null;
+      const generation = targetGeneration.current;
+      const epoch = persistenceEpoch.current + 1;
+      persistenceEpoch.current = epoch;
+      const priorSaves = saveChain.current;
+      setCurrentConflict(null);
+      setError(null);
+      const run = async () => {
+        if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+          return null;
+        }
+        setSaving(true);
+        try {
+          await priorSaves;
+          if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+            return null;
+          }
+          const remote = await readRemote();
+          if (!remote || generation !== targetGeneration.current) return null;
+          const expectedSeedRevision = flushed.revision + 1;
+          if (remote.draft.revision > expectedSeedRevision) {
+            const problem = new Error(
+              "New-session defaults changed in another client while the session was created"
+            );
+            draftRef.current = remote.draft;
+            lastSavedSignature.current = draftSignature(remote.editable);
+            passiveProjectionSignature.current = null;
+            setDraft(remote.draft);
+            setCurrentConflict(problem);
+            setError(problem);
+            return null;
+          }
+          if (remote.draft.revision < expectedSeedRevision) {
+            const problem = new Error("New-session defaults were not seeded yet");
+            setError(problem);
+            return null;
+          }
+          draftRef.current = remote.draft;
+          lastSavedSignature.current = draftSignature(remote.editable);
+          passiveProjectionSignature.current = null;
+          setDraft(remote.draft);
+          const snapshot = cloneEditable(valueRef.current);
+          const signature = draftSignature(snapshot);
+          if (signature === visibleSignature) {
+            draftRef.current = null;
+            lastSavedSignature.current = null;
+            passiveProjectionSignature.current = null;
+            setDraft(null);
+            return { kind: "consumed" };
+          }
+          const saved = await client.saveNewSessionDraft(workspaceId, {
+            ...snapshot,
+            expectedRevision: remote.draft.revision
+          });
+          if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+            return null;
+          }
+          draftRef.current = saved;
+          lastSavedSignature.current = signature;
+          passiveProjectionSignature.current = null;
+          setDraft(saved);
+          setCurrentConflict(null);
+          setError(null);
+          return {
+            kind: "preserved",
+            flushed: { revision: saved.revision, signature }
+          };
+        } catch (cause) {
+          if (generation !== targetGeneration.current || epoch !== persistenceEpoch.current) {
+            return null;
+          }
+          const problem = asError(cause);
+          if (isNewSessionDraftConflict(cause)) setCurrentConflict(problem);
+          setError(problem);
+          return null;
+        } finally {
+          if (generation === targetGeneration.current && epoch === persistenceEpoch.current) {
+            setSaving(false);
+          }
+        }
+      };
+      const operation = saveChain.current.then(run, run);
+      saveChain.current = operation.then(
+        () => void 0,
+        () => void 0
+      );
+      return await operation;
+    },
+    [client, readRemote, setCurrentConflict, setError, workspaceId]
+  );
+  const resolveConflict = useCallback(
+    async (choice) => {
+      if (choice === "use_remote") {
+        await reload();
+        return;
+      }
+      const mine = cloneEditable(valueRef.current);
+      const generation = targetGeneration.current;
+      loadingRef.current = true;
+      setLoading(true);
+      try {
+        const remote = await readRemote();
+        if (!remote || generation !== targetGeneration.current) return;
+        draftRef.current = remote.draft;
+        lastSavedSignature.current = draftSignature(remote.editable);
+        passiveProjectionSignature.current = null;
+        setDraft(remote.draft);
+        setCurrentConflict(null);
+        await persistSnapshot(mine);
+      } catch (cause) {
+        if (generation === targetGeneration.current) setError(asError(cause));
+      } finally {
+        if (generation === targetGeneration.current) {
+          loadingRef.current = false;
+          setLoading(false);
+        }
+      }
+    },
+    [persistSnapshot, readRemote, reload, setCurrentConflict, setError]
+  );
+  const unavailable = error !== null && conflict === null && isTransientServiceFailure(error);
+  const reconnect = useCallback(async () => {
+    if (!resourceHydrationReady) return;
+    const generation = targetGeneration.current;
+    try {
+      const remote = await readRemote(false);
+      if (!remote || generation !== targetGeneration.current) return;
+      if (!draftRef.current && unloadedValueSignature.current !== null && unloadedValueSignature.current === draftSignature(valueRef.current)) {
+        applyRemote(remote);
+        return;
+      }
+      unloadedValueSignature.current = null;
+      draftRef.current = remote.draft;
+      lastSavedSignature.current = draftSignature(remote.editable);
+      passiveProjectionSignature.current = null;
+      setDraft(remote.draft);
+      setError(null);
+    } catch (cause) {
+      if (generation === targetGeneration.current) setError(asError(cause));
+    }
+  }, [applyRemote, readRemote, resourceHydrationReady, setError]);
+  const reconnectRef = useRef(reconnect);
+  reconnectRef.current = reconnect;
+  useEffect(() => {
+    if (!unavailable) return;
+    let stopped = false;
+    let timer;
+    const tick = () => {
+      timer = setTimeout(() => {
+        if (stopped) return;
+        void reconnectRef.current().finally(() => {
+          if (!stopped) tick();
+        });
+      }, reconnectIntervalMs);
+    };
+    tick();
+    return () => {
+      stopped = true;
+      if (timer !== void 0) clearTimeout(timer);
+    };
+  }, [unavailable, reconnectIntervalMs, targetKey]);
+  return {
+    draft,
+    revision: draft?.revision ?? 0,
+    loading,
+    saving,
+    conflict,
+    error,
+    unavailable,
+    currentError: useCallback(() => errorRef.current, []),
+    reportUnavailable: useCallback(
+      (cause) => {
+        if (!isTransientServiceFailure(cause)) return false;
+        setError(asError(cause));
+        return true;
+      },
+      [setError]
+    ),
+    flush,
+    flushForSend,
+    isCurrentSignature,
+    acknowledgeConsumed,
+    reload,
+    captureConflict,
+    resolveConflict,
+    clearError: useCallback(() => {
+      setError(null);
+      setCurrentConflict(null);
+    }, [setCurrentConflict, setError])
+  };
+}
+function cloneEditable(value) {
+  return structuredClone(value);
+}
+function normalizeLegacyNewSessionDraft(remote) {
+  return {
+    ...remote,
+    toolsProvided: Object.hasOwn(remote, "toolsProvided") ? remote.toolsProvided : true,
+    latencyMode: remote.latencyMode ?? "standard",
+    selectionHistory: remote.selectionHistory ?? { projects: [] }
+  };
+}
+function draftSignature(value) {
+  return JSON.stringify(sortedJson(value));
+}
+function sortedJson(value) {
+  if (Array.isArray(value)) return value.map(sortedJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, sortedJson(nested)])
+    );
+  }
+  return value;
+}
+function clientIdentity(client) {
+  let identity = clientIdentities.get(client);
+  if (identity === void 0) {
+    identity = nextClientIdentity;
+    nextClientIdentity += 1;
+    clientIdentities.set(client, identity);
+  }
+  return identity;
+}
+var clientIdentities = /* @__PURE__ */ new WeakMap();
+var nextClientIdentity = 1;
+function isNewSessionDraftConflict(cause) {
+  return cause instanceof OpenGeniApiError2 && cause.status === 409 && cause.code === "NEW_SESSION_DRAFT_CONFLICT";
+}
+function asError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+export {
+  OPENGENI_UPDATING_NOTICE,
+  TRANSIENT_RECONNECT_INTERVAL_MS,
+  TRANSIENT_RETRY_DELAYS_MS,
+  isNewSessionDraftConflict,
+  isTransientServiceFailure,
+  retryTransient,
+  useNewSessionDraft
+};
+//# sourceMappingURL=new-session-draft.js.map