@opengeni/react 0.15.0 → 0.23.0

package/dist/chunk-UQS7OQDE.js

@@ -0,0 +1,591 @@
+import {
+  useEmbeddedSession,
+  useSessionEventTrigger
+} from "./chunk-I3BJZIG5.js";
+
+// src/hooks/use-composer.ts
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+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 [stateTargetKey, setStateTargetKey] = useState(targetKey);
+  const [sending, setSending] = useState(false);
+  const [pausing, setPausing] = useState(false);
+  const [resuming, setResuming] = useState(false);
+  const [error, setError] = useState(null);
+  const [draft, setDraft] = useState(null);
+  const [draftLoading, setDraftLoading] = useState(Boolean(sessionId) && durableDrafts);
+  const [draftSaving, setDraftSaving] = useState(false);
+  const [draftConflict, setDraftConflict] = useState(null);
+  const [restoredResources, setRestoredResources] = useState([]);
+  const pendingClientEventId = useRef(null);
+  const valueRef = useRef("");
+  const draftRef = useRef(null);
+  const restoredResourcesRef = useRef([]);
+  const localEditRevision = useRef(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 sendExtrasRef = useRef(options.sendExtras);
+  sendExtrasRef.current = options.sendExtras;
+  const liveExtrasVersion = JSON.stringify(resolveSendExtras(options.sendExtras));
+  const targetKeyRef = useRef(targetKey);
+  useLayoutEffect(() => {
+    if (targetKeyRef.current === targetKey) return;
+    targetKeyRef.current = targetKey;
+    targetGeneration.current += 1;
+    draftReadGeneration.current += 1;
+    pendingClientEventId.current = null;
+    localEditRevision.current = 0;
+    valueRef.current = "";
+    draftRef.current = null;
+    restoredResourcesRef.current = [];
+    lastSavedSignature.current = null;
+    saveChain.current = Promise.resolve();
+    setStateTargetKey(targetKey);
+    setValue("");
+    setSending(false);
+    setPausing(false);
+    setResuming(false);
+    setError(null);
+    setDraft(null);
+    setDraftLoading(Boolean(sessionId) && durableDrafts);
+    setDraftSaving(false);
+    setDraftConflict(null);
+    setRestoredResources([]);
+  }, [durableDrafts, 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;
+        draftRef.current = null;
+        lastSavedSignature.current = null;
+        setDraft(null);
+        setValue(next.text);
+        setRestoredResources(next.resources);
+        setDraftConflict(null);
+        return;
+      }
+      valueRef.current = next.text;
+      draftRef.current = next;
+      restoredResourcesRef.current = next.resources;
+      lastSavedSignature.current = draftSignature(draftPayload(next));
+      localEditRevision.current += 1;
+      pendingClientEventId.current = null;
+      setDraft(next);
+      setValue(next.text);
+      setRestoredResources(next.resources);
+      setDraftConflict(null);
+      onDraftApplied?.(next);
+    },
+    [durableDrafts, onDraftApplied, targetKey]
+  );
+  const loadDraft = useCallback(
+    async (replaceLocal) => {
+      if (targetKeyRef.current !== targetKey) return;
+      if (!sessionId || !durableDrafts) {
+        setDraftLoading(false);
+        return;
+      }
+      const generation = targetGeneration.current;
+      const readTicket = ++draftReadGeneration.current;
+      const localAtStart = localEditRevision.current;
+      const baseAtStart = draftRef.current;
+      const extrasAtStart = resolveSendExtras(sendExtrasRef.current);
+      const localSignatureAtStart = baseAtStart ? draftSignature(
+        composerDraftPayload(
+          baseAtStart,
+          valueRef.current,
+          restoredResourcesRef.current,
+          extrasAtStart
+        )
+      ) : null;
+      const localWasDirtyAtStart = localSignatureAtStart === null ? localAtStart !== 0 : localSignatureAtStart !== lastSavedSignature.current;
+      setDraftLoading(true);
+      try {
+        const fetched = await client.getComposerDraft(workspaceId, sessionId);
+        if (generation !== targetGeneration.current || targetKeyRef.current !== targetKey || readTicket !== draftReadGeneration.current) {
+          return;
+        }
+        const currentRevision = draftRef.current?.revision ?? -1;
+        if (fetched.revision >= currentRevision) {
+          draftRef.current = fetched;
+          setDraft(fetched);
+          setDraftConflict(null);
+          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);
+          }
+        }
+      } catch (cause) {
+        if (generation === targetGeneration.current && targetKeyRef.current === targetKey && readTicket === draftReadGeneration.current) {
+          setError(asError(cause));
+        }
+      } finally {
+        if (generation === targetGeneration.current && targetKeyRef.current === targetKey && readTicket === draftReadGeneration.current) {
+          setDraftLoading(false);
+        }
+      }
+    },
+    [client, durableDrafts, onDraftApplied, sessionId, targetKey, workspaceId]
+  );
+  useEffect(() => {
+    if (!sessionId || !durableDrafts) {
+      setDraftLoading(false);
+      return;
+    }
+    void loadDraft(false);
+  }, [durableDrafts, loadDraft, sessionId]);
+  useEffect(() => {
+    if (!sessionId || !durableDrafts) return;
+    return registerSessionReconciler(sessionId, "composer", async () => await loadDraft(false));
+  }, [durableDrafts, loadDraft, registerSessionReconciler, sessionId]);
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isComposerDraftEvent,
+    () => void loadDraft(false),
+    {
+      enabled: Boolean(sessionId) && durableDrafts,
+      ...options.events !== void 0 ? { events: options.events } : {}
+    }
+  );
+  const currentDraftPayload = useCallback(() => {
+    if (!durableDrafts || targetKeyRef.current !== targetKey) return null;
+    const base = draftRef.current;
+    if (!base) return null;
+    const extras = resolveSendExtras(sendExtrasRef.current);
+    return composerDraftPayload(base, value, restoredResources, extras);
+  }, [durableDrafts, restoredResources, targetKey, value]);
+  const persistPayload = useCallback(
+    async (payload) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || !durableDrafts || targetKeyRef.current !== ownedTargetKey) {
+        return false;
+      }
+      let success = false;
+      const run = async () => {
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return;
+        }
+        const current = draftRef.current;
+        if (!current) return;
+        const request = { ...payload, expectedRevision: current.revision };
+        const signature = draftSignature(request);
+        if (signature === lastSavedSignature.current) {
+          success = true;
+          return;
+        }
+        setDraftSaving(true);
+        try {
+          const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return;
+          }
+          draftRef.current = saved;
+          setDraft(saved);
+          lastSavedSignature.current = signature;
+          setDraftConflict(null);
+          success = true;
+        } catch (cause) {
+          if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+            const problem = asError(cause);
+            setDraftConflict(problem);
+            setError(problem);
+          }
+        } finally {
+          if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+            setDraftSaving(false);
+          }
+        }
+      };
+      saveChain.current = saveChain.current.then(run, run);
+      await saveChain.current;
+      return success;
+    },
+    [client, durableDrafts, sessionId, targetKey, workspaceId]
+  );
+  useEffect(() => {
+    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);
+  }, [
+    currentDraftPayload,
+    durableDrafts,
+    draftConflict,
+    draftLoading,
+    liveExtrasVersion,
+    persistPayload,
+    sending,
+    sessionId
+  ]);
+  const dispatch = useCallback(
+    async (delivery, explicit) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      const draftAtSend = value;
+      const rawText = explicit ?? draftAtSend;
+      const hasText = rawText.trim().length > 0;
+      const extras = resolveSendExtras(sendExtrasRef.current);
+      const hasResources = restoredResources.length > 0 || (extras.resources?.length ?? 0) > 0;
+      if (!hasText && !hasResources || !sessionId || sending || targetKeyRef.current !== ownedTargetKey) {
+        return false;
+      }
+      pendingClientEventId.current ??= generateClientEventId();
+      setSending(true);
+      setError(null);
+      try {
+        const sendText = hasText ? rawText : FILE_ONLY_MESSAGE_TEXT;
+        const currentPayload = currentDraftPayload();
+        const payload = currentPayload ? { ...currentPayload, text: sendText } : null;
+        if (payload && !await persistPayload(payload)) return false;
+        if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+          return false;
+        }
+        const acknowledgedDraft = draftRef.current;
+        const sendExtras = acknowledgedDraft?.toolsProvided === true && !Object.prototype.hasOwnProperty.call(extras, "tools") ? { ...extras, tools: acknowledgedDraft.tools } : extras;
+        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);
+        }
+        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);
+        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);
+        }
+      }
+    },
+    [
+      client,
+      currentDraftPayload,
+      durableDrafts,
+      onSent,
+      options.effectiveControl?.controlEtag,
+      persistPayload,
+      restoredResources,
+      sending,
+      sessionId,
+      targetKey,
+      value,
+      workspaceId
+    ]
+  );
+  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 pause = useCallback(
+    async (reason) => {
+      const ownedTargetKey = targetKey;
+      const ownedGeneration = targetGeneration.current;
+      if (!sessionId || pausing || targetKeyRef.current !== ownedTargetKey) {
+        return;
+      }
+      setPausing(true);
+      setError(null);
+      try {
+        await client.pauseSession(workspaceId, sessionId, {
+          ...reason !== void 0 ? { reason } : {},
+          ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
+        });
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setPausing(false);
+        }
+      }
+    },
+    [client, workspaceId, sessionId, pausing, options.effectiveControl?.controlEtag, 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 {
+        await client.resumeSession(workspaceId, sessionId, {
+          ...reason !== void 0 ? { reason } : {},
+          ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
+        });
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setResuming(false);
+        }
+      }
+    },
+    [client, workspaceId, sessionId, resuming, options.effectiveControl?.controlEtag, 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 = options.effectiveControl?.blockers.find(
+            (blocker) => blocker.kind === "workspace"
+          );
+          if (!client.setWorkspaceInferenceState) {
+            throw new Error(
+              "@opengeni/react: workspace-scoped resume requires setWorkspaceInferenceState."
+            );
+          }
+          await client.setWorkspaceInferenceState(workspaceId, {
+            action: "resume",
+            clientEventId: generateClientEventId(),
+            ...workspaceBlocker ? { expectedRevision: workspaceBlocker.revision } : {}
+          });
+        } else if (option.scope === "session" && option.targetId) {
+          const target = await client.getQueue(workspaceId, option.targetId);
+          if (targetKeyRef.current !== ownedTargetKey || targetGeneration.current !== ownedGeneration) {
+            return;
+          }
+          await client.resumeSession(workspaceId, option.targetId, {
+            expectedControlEtag: target.effectiveControl.controlEtag
+          });
+        } else {
+          await client.resumeSession(workspaceId, sessionId, {
+            ...options.effectiveControl?.controlEtag ? { expectedControlEtag: options.effectiveControl.controlEtag } : {}
+          });
+        }
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setError(asError(cause));
+        }
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && targetGeneration.current === ownedGeneration) {
+          setResuming(false);
+        }
+      }
+    },
+    [client, options.effectiveControl, resuming, sessionId, targetKey, workspaceId]
+  );
+  const updateValue = useCallback(
+    (next) => {
+      if (targetKeyRef.current !== targetKey) return;
+      pendingClientEventId.current = null;
+      localEditRevision.current += 1;
+      valueRef.current = next;
+      setValue(next);
+    },
+    [targetKey]
+  );
+  const removeRestoredResource = useCallback(
+    (index) => {
+      if (targetKeyRef.current !== targetKey) return;
+      localEditRevision.current += 1;
+      const next = restoredResourcesRef.current.filter((_, candidate) => candidate !== index);
+      restoredResourcesRef.current = next;
+      setRestoredResources(next);
+    },
+    [targetKey]
+  );
+  const hasDraftContent = useCallback(() => {
+    const current = draftRef.current;
+    const extras = resolveSendExtras(sendExtrasRef.current);
+    const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+    const tools = toolsProvidedByHost ? extras.tools ?? [] : current?.tools ?? [];
+    return valueRef.current.length > 0 || restoredResourcesRef.current.length > 0 || (extras.resources?.length ?? 0) > 0 || tools.length > 0 || current?.sourceTurnId !== null && current?.sourceTurnId !== void 0;
+  }, []);
+  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);
+        return;
+      }
+      draftRef.current = remote;
+      setDraft(remote);
+      setDraftConflict(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 reloadDraft = useCallback(async () => await loadDraft(true), [loadDraft]);
+  const clearError = useCallback(() => {
+    if (targetKeyRef.current !== targetKey) return;
+    setError(null);
+    setDraftConflict(null);
+  }, [targetKey]);
+  return {
+    value: identityMatches ? value : "",
+    setValue: updateValue,
+    hasDraftContent,
+    send,
+    steer,
+    sending: identityMatches ? sending : false,
+    canSend: identityMatches && Boolean(sessionId) && !sending && (value.trim().length > 0 || hasReadyResources),
+    pause,
+    pausing: identityMatches ? pausing : false,
+    resume,
+    resumeScope,
+    resuming: identityMatches ? resuming : false,
+    draft: identityMatches ? draft : null,
+    draftRevision: identityMatches ? draft?.revision ?? 0 : 0,
+    draftLoading: identityMatches ? draftLoading : Boolean(sessionId) && durableDrafts,
+    draftSaving: identityMatches ? draftSaving : false,
+    draftConflict: identityMatches ? draftConflict : null,
+    draftPersistence: durableDrafts ? "durable" : "disabled",
+    applyDraft,
+    reloadDraft,
+    resolveDraftConflict,
+    restoredResources: identityMatches ? restoredResources : [],
+    removeRestoredResource,
+    error: identityMatches ? error : null,
+    clearError
+  };
+}
+function isComposerDraftEvent(event) {
+  return event.type === "user.message" || event.type === "session.queue.changed";
+}
+var FILE_ONLY_MESSAGE_TEXT = "(see attached files)";
+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 asError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+function draftPayload(draft) {
+  return {
+    expectedRevision: draft.revision,
+    text: draft.text,
+    resources: draft.resources,
+    tools: draft.tools,
+    toolsProvided: draft.toolsProvided,
+    model: draft.model,
+    reasoningEffort: draft.reasoningEffort
+  };
+}
+function composerDraftPayload(base, text, restoredResources, extras) {
+  const toolsProvidedByHost = Object.prototype.hasOwnProperty.call(extras, "tools");
+  return {
+    expectedRevision: base.revision,
+    text,
+    resources: mergeResources(restoredResources, extras.resources ?? []),
+    tools: toolsProvidedByHost ? extras.tools ?? [] : base.tools,
+    toolsProvided: toolsProvidedByHost ? true : base.toolsProvided,
+    model: extras.model ?? base.model,
+    reasoningEffort: extras.reasoningEffort ?? base.reasoningEffort
+  };
+}
+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 = JSON.stringify(resource);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export {
+  useComposer,
+  FILE_ONLY_MESSAGE_TEXT,
+  composeSendInput,
+  shouldSubmitOnKey,
+  shouldSteerOnKey
+};
+//# sourceMappingURL=chunk-UQS7OQDE.js.map