@opengeni/react 0.57.0 → 1.0.2-canary.37191796234001

package/src/session-capability-policy.ts

@@ -0,0 +1,83 @@
+import type { FirstPartyMcpToolName, CapabilityCatalogItem } from "@opengeni/sdk";
+import type { OpenGeniBrowserClient as OpenGeniClient } from "@opengeni/sdk/browser";
+
+/** Catalog tool discovery may be lazy; selecting the installed server does not
+ * require its individual tool inventory to have been fetched. */
+export function sessionCapabilityTools(item: CapabilityCatalogItem) {
+  const serverId = item.kind === "mcp" ? item.runtime?.mcpServerId : undefined;
+  return serverId && !item.tools.some((tool) => tool.kind === "mcp" && tool.id === serverId)
+    ? [...item.tools, { kind: "mcp" as const, id: serverId }]
+    : item.tools;
+}
+
+/** A connection never resets the human's existing tool selection. Default-mode
+ * sessions discover newly enabled servers at admission; explicit/inherited
+ * policies add only this reviewed capability, with the existing CAS fence. */
+export async function attachSessionCapability(
+  client: OpenGeniClient,
+  workspaceId: string,
+  sessionId: string,
+  item: CapabilityCatalogItem,
+  stillCurrent: () => boolean = () => true,
+): Promise<void> {
+  const tools = sessionCapabilityTools(item);
+  if (item.kind === "skill" || tools.length === 0) return;
+  if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+  const session = await client.getSession(workspaceId, sessionId);
+  if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+  // Session.tools includes mandatory runtime servers, which must never be
+  // echoed into the human's explicit selection.
+  let existing = session.tools.filter(
+    (tool) => !session.effectiveToolPolicy?.mandatoryIds?.includes(tool.id),
+  );
+  if (session.toolPolicy.mode === "workspace_default") {
+    const policy = session.effectiveToolPolicy;
+    if (!policy || policy.idsTruncated)
+      throw new Error(
+        "Connected, but the full session tool selection could not be read. Review the Tools picker before continuing.",
+      );
+    // A workspace may choose a restricted default instead of all enabled servers.
+    // Preserve that exact selection if this connection needs an explicit addition.
+    // selectedIds contains only explicit additions, and is normally empty for
+    // automatic selection. Compare against the resolved defaults instead.
+    existing = policy.effectiveIds
+      .filter((id) => !policy.mandatoryIds.includes(id))
+      .map((id) => ({ kind: "mcp" as const, id }));
+  }
+  const additions = tools.filter(
+    (tool) => !existing.some((current) => current.kind === tool.kind && current.id === tool.id),
+  );
+  const recommended = Array.isArray(item.metadata?.firstPartyMcpTools)
+    ? (item.metadata.firstPartyMcpTools.filter(
+        (name): name is string => typeof name === "string",
+      ) as FirstPartyMcpToolName[])
+    : [];
+  const firstParty = [...new Set([...session.firstPartyMcpTools, ...recommended])];
+  if (additions.length === 0 && firstParty.length === session.firstPartyMcpTools.length) return;
+  await client.updateSessionToolPolicy(workspaceId, sessionId, {
+    mode: "explicit",
+    tools: [...existing, ...additions],
+    firstPartyMcpTools: firstParty,
+    expectedVersion: session.toolPolicyVersion,
+  });
+}
+
+/** Native OAuth callbacks have already saved the provider connection. Finish
+ * the separate, version-fenced session tool selection before reporting success. */
+export async function completeSessionCapabilityOAuth(
+  client: OpenGeniClient,
+  workspaceId: string,
+  sessionId: string,
+  capabilityId: string | null,
+): Promise<void> {
+  if (!capabilityId)
+    throw new Error(
+      "The authorized integration could not be identified. Review its connection card to finish setup.",
+    );
+  const connected = (await client.listCapabilities(workspaceId)).items.find(
+    (item) => item.id === capabilityId,
+  );
+  if (!connected?.enabled)
+    throw new Error("The connection was authorized, but enabling its tools could not be verified.");
+  await attachSessionCapability(client, workspaceId, sessionId, connected);
+}

package/src/session-context.ts

@@ -316,6 +316,7 @@ export function useEmbeddedSession(
       "streamEvents",
       "getComposerDraft",
       "saveComposerDraft",
+      "submitComposerDraft",
       "sendMessage",
       "steerMessage",
       "getQueue",

package/src/session-ui.ts

@@ -8,11 +8,40 @@ export type {
   HumanInputFormProps,
 } from "./components/human-input-form";
 export { HumanInputSurface } from "./components/human-input-surface";
+export { ApprovalSurface } from "./components/approval-surface";
+export type { ApprovalSurfaceProps, ApprovalSurfaceMessages } from "./components/approval-surface";
 export type { HumanInputSurfaceProps } from "./components/human-input-surface";
 export { MessageTimeline, TimelineRow } from "./components/message-timeline";
 export type { MessageTimelineProps } from "./components/message-timeline";
+export type { RenderAllowanceExhausted } from "./timeline/allowance-exhausted-row";
+export type { AllowanceLabels, AllowanceScope } from "./usage/allowance-copy";
+export {
+  OpenGeniLinkProvider,
+  chainLinkResolvers,
+  sessionLinkResolver,
+  useOpenGeniLinkResolver,
+  viewerLinkResolver,
+} from "./components/open-geni-links";
+export type {
+  OpenGeniLinkResolution,
+  OpenGeniLinkResolver,
+  OpenGeniLinkTarget,
+  OpenGeniViewerTarget,
+} from "./components/open-geni-links";
+export { parseOpenGeniLink } from "@opengeni/sdk";
+export {
+  ArtifactLabelsProvider,
+  DEFAULT_ARTIFACT_LABELS,
+  type ArtifactLabels,
+} from "./components/artifacts/artifact-chrome";
+export type { TimelineSearchTarget } from "./components/timeline-search";
+export { createOlderHistoryLoadReceipt } from "./older-history";
+export type { OlderHistoryLoader, OlderHistoryLoadReceipt } from "./older-history";
 export { UserMessageBody, userMessageLikelyNeedsDisclosure } from "./components/user-message-body";
-export type { UserMessageBodyProps } from "./components/user-message-body";
+export type {
+  UserMessageBodyProps,
+  UserMessageDisclosureLabels,
+} from "./components/user-message-body";
 export { BUILT_IN_TURN_SUMMARY_FACET_IDS } from "./timeline/turn-summary";
 export type {
   BuiltInTurnSummaryFacetId,
@@ -23,11 +52,46 @@ export type {
   TurnSummaryOptions,
 } from "./timeline/turn-summary";
 export { QueueSurface } from "./components/queue-surface";
+// The provider too, so a host needs only this entry (the root also exports the
+// workbench, whose editors, terminal and desktop are optional peers).
+export { OpenGeniProvider } from "./provider";
+export type { OpenGeniProviderProps, ErrorMessageFormatter } from "./provider";
+// The tool-renderer registry, so custom tool renderers need no root import.
+export { createDefaultToolRegistry, createToolRegistry, defaultToolRegistry } from "./timeline";
+export type {
+  CreateToolRegistryOptions,
+  ToolRegistry,
+  ToolRegistryEntry,
+  ToolRenderer,
+  ToolRendererProps,
+} from "./timeline";
+export { SessionConversation } from "./components/session-conversation";
+export { SessionList } from "./components/session-list";
+export type { SessionListLabels, SessionListProps } from "./components/session-list";
+export { OpenGeniChat } from "./components/open-geni-chat";
+export type { OpenGeniChatLabels, OpenGeniChatProps } from "./components/open-geni-chat";
+export type {
+  SessionConversationLabels,
+  SessionConversationProps,
+} from "./components/session-conversation";
 export type { QueueSurfaceProps } from "./components/queue-surface";
-export { SessionChrome, sessionChromeGoalPillState } from "./components/session-chrome";
+export {
+  SessionChrome,
+  sessionChromeGoalPillExplanation,
+  sessionChromeGoalPillLabel,
+  sessionChromeGoalPillState,
+} from "./components/session-chrome";
 export type {
   SessionChromeAgentsSignal,
   SessionChromeProps,
   SessionChromeSignalId,
   SessionChromeSignalTone,
 } from "./components/session-chrome";
+export { SessionCommandsPanel } from "./components/session-commands-panel";
+export { SessionCommands } from "./components/session-commands";
+
+export { KnowledgeActivityProvider } from "./timeline/knowledge-receipt";
+export type { KnowledgeActivityActions } from "./timeline/knowledge-receipt";
+export { StartupTimings } from "./timeline/startup-timings";
+export { useStartupDetails, setStartupDetails } from "./timeline/startup-preference";
+export type { GenieLoadingOptions } from "./timeline/genie-loading";

package/src/session.ts

@@ -22,6 +22,12 @@ export type {
   EmbeddedSessionReadClientOverride as SessionReadClientOverride,
   EmbeddedSessionClientOverride as ClientOverride,
 } from "./session-context";
+export { createEmbeddedSessionClient } from "./embedded-session-client";
+export { conversationTimeline } from "./conversation-timeline";
+export type {
+  ComposerDraftMapContext,
+  CreateEmbeddedSessionClientOptions,
+} from "./embedded-session-client";
 
 export { useSession, isTitleEvent } from "./hooks/use-session";
 export type { UseSessionOptions, UseSessionResult } from "./hooks/use-session";
@@ -31,6 +37,8 @@ export type {
   UseSessionEventsOptions,
   UseSessionEventsResult,
 } from "./hooks/use-session-events";
+export { createOlderHistoryLoadReceipt } from "./older-history";
+export type { OlderHistoryLoader, OlderHistoryLoadReceipt } from "./older-history";
 export {
   useComposer,
   composeSendInput,
@@ -38,7 +46,13 @@ export {
   shouldSubmitOnKey,
   FILE_ONLY_MESSAGE_TEXT,
 } from "./hooks/use-composer";
-export type { ComposerSendExtras, ComposerState, UseComposerOptions } from "./hooks/use-composer";
+export type {
+  ComposerControllerState,
+  ComposerPolicy,
+  ComposerSendExtras,
+  ComposerState,
+  UseComposerOptions,
+} from "./hooks/use-composer";
 export { useFileAttachments } from "./hooks/use-file-attachments";
 export type {
   FileAttachment,
@@ -91,11 +105,14 @@ export {
   sessionStatusFromEvents,
   toolDisplayName,
 } from "./timeline/projection";
+export type { GroupTimelineOptions } from "./timeline/projection";
 export type {
   ActivityItem,
   AgentMessageItem,
   AuthNeededItem,
   GoalItem,
+  HumanInputAnswerSummary,
+  HumanInputItem,
   MachineInputBatchItem,
   MachineInputMember,
   MemoryItem,

package/src/sites-ui.tsx

@@ -0,0 +1,402 @@
+import { useEffect, useRef, useState } from "react";
+import type {
+  OpenGeniClient,
+  WorkspaceArtifact,
+  WorkspaceArtifactContentResponse,
+  WorkspaceArtifactDetailResponse,
+  WorkspaceArtifactListResponse,
+} from "@opengeni/sdk";
+import {
+  PublishedHtmlArtifactFrame,
+  type PublishedHtmlArtifactToolBridge,
+} from "./components/artifacts/published-html-artifact-frame";
+
+/** Implement with an authenticated host proxy. Never put an organization key
+ * in browser props; replace the client object when the host actor changes. */
+export type SiteClient = Pick<
+  OpenGeniClient,
+  | "listWorkspaceArtifacts"
+  | "getWorkspaceArtifact"
+  | "getWorkspaceArtifactHtml"
+  | "rollbackWorkspaceArtifact"
+  | "setWorkspaceArtifactStatus"
+>;
+type SiteDisplayContent = Pick<
+  WorkspaceArtifactContentResponse,
+  "artifactId" | "versionId" | "html" | "requestedTools"
+>;
+type SiteScope = { client: SiteClient; workspaceId: string; className?: string };
+/** Shared native/embedded read boundary: pin content to the observed version,
+ * and never accept a response belonging to another workspace or Site. */
+export async function loadSiteSnapshot(
+  client: Pick<SiteClient, "getWorkspaceArtifact" | "getWorkspaceArtifactHtml"> &
+    Partial<Pick<OpenGeniClient, "getWorkspaceArtifactContent">>,
+  workspaceId: string,
+  siteId: string,
+  options: { signal?: AbortSignal; includeArchivedContent?: boolean; versionId?: string } = {},
+): Promise<{
+  detail: WorkspaceArtifactDetailResponse;
+  content: SiteDisplayContent | null;
+}> {
+  const requestOptions = options.signal ? { signal: options.signal } : {};
+  const detail = await client.getWorkspaceArtifact(workspaceId, siteId, requestOptions);
+  options.signal?.throwIfAborted();
+  if (detail.artifact.id !== siteId || detail.artifact.workspaceId !== workspaceId)
+    throw new Error("Site scope mismatch");
+  const selectedVersion = options.versionId
+    ? detail.versions.find((version) => version.id === options.versionId)
+    : detail.artifact.currentVersion;
+  const versionId = options.versionId ?? selectedVersion?.id;
+  let content: SiteDisplayContent | null =
+    selectedVersion &&
+    versionId &&
+    (detail.artifact.status === "active" || options.includeArchivedContent)
+      ? {
+          artifactId: siteId,
+          versionId,
+          requestedTools: selectedVersion!.requestedTools,
+          html: await client.getWorkspaceArtifactHtml(workspaceId, siteId, {
+            ...requestOptions,
+            versionId,
+          }),
+        }
+      : null;
+  if (
+    versionId &&
+    !selectedVersion &&
+    (detail.artifact.status === "active" || options.includeArchivedContent)
+  ) {
+    if (!client.getWorkspaceArtifactContent) throw new Error("Site version unavailable");
+    content = await client.getWorkspaceArtifactContent(workspaceId, siteId, {
+      ...requestOptions,
+      versionId,
+    });
+  }
+  options.signal?.throwIfAborted();
+  if (content && (content.artifactId !== siteId || content.versionId !== versionId))
+    throw new Error("Site content mismatch");
+  return { detail: structuredClone(detail), content: content ? structuredClone(content) : null };
+}
+export type SiteListProps = SiteScope & {
+  status?: "active" | "archived";
+  onOpen: (site: WorkspaceArtifact) => void;
+};
+export type SiteDetailProps = SiteScope & {
+  siteId: string;
+  /** Presentation hint only: the backend still enforces artifacts:publish. */
+  canPublish?: boolean;
+  toolBridge?: PublishedHtmlArtifactToolBridge;
+};
+
+function useScopeKey(values: readonly unknown[]) {
+  const [scope, setScope] = useState(values);
+  const [generation, setGeneration] = useState(0);
+  if (values.some((value, index) => value !== scope[index])) {
+    setScope(values);
+    setGeneration(generation + 1);
+  }
+  return generation;
+}
+
+export function SiteList(props: SiteListProps) {
+  const key = useScopeKey([props.client, props.workspaceId, props.status]);
+  return <ScopedSiteList key={key} {...props} />;
+}
+function ScopedSiteList({
+  client,
+  workspaceId,
+  status = "active",
+  onOpen,
+  className,
+}: SiteListProps) {
+  const [page, setPage] = useState<WorkspaceArtifactListResponse | null>(null);
+  const [cursor, setCursor] = useState<string | undefined>();
+  const [error, setError] = useState(false);
+  const [reload, setReload] = useState(0);
+  useEffect(() => {
+    const abort = new AbortController();
+    setPage(null);
+    setError(false);
+    void Promise.resolve()
+      .then(() =>
+        client.listWorkspaceArtifacts(workspaceId, {
+          status,
+          ...(cursor ? { cursor } : {}),
+          limit: 50,
+          signal: abort.signal,
+        }),
+      )
+      .then((result) => {
+        if (!abort.signal.aborted) setPage(structuredClone(result));
+      })
+      .catch(() => {
+        if (!abort.signal.aborted) setError(true);
+      });
+    return () => abort.abort();
+  }, [client, workspaceId, status, cursor, reload]);
+  return (
+    <section className={className} aria-label="Sites" aria-busy={!page && !error}>
+      {error ? (
+        <p role="alert">Sites are unavailable or access has changed. Refresh to check access.</p>
+      ) : !page ? (
+        <p role="status">Loading Sites…</p>
+      ) : page.artifacts.length === 0 ? (
+        <p role="status">No {status} Sites.</p>
+      ) : (
+        <ul>
+          {page.artifacts.map((site) => (
+            <li key={site.id}>
+              <button type="button" onClick={() => onOpen(structuredClone(site))}>
+                {site.title}
+              </button>
+              <p>{site.description}</p>
+              <span>
+                {site.status} · revision {site.currentVersion?.revision ?? "unpublished"}
+              </span>
+            </li>
+          ))}
+        </ul>
+      )}
+      {page?.nextCursor && (
+        <button type="button" onClick={() => setCursor(page.nextCursor!)}>
+          Next page
+        </button>
+      )}
+      {cursor && (
+        <button type="button" onClick={() => setCursor(undefined)}>
+          First page
+        </button>
+      )}
+      <button type="button" onClick={() => setReload((value) => value + 1)}>
+        Refresh Sites
+      </button>
+    </section>
+  );
+}
+
+export function SiteDetail(props: SiteDetailProps) {
+  const key = useScopeKey([props.client, props.workspaceId, props.siteId]);
+  return <ScopedSiteDetail key={key} {...props} />;
+}
+function ScopedSiteDetail({
+  client,
+  workspaceId,
+  siteId,
+  canPublish = false,
+  toolBridge,
+  className,
+}: SiteDetailProps) {
+  const [loaded, setLoaded] = useState<{
+    detail: WorkspaceArtifactDetailResponse;
+    content: SiteDisplayContent | null;
+  } | null>(null);
+  const [error, setError] = useState(false);
+  const [reload, setReload] = useState(0);
+  const [busy, setBusy] = useState(false);
+  const [rollbackId, setRollbackId] = useState("");
+  const [confirmation, setConfirmation] = useState<"status" | "rollback" | null>(null);
+  const mutation = useRef<AbortController | null>(null);
+  useEffect(() => () => mutation.current?.abort(), []);
+  useEffect(() => {
+    const abort = new AbortController();
+    setLoaded(null);
+    setError(false);
+    setConfirmation(null);
+    setRollbackId("");
+    void Promise.resolve()
+      .then(async () => {
+        const snapshot = await loadSiteSnapshot(client, workspaceId, siteId, {
+          signal: abort.signal,
+        });
+        if (!abort.signal.aborted) setLoaded(snapshot);
+      })
+      .catch(() => {
+        if (!abort.signal.aborted) {
+          setLoaded(null);
+          setError(true);
+        }
+      });
+    return () => abort.abort();
+  }, [client, workspaceId, siteId, reload]);
+  // Recheck live read authority without rebuilding the iframe on every tick.
+  // No overlapping polls, and failures remove the document and tool bridge.
+  useEffect(() => {
+    if (!loaded || busy) return;
+    const abort = new AbortController();
+    let checking = false;
+    const timer = setInterval(() => {
+      if (checking) return;
+      checking = true;
+      void Promise.resolve()
+        .then(() => client.getWorkspaceArtifact(workspaceId, siteId, { signal: abort.signal }))
+        .then((detail) => {
+          if (abort.signal.aborted) return;
+          if (detail.artifact.id !== siteId || detail.artifact.workspaceId !== workspaceId)
+            throw new Error("Site scope mismatch");
+          if (
+            detail.artifact.currentVersion?.id !== loaded.detail.artifact.currentVersion?.id ||
+            detail.artifact.status !== loaded.detail.artifact.status
+          ) {
+            setLoaded(null);
+            setReload((value) => value + 1);
+          }
+        })
+        .catch(() => {
+          if (!abort.signal.aborted) {
+            setLoaded(null);
+            setError(true);
+          }
+        })
+        .finally(() => {
+          checking = false;
+        });
+    }, 15_000);
+    return () => {
+      abort.abort();
+      clearInterval(timer);
+    };
+  }, [client, workspaceId, siteId, loaded, busy]);
+  const commit = async () => {
+    const current = loaded?.detail.artifact.currentVersion;
+    if (!canPublish || !loaded || !current || !confirmation || mutation.current) return;
+    const abort = new AbortController();
+    mutation.current = abort;
+    setBusy(true);
+    try {
+      const common = { expectedCurrentVersionId: current.id, idempotencyKey: crypto.randomUUID() };
+      if (confirmation === "rollback") {
+        if (!loaded.detail.versions.some((version) => version.id === rollbackId))
+          throw new Error("Unknown version");
+        await client.rollbackWorkspaceArtifact(
+          workspaceId,
+          siteId,
+          { ...common, versionId: rollbackId, reason: "Restore explicitly selected Site version" },
+          { signal: abort.signal },
+        );
+      } else {
+        await client.setWorkspaceArtifactStatus(
+          workspaceId,
+          siteId,
+          {
+            ...common,
+            status: loaded.detail.artifact.status === "active" ? "archived" : "active",
+            reason: "Explicit Site status change",
+          },
+          { signal: abort.signal },
+        );
+      }
+      if (!abort.signal.aborted) {
+        setLoaded(null);
+        setReload((value) => value + 1);
+      }
+    } catch {
+      if (!abort.signal.aborted) {
+        setLoaded(null);
+        setError(true);
+      }
+    } finally {
+      if (!abort.signal.aborted) {
+        mutation.current = null;
+        setBusy(false);
+        setConfirmation(null);
+      }
+    }
+  };
+  const site = loaded?.detail.artifact;
+  return (
+    <section
+      className={className}
+      aria-label="Site details"
+      aria-busy={busy || (!loaded && !error)}
+    >
+      {error && (
+        <p role="alert">
+          Site state could not be confirmed or access has changed. Refresh before continuing.
+        </p>
+      )}
+      {!loaded && !error && <p role="status">Loading Site…</p>}
+      {site && (
+        <>
+          <h2>{site.title}</h2>
+          <p>{site.description}</p>
+          <p>
+            {site.status} · revision {site.currentVersion?.revision ?? "unpublished"}
+          </p>
+          {loaded.content && (
+            <PublishedHtmlArtifactFrame
+              html={loaded.content.html}
+              title={site.title}
+              {...(toolBridge ? { toolBridge } : {})}
+            />
+          )}
+          <h3>Versions</h3>
+          <ul>
+            {loaded.detail.versions.map((version) => (
+              <li key={version.id}>
+                Revision {version.revision} · {version.createdAt}
+                {version.id === site.currentVersion?.id ? " · current" : ""}
+              </li>
+            ))}
+          </ul>
+          {loaded.detail.versionsTruncated && (
+            <p>Older versions are not included in this response.</p>
+          )}
+          {canPublish && site.currentVersion && (
+            <fieldset disabled={busy}>
+              <legend>Manage Site</legend>
+              <button type="button" onClick={() => setConfirmation("status")}>
+                {site.status === "active" ? "Archive Site" : "Restore Site"}
+              </button>
+              <label>
+                Version to restore
+                <select
+                  value={rollbackId}
+                  onChange={(event) => {
+                    setRollbackId(event.target.value);
+                    setConfirmation(null);
+                  }}
+                >
+                  <option value="">Choose a version</option>
+                  {loaded.detail.versions
+                    .filter((version) => version.id !== site.currentVersion?.id)
+                    .map((version) => (
+                      <option key={version.id} value={version.id}>
+                        Revision {version.revision}
+                      </option>
+                    ))}
+                </select>
+              </label>
+              <button
+                type="button"
+                disabled={!rollbackId}
+                onClick={() => setConfirmation("rollback")}
+              >
+                Review rollback
+              </button>
+              {confirmation && (
+                <div role="group" aria-label="Confirm Site change">
+                  <p>
+                    {confirmation === "rollback"
+                      ? "Make the selected version current?"
+                      : site.status === "active"
+                        ? "Archive this Site for workspace users?"
+                        : "Restore this Site for workspace users?"}
+                  </p>
+                  <button type="button" onClick={() => void commit()}>
+                    Confirm change
+                  </button>
+                  <button type="button" onClick={() => setConfirmation(null)}>
+                    Keep current state
+                  </button>
+                </div>
+              )}
+            </fieldset>
+          )}
+        </>
+      )}
+      <button type="button" disabled={busy} onClick={() => setReload((value) => value + 1)}>
+        Refresh Site
+      </button>
+    </section>
+  );
+}

package/src/sites.ts

@@ -0,0 +1,3 @@
+/** Public package entry: keep TSX implementation behind a release-rewritable .ts boundary. */
+export { SiteList, SiteDetail, loadSiteSnapshot } from "./sites-ui";
+export type { SiteClient, SiteListProps, SiteDetailProps } from "./sites-ui";