@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-T6XI5FLY.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  invalidateArtifactCatalog
+} from "./chunk-KZVRXEYR.js";
+import {
+  useNavigate
+} from "./chunk-BXBDYNRP.js";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+
+// src/app/lib/use-duplicate-site.tsx
+import { useRef, useState } from "react";
+function useDuplicateSite(workspaceId) {
+  const { client } = useAppContext();
+  const navigate = useNavigate();
+  const [busy, setBusy] = useState(false);
+  const inFlight = useRef(false);
+  const openCopy = (copy) => void navigate({
+    to: "/workspaces/$workspaceId/sites/$siteId",
+    params: { workspaceId, siteId: copy.id }
+  });
+  const duplicate = async (site, { open = true } = {}) => {
+    if (inFlight.current) return null;
+    inFlight.current = true;
+    setBusy(true);
+    try {
+      const { artifact: copy } = await client.duplicateWorkspaceArtifact(workspaceId, site.id, {
+        idempotencyKey: crypto.randomUUID()
+      });
+      invalidateArtifactCatalog(client, workspaceId);
+      if (open) {
+        toast(`Duplicated as \u201C${copy.title}\u201D`);
+        openCopy(copy);
+      } else {
+        toast(`Duplicated as \u201C${copy.title}\u201D`, {
+          action: { label: "Open", onClick: () => openCopy(copy) }
+        });
+      }
+      return copy;
+    } catch (error) {
+      toast.error("Couldn't duplicate the Site", { description: userErrorText(error) });
+      return null;
+    } finally {
+      inFlight.current = false;
+      setBusy(false);
+    }
+  };
+  return { duplicate, busy };
+}
+
+export {
+  useDuplicateSite
+};
+//# sourceMappingURL=chunk-T6XI5FLY.js.map

package/dist/chunk-T7OXJZCX.js

@@ -0,0 +1,62 @@
+"use client";
+import {
+  CHECKOUT_RETURN_QUERY,
+  readCheckoutPageReturn
+} from "./chunk-H7D7ZA6J.js";
+import {
+  hasAccountPermission
+} from "./chunk-H2ALCTWC.js";
+import {
+  usePage
+} from "./chunk-BXBDYNRP.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+
+// src/app/components/credit-required-gate.tsx
+import { lazy, Suspense, useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var CreditRequiredPrompt = lazy(
+  () => import("./app/components/credit-required-prompt.js").then((module) => ({
+    default: module.CreditRequiredPrompt
+  }))
+);
+function CreditRequiredGate(props) {
+  const { creditRequired, setCreditRequired, accessContext } = props;
+  useCheckoutPageReturn();
+  if (!creditRequired) return null;
+  return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+    CreditRequiredPrompt,
+    {
+      open: true,
+      workspaceId: creditRequired.workspaceId,
+      accountId: creditRequired.accountId,
+      refusalCode: creditRequired.code ?? null,
+      canBuyCredits: Boolean(creditRequired.accountId) && hasAccountPermission(accessContext, creditRequired.accountId ?? "", "billing:manage"),
+      onOpenChange: (open) => {
+        if (!open) setCreditRequired(null);
+      }
+    }
+  ) });
+}
+function useCheckoutPageReturn() {
+  const page = usePage();
+  const client = useAppContext().client;
+  const [query] = useState(() => page.readQuery());
+  useEffect(() => {
+    if (!query.has(CHECKOUT_RETURN_QUERY.outcome)) return;
+    const checkout = readCheckoutPageReturn(query);
+    const current = page.readQuery();
+    for (const key of Object.values(CHECKOUT_RETURN_QUERY)) current.delete(key);
+    page.replaceQuery(current, { keepHistoryState: true });
+    if (!checkout) return;
+    void import("./app/components/credits/checkout-return.js").then(
+      ({ followCheckoutPageReturn }) => followCheckoutPageReturn(client, checkout)
+    );
+  }, []);
+}
+
+export {
+  CreditRequiredGate
+};
+//# sourceMappingURL=chunk-T7OXJZCX.js.map

package/dist/chunk-TAT5USZN.js

@@ -0,0 +1,353 @@
+"use client";
+import {
+  attemptHint,
+  useConnect
+} from "./chunk-IMDQUHBJ.js";
+import {
+  attachSessionCapability
+} from "./chunk-52Y2X66Q.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/components/integration-capability-connect-flow.ts
+import {
+  authorizeConnectAttempt,
+  ConnectController,
+  ConnectPopupClosedError
+} from "@opengeni/connect";
+import { integrationDefinitionIdFromCapabilityId } from "@opengeni/contracts";
+import { useEffect, useRef, useState } from "react";
+var RESTARTABLE = /* @__PURE__ */ new Set(["failed", "cancelled", "expired"]);
+var SetupCancelled = class extends Error {
+};
+var SignInReopened = class extends Error {
+};
+var SignInHandedOff = class extends Error {
+};
+var SignInBlocked = class extends Error {
+};
+var stepOf = (attempt) => attempt ? `${attempt.id}:${attempt.state}` : "none";
+function ownInstances(integrations, definitionId) {
+  return integrations.filter(
+    (instance) => instance.definitionId === definitionId && instance.ownership === "personal"
+  );
+}
+function reconnectCandidate(integrations, definitionId) {
+  const disconnected = ownInstances(integrations, definitionId).filter(
+    (instance) => !instance.connected
+  );
+  const lastUsed = (instance) => instance.connectionLastUsedAt ? Date.parse(instance.connectionLastUsedAt) || 0 : 0;
+  return [...disconnected].sort(
+    (left, right) => lastUsed(right) - lastUsed(left) || left.instanceKey.localeCompare(right.instanceKey)
+  )[0] ?? null;
+}
+function useIntegrationCapabilityConnect({
+  client,
+  workspaceId,
+  sessionId,
+  capabilityId,
+  name,
+  returnUrl,
+  windows,
+  onConfigured
+}) {
+  const t = useOpenGeniText();
+  const definitionId = integrationDefinitionIdFromCapabilityId(capabilityId) ?? capabilityId;
+  const [controller] = useState(
+    () => new ConnectController(client.connectTransport(), workspaceId)
+  );
+  const view = useConnect(controller);
+  const attempt = view.attempt;
+  const [availability, setAvailability] = useState({
+    kind: "loading"
+  });
+  const [reloads, setReloads] = useState(0);
+  const [busy, setBusy] = useState(false);
+  const [waiting, setWaiting] = useState(false);
+  const [error, setError] = useState(null);
+  const [signInClosed, setSignInClosed] = useState(false);
+  const [leftOpen, setLeftOpen] = useState(false);
+  const [windowGone, setWindowGone] = useState(false);
+  const [messageStep, setMessageStep] = useState("none");
+  const [chatAccessFailed, setChatAccessFailed] = useState(false);
+  const [notRequester, setNotRequester] = useState(false);
+  const lifetime = useRef(null);
+  const authorization = useRef(null);
+  const signInWindow = useRef(null);
+  const finished = useRef(null);
+  const configured = useRef(onConfigured);
+  configured.current = onConfigured;
+  const windowHost = useRef(windows);
+  windowHost.current = windows;
+  const hints = windows.hints ?? attemptHint;
+  const storageKey = `opengeni:session-integration-connect:${workspaceId}:${sessionId}:${capabilityId}`;
+  const pin = () => setMessageStep(stepOf(controller.getSnapshot().attempt));
+  const clearMessages = () => {
+    setError(null);
+    setSignInClosed(false);
+    setLeftOpen(false);
+    setWindowGone(false);
+  };
+  useEffect(() => {
+    if (!waiting && !leftOpen) return;
+    const timer = setInterval(() => {
+      if (signInWindow.current?.isOpen?.() !== false) return;
+      setLeftOpen(false);
+      if (waiting) setWindowGone(true);
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, [waiting, leftOpen]);
+  useEffect(() => {
+    const abort = new AbortController();
+    lifetime.current = abort;
+    const live = () => !abort.signal.aborted;
+    setAvailability({ kind: "loading" });
+    void (async () => {
+      void (controller.transport.finishUnfinished?.(workspaceId, { signal: abort.signal }) ?? Promise.resolve([])).then(async (finishedNow) => {
+        const leftover = finishedNow.find((entry) => entry.providerId === definitionId);
+        if (!leftover || !live()) return;
+        const current2 = controller.getSnapshot().attempt;
+        if (current2 && current2.id !== leftover.id && !RESTARTABLE.has(current2.state)) return;
+        await controller.recover(leftover.id);
+      }).catch(() => void 0);
+      const [providers, installed] = await Promise.all([
+        controller.transport.catalog(workspaceId, { signal: abort.signal }),
+        client.listApiIntegrations(workspaceId)
+      ]);
+      if (!live()) return;
+      const connectedNow = ownInstances(installed.integrations, definitionId).some(
+        (instance) => instance.connected
+      );
+      const saved = hints.read(storageKey);
+      if (saved) {
+        const recovered = await controller.recover(saved).catch(() => null);
+        if (!live()) return;
+        if (recovered?.state === "complete" && recovered.integrationInstalled) return;
+        if (!recovered || connectedNow) hints.forget(storageKey);
+      }
+      if (connectedNow) {
+        setAvailability({ kind: "connected" });
+        return;
+      }
+      const provider = providers.find((entry) => entry.id === definitionId);
+      if (!provider || provider.readiness !== "available") {
+        setAvailability({
+          kind: "unavailable",
+          reason: provider?.readiness === "unsupported" ? t("sessionIntegrationCapabilityCard.noPermission", { name }) : t("sessionIntegrationCapabilityCard.notSetUp", { name })
+        });
+        return;
+      }
+      if (!provider.ownership.includes("personal")) {
+        setAvailability({
+          kind: "unavailable",
+          reason: t("sessionIntegrationCapabilityCard.personalUnavailable", { name })
+        });
+        return;
+      }
+      setAvailability((shown) => shown.kind === "connected" ? shown : { kind: "ready" });
+    })().catch(() => {
+      if (live()) setAvailability({ kind: "error" });
+    });
+    return () => {
+      abort.abort();
+      authorization.current?.abort();
+    };
+  }, [reloads]);
+  const attemptState = attempt?.state;
+  useEffect(() => {
+    if (attemptState && RESTARTABLE.has(attemptState)) hints.forget(storageKey);
+  }, [attemptState, hints, storageKey]);
+  useEffect(() => {
+    if (!attempt || attempt.state !== "complete" || !attempt.integrationInstalled) return;
+    if (finished.current === attempt.id) return;
+    finished.current = attempt.id;
+    const live = () => !lifetime.current?.signal.aborted;
+    void (async () => {
+      hints.forget(storageKey);
+      const instances = ownInstances(
+        (await client.listApiIntegrations(workspaceId)).integrations,
+        definitionId
+      ).filter((instance) => instance.connected);
+      for (const instance of instances) {
+        await attachSessionCapability(
+          t,
+          client,
+          workspaceId,
+          sessionId,
+          {
+            kind: "api",
+            tools: [{ kind: "mcp", id: instance.serverId, optional: true }],
+            runtime: { available: true, notes: null },
+            metadata: {}
+          },
+          live
+        );
+      }
+      void Promise.resolve().then(() => client.continueAfterCapabilitySetup(workspaceId, sessionId, { capabilityId })).then((result) => {
+        if (live() && result.outcome === "not_needed" && result.reason === "not_requester")
+          setNotRequester(true);
+      }).catch(() => void 0);
+    })().catch(() => {
+      if (live()) setChatAccessFailed(true);
+    }).finally(() => {
+      if (!live()) return;
+      setAvailability({ kind: "connected" });
+      void Promise.resolve(configured.current?.()).catch(() => {
+      });
+    });
+  }, [attempt, client, workspaceId, sessionId, capabilityId, definitionId, storageKey, hints, t]);
+  async function authorize(next, navigation) {
+    const pending = new AbortController();
+    authorization.current = pending;
+    clearMessages();
+    setWaiting(true);
+    let blocked = false;
+    const watched = {
+      openPopup(url) {
+        const popup = navigation.openPopup(url);
+        if (!popup) blocked = true;
+        signInWindow.current = popup;
+        return popup;
+      },
+      redirect: (url) => navigation.redirect(url)
+    };
+    const following = {
+      async get(...args) {
+        const latest = await controller.transport.get(...args);
+        if (latest.nextAction.type === "wait" && (latest.nextAction.userCode || latest.nextAction.verificationUrl))
+          pending.abort(new SignInHandedOff());
+        return latest;
+      }
+    };
+    try {
+      try {
+        const result = await authorizeConnectAttempt(following, next, watched, {
+          mode: "popup",
+          signal: pending.signal
+        });
+        if (result && !pending.signal.aborted) await controller.recover(result.id);
+      } catch (failure) {
+        if (blocked) throw new SignInBlocked();
+        const reason = pending.signal.aborted ? pending.signal.reason : failure;
+        if (reason instanceof SignInHandedOff) {
+          await controller.recover(next.id);
+          return;
+        }
+        if (reason instanceof SignInReopened) return;
+        if (reason instanceof SetupCancelled) {
+          await controller.cancel(crypto.randomUUID()).catch(() => controller.recover(next.id)).catch(() => void 0);
+          if (lifetime.current?.signal.aborted === false && signInWindow.current?.isOpen?.()) {
+            setLeftOpen(true);
+            pin();
+          }
+          return;
+        }
+        throw failure;
+      }
+    } finally {
+      if (authorization.current === pending) {
+        authorization.current = null;
+        setWaiting(false);
+      }
+    }
+  }
+  function reportFailure(failure) {
+    if (!lifetime.current || lifetime.current.signal.aborted) return;
+    if (failure instanceof ConnectPopupClosedError) setSignInClosed(true);
+    else if (failure instanceof SignInBlocked) setError(t("connectWindowHost.allowPopups"));
+    else setError(t("sessionIntegrationCapabilityCard.signInFailed"));
+    pin();
+  }
+  function start() {
+    if (busy || availability.kind !== "ready") return;
+    clearMessages();
+    let reserved;
+    try {
+      reserved = windowHost.current.reserve();
+    } catch {
+      setError(t("connectWindowHost.allowPopups"));
+      pin();
+      return;
+    }
+    setBusy(true);
+    let signingIn = false;
+    void (async () => {
+      const existing = reconnectCandidate(
+        (await client.listApiIntegrations(workspaceId)).integrations,
+        definitionId
+      );
+      const begun = await controller.begin({
+        providerId: definitionId,
+        ownership: "personal",
+        returnUrl,
+        // A browser popup ends on a page that closes itself instead of
+        // loading this page a second time; a phone returns to the app.
+        ...windowHost.current.finishInPopup ? { finishInPopup: true } : {},
+        idempotencyKey: crypto.randomUUID(),
+        ...existing?.connectionId ? { reconnectAccountId: existing.connectionId } : {},
+        // A new account gets a fresh instance the server names after the
+        // attempt, so connecting can never overwrite someone else's.
+        ...existing ? {
+          installationTarget: {
+            instanceKey: existing.instanceKey,
+            displayName: existing.displayName,
+            expectedInstanceVersion: existing.instanceVersion
+          }
+        } : {}
+      });
+      hints.remember(storageKey, begun.id);
+      if (begun.nextAction.type !== "authorize") return;
+      signingIn = true;
+      await authorize(begun, reserved.navigation);
+    })().catch((failure) => {
+      if (signingIn) reportFailure(failure);
+      else if (lifetime.current && !lifetime.current.signal.aborted) {
+        setError(t("sessionIntegrationCapabilityCard.couldNotStart"));
+        pin();
+      }
+    }).finally(() => {
+      reserved.close();
+      setBusy(false);
+    });
+  }
+  const current = messageStep === stepOf(attempt);
+  return {
+    controller,
+    attempt,
+    availability,
+    busy,
+    waiting,
+    signInWindowGone: waiting && windowGone,
+    error: current ? error : null,
+    signInClosed: current && signInClosed,
+    notice: !current ? null : signInClosed ? t("connectSetup.signInWindowClosed") : leftOpen ? t("sessionIntegrationCapabilityCard.closeSignInWindow") : null,
+    chatAccessFailed,
+    notRequester,
+    restartable: !!attempt && RESTARTABLE.has(attempt.state),
+    start,
+    authorizeAttempt: (next) => authorize(next, windowHost.current.open()).catch(reportFailure),
+    stopWaiting: () => {
+      clearMessages();
+      authorization.current?.abort(new SetupCancelled());
+    },
+    reopenSignIn: () => {
+      const waitingOn = controller.getSnapshot().attempt;
+      if (!authorization.current || waitingOn?.nextAction.type !== "authorize") return;
+      const shown = signInWindow.current;
+      if (shown?.isOpen?.()) {
+        shown.focus?.();
+        return;
+      }
+      authorization.current.abort(new SignInReopened());
+      void authorize(waitingOn, windowHost.current.open()).catch(reportFailure);
+    },
+    reload: () => setReloads((value) => value + 1)
+  };
+}
+
+export {
+  reconnectCandidate,
+  useIntegrationCapabilityConnect
+};
+//# sourceMappingURL=chunk-TAT5USZN.js.map

package/dist/chunk-TPQTRNER.js

@@ -0,0 +1,172 @@
+"use client";
+import {
+  setTurnFailureStepSink
+} from "./chunk-3QAINO5E.js";
+import {
+  classifyProviderFailure,
+  failedSessionCopy
+} from "./chunk-2BDT3UZQ.js";
+import {
+  captureAnalyticsEvent
+} from "./chunk-55S3W7RZ.js";
+
+// src/app/lib/turn-failure-analytics.tsx
+var TURN_FAILURE_CLASSES = [
+  "credits_exhausted",
+  "provider_credentials",
+  "provider_billing",
+  "provider_access",
+  "daily_limit",
+  "monthly_limit",
+  "provider_quota",
+  "rate_limited",
+  "provider_error",
+  "model_unavailable",
+  "codex_account",
+  "safety_refusal",
+  "sandbox",
+  "mcp",
+  "context_limit",
+  "connectivity",
+  "pre_start",
+  "other"
+];
+var TURN_FAILURE_ACTIONS = [
+  "retry",
+  "switch_model",
+  "buy_credits",
+  "upgrade_plan",
+  "connect_model",
+  "new_session",
+  "send_message",
+  "left"
+];
+var TURN_FAILURE_HIDDEN_LEFT_MS = 5 * 6e4;
+function turnFailureClass(failure, creditExhausted = false) {
+  if (failure.structuralSandboxFailure) return "sandbox";
+  if (creditExhausted) return "credits_exhausted";
+  if (failure.safetyRefusal) return "safety_refusal";
+  const code = failure.failureCode ?? "";
+  if (code.startsWith("codex_")) return "codex_account";
+  if (failedSessionCopy(failure).unavailableModel) return "model_unavailable";
+  const known = classifyProviderFailure(
+    failure.recordedDetail ?? failure.reason ?? "",
+    failure.failureCode,
+    failure.quotaScope
+  );
+  if (known) return known.kind;
+  if (code.startsWith("sandbox_") || !code && failure.sandboxStartFailed) return "sandbox";
+  if (code.startsWith("mcp_")) return "mcp";
+  if (code.startsWith("context_") || code.includes("compaction")) return "context_limit";
+  if (code === "upstream_connectivity_unavailable") return "connectivity";
+  if (code === "pre_claim_failure") return "pre_start";
+  return "other";
+}
+function createTurnFailureJourney(options = {}) {
+  const capture = options.capture ?? ((name, properties) => void captureAnalyticsEvent(name, properties));
+  const setTimer = options.setTimer ?? ((callback, ms) => setTimeout(callback, ms));
+  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  const hiddenLeftMs = options.hiddenLeftMs ?? TURN_FAILURE_HIDDEN_LEFT_MS;
+  const seen = [];
+  let active = null;
+  let hiddenTimer = null;
+  const pendingDismissals = /* @__PURE__ */ new Map();
+  const send = (name, properties) => {
+    try {
+      capture(name, properties);
+    } catch {
+    }
+  };
+  const stopHiddenTimer = () => {
+    if (hiddenTimer !== null) clearTimer(hiddenTimer);
+    hiddenTimer = null;
+  };
+  const finish = (action) => {
+    if (!active) return;
+    const { failureClass } = active;
+    active = null;
+    stopHiddenTimer();
+    send("turn_failure_action", { failure_class: failureClass, action });
+  };
+  return {
+    viewed(failureKey, failureClass) {
+      const pending = pendingDismissals.get(failureKey);
+      if (pending !== void 0) {
+        clearTimer(pending);
+        pendingDismissals.delete(failureKey);
+      }
+      if (active?.key === failureKey) return;
+      if (seen.includes(failureKey)) return;
+      seen.push(failureKey);
+      if (seen.length > 50) seen.shift();
+      if (active) finish("left");
+      active = { key: failureKey, failureClass };
+      send("turn_failure_viewed", { failure_class: failureClass });
+    },
+    action(action, failureKey) {
+      if (!active || failureKey !== void 0 && failureKey !== active.key) return;
+      finish(action);
+    },
+    dismissed(failureKey) {
+      if (active?.key !== failureKey || pendingDismissals.has(failureKey)) return;
+      pendingDismissals.set(
+        failureKey,
+        setTimer(() => {
+          pendingDismissals.delete(failureKey);
+          if (active?.key === failureKey) finish("left");
+        }, 0)
+      );
+    },
+    visibilityChanged(hidden) {
+      stopHiddenTimer();
+      if (!hidden || !active) return;
+      hiddenTimer = setTimer(() => {
+        hiddenTimer = null;
+        finish("left");
+      }, hiddenLeftMs);
+    },
+    pageHidden() {
+      finish("left");
+    },
+    activeKey() {
+      return active?.key ?? null;
+    }
+  };
+}
+var journey = null;
+var listenersInstalled = false;
+function turnFailureJourney() {
+  if (!journey) {
+    journey = createTurnFailureJourney();
+    setTurnFailureStepSink((step) => journey?.action(step));
+  }
+  if (!listenersInstalled && typeof document !== "undefined") {
+    listenersInstalled = true;
+    document.addEventListener(
+      "visibilitychange",
+      () => journey?.visibilityChanged(document.visibilityState === "hidden")
+    );
+    window.addEventListener("pagehide", () => journey?.pageHidden());
+    document.addEventListener(
+      "click",
+      (event) => {
+        const target = event.target instanceof Element ? event.target : null;
+        if (target?.closest('[data-analytics-action="new_session"]')) {
+          journey?.action("new_session");
+        }
+      },
+      { capture: true }
+    );
+  }
+  return journey;
+}
+
+export {
+  TURN_FAILURE_CLASSES,
+  TURN_FAILURE_ACTIONS,
+  TURN_FAILURE_HIDDEN_LEFT_MS,
+  turnFailureClass,
+  createTurnFailureJourney,
+  turnFailureJourney
+};
+//# sourceMappingURL=chunk-TPQTRNER.js.map