@opengeni/react 1.3.0 → 1.4.2

package/src/session-capability-policy.ts

@@ -1,4 +1,9 @@
-import type { FirstPartyMcpToolName, CapabilityCatalogItem } from "@opengeni/sdk";
+import type {
+  FirstPartyMcpToolName,
+  CapabilityCatalogItem,
+  Session,
+  UpdateSessionToolPolicyRequest,
+} from "@opengeni/sdk";
 import type { OpenGeniBrowserClient as OpenGeniClient } from "@opengeni/sdk/browser";
 
 /** Catalog tool discovery may be lazy; selecting the installed server does not
@@ -25,6 +30,16 @@ export async function attachSessionCapability(
   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.");
+  const request = capabilityToolPolicyUpdate(session, item);
+  if (request) await client.updateSessionToolPolicy(workspaceId, sessionId, request);
+}
+
+function capabilityToolPolicyUpdate(
+  session: Session,
+  item: CapabilityCatalogItem,
+): UpdateSessionToolPolicyRequest | null {
+  const tools = sessionCapabilityTools(item);
+  if (item.kind === "skill" || tools.length === 0) return null;
   // Session.tools includes mandatory runtime servers, which must never be
   // echoed into the human's explicit selection.
   let existing = session.tools.filter(
@@ -42,10 +57,19 @@ export async function attachSessionCapability(
     // automatic selection. Compare against the resolved defaults instead.
     existing = policy.effectiveIds
       .filter((id) => !policy.mandatoryIds.includes(id))
-      .map((id) => ({ kind: "mcp" as const, id }));
+      .map(
+        (id) =>
+          session.tools.find((tool) => tool.kind === "mcp" && tool.id === id) ?? {
+            kind: "mcp" as const,
+            id,
+            optional: true,
+          },
+      );
   }
   const additions = tools.filter(
-    (tool) => !existing.some((current) => current.kind === tool.kind && current.id === tool.id),
+    (tool) =>
+      !session.effectiveToolPolicy?.mandatoryIds.includes(tool.id) &&
+      !existing.some((current) => current.kind === tool.kind && current.id === tool.id),
   );
   const recommended = Array.isArray(item.metadata?.firstPartyMcpTools)
     ? (item.metadata.firstPartyMcpTools.filter(
@@ -53,13 +77,102 @@ export async function attachSessionCapability(
       ) as FirstPartyMcpToolName[])
     : [];
   const firstParty = [...new Set([...session.firstPartyMcpTools, ...recommended])];
-  if (additions.length === 0 && firstParty.length === session.firstPartyMcpTools.length) return;
-  await client.updateSessionToolPolicy(workspaceId, sessionId, {
+  if (additions.length === 0 && firstParty.length === session.firstPartyMcpTools.length)
+    return null;
+  return {
     mode: "explicit",
     tools: [...existing, ...additions],
     firstPartyMcpTools: firstParty,
     expectedVersion: session.toolPolicyVersion,
-  });
+  };
+}
+
+/** Read-only review. Hosts must show ancestor changes and obtain a separate
+ * explicit click before applying. This plan is never authorization. */
+export type SessionCapabilityAccessPlan = {
+  workspaceId: string;
+  sessionId: string;
+  capabilityId: string;
+  sessions: Array<{
+    id: string;
+    title: string | null;
+    parentSessionId: string | null;
+    toolPolicyVersion: number;
+    request: UpdateSessionToolPolicyRequest | null;
+  }>;
+};
+
+export async function prepareSessionCapabilityAccess(
+  client: OpenGeniClient,
+  workspaceId: string,
+  sessionId: string,
+  item: CapabilityCatalogItem,
+  stillCurrent: () => boolean = () => true,
+): Promise<SessionCapabilityAccessPlan> {
+  const sessions: SessionCapabilityAccessPlan["sessions"] = [];
+  if (item.kind === "skill" || sessionCapabilityTools(item).length === 0)
+    return { workspaceId, sessionId, capabilityId: item.id, sessions };
+  const visited = new Set<string>();
+  let id: string | null = sessionId;
+  while (id) {
+    if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+    if (visited.has(id)) throw new Error("The parent chat chain could not be verified.");
+    visited.add(id);
+    const session = await client.getSession(workspaceId, id);
+    if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+    const request = capabilityToolPolicyUpdate(session, item);
+    sessions.push({
+      id,
+      title: session.title ?? null,
+      parentSessionId: session.parentSessionId ?? null,
+      toolPolicyVersion: session.toolPolicyVersion,
+      request,
+    });
+    // An unchanged immediate parent already supplies this capability's ceiling.
+    // Do not read or broaden ancestors irrelevant to this addition.
+    if (!request) break;
+    id = session.parentSessionId ?? null;
+  }
+  return { workspaceId, sessionId, capabilityId: item.id, sessions: sessions.reverse() };
+}
+
+/** Preflight the entire review, then apply ordinary CAS-fenced API writes root
+ * first. A partial failure may leave approved ancestor changes committed; never
+ * claim success or roll back another person's edits. Prepare a new review. */
+export async function applySessionCapabilityAccess(
+  client: OpenGeniClient,
+  plan: SessionCapabilityAccessPlan,
+  stillCurrent: () => boolean = () => true,
+): Promise<void> {
+  for (const reviewed of plan.sessions) {
+    if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+    const current = await client.getSession(plan.workspaceId, reviewed.id);
+    if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+    if (
+      current.toolPolicyVersion !== reviewed.toolPolicyVersion ||
+      (current.parentSessionId ?? null) !== reviewed.parentSessionId
+    )
+      throw new Error("Chat access changed. Click Add tools to review the current choices again.");
+  }
+  for (const reviewed of plan.sessions) {
+    if (!stillCurrent()) throw new Error("Connection setup was interrupted.");
+    if (reviewed.request) {
+      const updated = await client.updateSessionToolPolicy(
+        plan.workspaceId,
+        reviewed.id,
+        reviewed.request,
+      );
+      if (
+        reviewed.request.mode === "explicit" &&
+        reviewed.request.firstPartyMcpTools.some(
+          (tool) => !updated.firstPartyMcpTools.includes(tool),
+        )
+      )
+        throw new Error(
+          "This chat's capabilities do not allow these tools. Review its capability settings before adding tools again.",
+        );
+    }
+  }
 }
 
 /** Native OAuth callbacks have already saved the provider connection. Finish

package/src/timeline/index.ts

@@ -61,6 +61,16 @@ export type {
 
 // renderer registry
 export { createToolRegistry, rawTypeOf } from "./registry";
+export {
+  createSessionRetainedScreenshotLoader,
+  createWorkspaceRetainedArtifactLoader,
+  createWorkspaceRetainedVideoLoader,
+} from "./retained-loaders";
+export type {
+  RetainedArtifactLoaderClient,
+  RetainedScreenshotLoaderClient,
+  RetainedVideoLoaderClient,
+} from "./retained-loaders";
 export type {
   CreateToolRegistryOptions,
   RetainedArtifactLoader,

package/src/timeline/retained-loaders.ts

@@ -0,0 +1,86 @@
+import type { OpenGeniClient, RetainedArtifactReference } from "@opengeni/sdk";
+import type {
+  RetainedArtifactLoader,
+  RetainedScreenshotLoader,
+  VideoArtifactPlaybackLoader,
+} from "./registry";
+
+/** SDK methods the workspace retained-artifact loader needs. */
+export type RetainedArtifactLoaderClient = Pick<
+  OpenGeniClient,
+  "createRetainedArtifactDownloadUrl" | "downloadRetainedArtifact"
+>;
+
+/** SDK method the session retained-screenshot loader needs. */
+export type RetainedScreenshotLoaderClient = Pick<OpenGeniClient, "downloadRetainedScreenshot">;
+
+/** SDK method the generated-video playback loader needs. */
+export type RetainedVideoLoaderClient = Pick<OpenGeniClient, "createVideoArtifactPlaybackSource">;
+
+/**
+ * Bind permanent retained-artifact retrieval (generated images, published
+ * files) to one authenticated workspace, for `MessageTimeline`'s
+ * `loadRetainedArtifact`. Images get a short-lived URL; files are assembled
+ * from verified byte ranges.
+ */
+export function createWorkspaceRetainedArtifactLoader(
+  client: RetainedArtifactLoaderClient,
+  workspaceId: string,
+): RetainedArtifactLoader {
+  return async (artifact: RetainedArtifactReference, signal: AbortSignal) => {
+    if (artifact.kind === "file") {
+      const download = await client.downloadRetainedArtifact(workspaceId, artifact, { signal });
+      return download.bytes;
+    }
+    const download = await client.createRetainedArtifactDownloadUrl(workspaceId, artifact, {
+      signal,
+    });
+    return { url: download.url };
+  };
+}
+
+/**
+ * Bind the authenticated screenshot downloader to one workspace and session,
+ * for `MessageTimeline`'s `loadRetainedScreenshot`. Fetched metadata must match
+ * the timeline receipt before bytes are handed to React; errors deliberately
+ * contain no storage locator or content.
+ */
+export function createSessionRetainedScreenshotLoader(
+  client: RetainedScreenshotLoaderClient,
+  workspaceId: string,
+  sessionId: string,
+): RetainedScreenshotLoader {
+  return async (artifact: RetainedArtifactReference, signal: AbortSignal) => {
+    const download = await client.downloadRetainedScreenshot(
+      workspaceId,
+      sessionId,
+      artifact.artifactId,
+      { signal },
+    );
+    if (!download.metadata.available || !download.bytes) return null;
+    if (
+      download.metadata.artifactId !== artifact.artifactId ||
+      download.metadata.kind !== artifact.kind ||
+      download.metadata.contentType !== artifact.contentType ||
+      download.metadata.originalBytes !== artifact.originalBytes ||
+      download.metadata.sha256 !== artifact.sha256 ||
+      download.metadata.dimensions?.width !== artifact.dimensions?.width ||
+      download.metadata.dimensions?.height !== artifact.dimensions?.height
+    ) {
+      throw new Error("Retained screenshot receipt verification failed");
+    }
+    return download.bytes;
+  };
+}
+
+/**
+ * Bind expiring generated-video playback sources to one authenticated
+ * workspace, for `MessageTimeline`'s `loadVideoArtifactPlayback`.
+ */
+export function createWorkspaceRetainedVideoLoader(
+  client: RetainedVideoLoaderClient,
+  workspaceId: string,
+): VideoArtifactPlaybackLoader {
+  return async (artifactId: string, signal: AbortSignal) =>
+    await client.createVideoArtifactPlaybackSource(workspaceId, artifactId, { signal });
+}

package/src/timeline/tool-display-name.ts

@@ -30,7 +30,11 @@ export function toolMatchesLeaf(wireName: string, leaf: string): boolean {
  */
 export function toolDisplayName(name: string, display?: ToolDisplayMetadata): string {
   if (!display && /^[a-f0-9]{64}$/.test(name)) return "Tool call";
-  const phrase = (display?.toolName ?? mcpToolLeaf(name)).replace(/[_-]+/g, " ").trim();
+  // "batch modify messages" → "Modify messages": batching is transport, not the action.
+  const phrase = (display?.toolName ?? mcpToolLeaf(name))
+    .replace(/[_-]+/g, " ")
+    .trim()
+    .replace(/^batch\s+(?=\S)/i, "");
   const title =
     display?.title ?? (phrase ? phrase.charAt(0).toUpperCase() + phrase.slice(1) : name);
   return display?.accountLabel ? `${title} — ${display.accountLabel}` : title;

package/src/timeline/tool-renderers.tsx

@@ -1,4 +1,6 @@
-import { useHasToolReview, ToolReviewHistoryReceipt } from "../components/tool-review-history";
+import { useHasToolReview, useRecordedToolReview } from "../components/tool-review-history";
+import { ToolActionReviewCard } from "../components/tool-action-review";
+import type { ToolReviewStatus } from "@opengeni/sdk";
 import { KnowledgeReceiptRow } from "./knowledge-receipt";
 import { defaultUrlTransform } from "react-markdown";
 import { isRetainedImageContentType, useRetainedImageObjectUrl } from "./retained-image";
@@ -588,7 +590,10 @@ function ComputerCallRenderer({ item, loadRetainedScreenshot }: ToolRendererProp
   // every transport.
   const functionAction: ComputerAction | undefined =
     !raw.action && item.name.startsWith("computer_") && item.name !== "computer_call"
-      ? { type: item.name.slice("computer_".length), ...asComputerArgs(item.arguments) }
+      ? {
+          type: item.name.slice("computer_".length),
+          ...asComputerArgs(item.arguments),
+        }
       : undefined;
   const action = raw.action ?? functionAction;
   const actions = raw.actions ?? (action ? [action] : []);
@@ -2335,10 +2340,74 @@ function RunOnRenderer({ item }: ToolRendererProps) {
  */
 function GenericRenderer({ item }: ToolRendererProps) {
   const reviewed = useHasToolReview(item.callId);
-  if (reviewed && item.callId) return <ToolReviewHistoryReceipt approvalId={item.callId} />;
+  if (reviewed && item.callId) return <ReviewedGenericRenderer item={item} />;
   return <UnreviewedGenericRenderer item={item} />;
 }
 
+/** Settled review states earn one quiet gutter word; success and waiting stay chip-free. */
+const REVIEW_CHIP: Partial<Record<ToolReviewStatus, DisclosureChip>> = {
+  rejected: { tone: "interrupted", text: "declined" },
+  cancelled: { tone: "interrupted", text: "not run" },
+  expired: { tone: "interrupted", text: "expired" },
+  stale: { tone: "interrupted", text: "not run" },
+  revoked: { tone: "interrupted", text: "not run" },
+  blocked: { tone: "interrupted", text: "blocked" },
+  unknown: { tone: "bad", text: "outcome unknown" },
+  partial: { tone: "bad", text: "partly done" },
+  failed: { tone: "bad", text: "failed" },
+};
+
+/**
+ * A call that went through approval keeps the ordinary row shape, titled with
+ * what was approved. The expanded body is the saved review plus the result.
+ */
+function ReviewedGenericRenderer({ item }: ToolRendererProps) {
+  const { review, onViewDetails } = useRecordedToolReview(item.callId);
+  if (!review) return <UnreviewedGenericRenderer item={item} />;
+  const icon = <GenericToolIcon name={item.name} />;
+  const waiting = review.status === "pending";
+  const running =
+    !waiting &&
+    (review.status === "executing" || review.status === "approved") &&
+    item.status === "running";
+  const { text: outText, isError } = unwrapMcpOutput(item.output);
+  const chip =
+    REVIEW_CHIP[review.status] ??
+    (isError && !running && !waiting ? ({ tone: "bad", text: "error" } as const) : undefined);
+  return (
+    <ActivityDisclosure
+      icon={icon}
+      iconTone={chip?.tone === "bad" ? "failed" : waiting ? "accent" : "muted"}
+      title={review.title}
+      running={running}
+      chip={chip}
+      preview={
+        waiting ? (
+          "Waiting for your approval"
+        ) : running ? (
+          <RunningPreview>Running…</RunningPreview>
+        ) : (
+          (review.accountLabel ?? undefined)
+        )
+      }
+    >
+      <div className="py-1" data-approval-id={item.callId} data-review-origin="history">
+        <ToolActionReviewCard
+          bare
+          review={{ ...review, availableActions: [] }}
+          onViewDetails={onViewDetails}
+        />
+      </div>
+      {outText ? <PayloadBlock label="Result" value={outText} failed={isError} /> : null}
+    </ActivityDisclosure>
+  );
+}
+
+/** The runtime's exact refusal for a tool whose effective permission is Block. */
+const BLOCKED_OUTPUT = /Connector action was not executed: blocked\b/;
+/** The runtime's refusal to guess whether an approved action ran. */
+const UNCERTAIN_OUTPUT = /Connector action outcome is uncertain\b/;
+
 function UnreviewedGenericRenderer({ item }: ToolRendererProps) {
   const running = item.status === "running";
   const args = parseToolArgs(item.arguments);
@@ -2363,6 +2432,42 @@ function UnreviewedGenericRenderer({ item }: ToolRendererProps) {
   }
 
   const { text: outText, isError } = unwrapMcpOutput(item.output);
+  // A permission Block is a decision, not a tool failure: say so plainly instead
+  // of the generic "error occurred, please try again" wrapper.
+  if (isError && BLOCKED_OUTPUT.test(outText)) {
+    return (
+      <ActivityDisclosure
+        icon={icon}
+        iconTone="muted"
+        title={display}
+        chip={{ tone: "interrupted", text: "blocked" }}
+        preview="Blocked by your permission settings"
+      >
+        <p className="m-0 py-1 text-og-sm text-og-fg-muted">
+          Your permission settings block this action, so it did not run. You can change this in the
+          integration's tool permissions.
+        </p>
+        <PayloadBlock label="Arguments" value={args} />
+      </ActivityDisclosure>
+    );
+  }
+  // An interrupted approved action may have run. Never invite a blind retry.
+  if (isError && UNCERTAIN_OUTPUT.test(outText)) {
+    return (
+      <ActivityDisclosure
+        icon={icon}
+        iconTone="failed"
+        title={display}
+        chip={{ tone: "bad", text: "outcome unknown" }}
+        preview="It may have run"
+      >
+        <p className="m-0 py-1 text-og-sm text-og-fg-muted">
+          This action may have run. Check the result in the connected app before trying again.
+        </p>
+        <PayloadBlock label="Arguments" value={args} />
+      </ActivityDisclosure>
+    );
+  }
   // Cancelled is NOT an error — a user-cancelled tool should not surface the red
   // error chip even if the output payload carries an isError flag (the error may be
   // a consequence of the cancellation, not the tool's own failure).
@@ -2543,25 +2648,41 @@ const BASE_ENTRIES: ToolRegistryEntry[] = [
   { match: "name", name: "apply_patch_call", render: ApplyPatchRenderer },
   { match: "name", name: "apply_patch", render: ApplyPatchRenderer },
   { match: "name", name: "computer_call", render: ComputerCallRenderer },
-  { match: "name", name: "browser_screenshot", render: BrowserScreenshotRenderer },
+  {
+    match: "name",
+    name: "browser_screenshot",
+    render: BrowserScreenshotRenderer,
+  },
   { match: "name", name: "browser_observe", render: BrowserScreenshotRenderer },
   { match: "name", name: "browser_act", render: BrowserScreenshotRenderer },
   // Function-mode computer tools (codex / chat-wire transports).
   { match: "name", name: "computer_screenshot", render: ComputerCallRenderer },
   { match: "name", name: "computer_click", render: ComputerCallRenderer },
-  { match: "name", name: "computer_double_click", render: ComputerCallRenderer },
+  {
+    match: "name",
+    name: "computer_double_click",
+    render: ComputerCallRenderer,
+  },
   { match: "name", name: "computer_move", render: ComputerCallRenderer },
   { match: "name", name: "computer_scroll", render: ComputerCallRenderer },
   { match: "name", name: "computer_type", render: ComputerCallRenderer },
   { match: "name", name: "computer_keypress", render: ComputerCallRenderer },
   { match: "name", name: "computer_drag", render: ComputerCallRenderer },
   { match: "name", name: "web_search_call", render: WebSearchRenderer },
-  { match: "name", name: "image_generation_call", render: GeneratedImageRenderer },
+  {
+    match: "name",
+    name: "image_generation_call",
+    render: GeneratedImageRenderer,
+  },
   { match: "name", name: "generate_image", render: GeneratedImageRenderer },
   { match: "name", name: "generate_video", render: GeneratedVideoRenderer },
   { match: "name", name: "tool_search", render: ToolSearchRenderer },
   { match: "name", name: "view_image", render: ViewImageRenderer },
-  { match: "name", name: "sandbox_file_publish", render: SandboxFilePublishRenderer },
+  {
+    match: "name",
+    name: "sandbox_file_publish",
+    render: SandboxFilePublishRenderer,
+  },
   {
     match: "name",
     name: "artifacts_create",
@@ -2586,13 +2707,25 @@ const BASE_ENTRIES: ToolRegistryEntry[] = [
     render: SiteArtifactRenderer,
     matchPrefixedLeaf: false,
   },
-  { match: "name", name: "environment_set_variable", render: SecretSetRenderer },
-  { match: "name", name: "variable_set_set_variable", render: SecretSetRenderer },
+  {
+    match: "name",
+    name: "environment_set_variable",
+    render: SecretSetRenderer,
+  },
+  {
+    match: "name",
+    name: "variable_set_set_variable",
+    render: SecretSetRenderer,
+  },
   { match: "name", name: "search_documents", render: DocsSearchRenderer },
   { match: "name", name: "knowledge_search", render: DocsSearchRenderer },
   { match: "name", name: "memory_propose", render: MemoryProposeRenderer },
   { match: "name", name: "set_session_title", render: SetSessionTitleRenderer },
-  { match: "name", name: "set_other_session_title", render: SetSessionTitleRenderer },
+  {
+    match: "name",
+    name: "set_other_session_title",
+    render: SetSessionTitleRenderer,
+  },
 ];
 
 /** The built-in tool renderer registry: every first-party tool plus a fallback. */

package/src/voice-recording-owner.ts

@@ -98,6 +98,28 @@ async function createUnderlyingOwnerLease(): Promise<UnderlyingOwnerLease> {
   return { ownerId, release: () => undefined };
 }
 
+/**
+ * Owner ids whose document still holds its Web Lock, or null when this browser
+ * cannot answer. A lock is released the moment its tab closes or crashes, so a
+ * recording whose owner is absent here is recoverable immediately instead of
+ * after the heartbeat stale window.
+ */
+export async function liveVoiceRecordingOwnerIds(): Promise<ReadonlySet<string> | null> {
+  if (!hasWebLocks() || typeof navigator.locks.query !== "function") return null;
+  try {
+    const snapshot = await navigator.locks.query();
+    const live = new Set<string>();
+    for (const lock of [...(snapshot.held ?? []), ...(snapshot.pending ?? [])]) {
+      if (lock.name?.startsWith(VOICE_RECORDING_OWNER_LOCK_PREFIX)) {
+        live.add(lock.name.slice(VOICE_RECORDING_OWNER_LOCK_PREFIX.length));
+      }
+    }
+    return live;
+  } catch {
+    return null;
+  }
+}
+
 function hasWebLocks(): boolean {
   return (
     typeof navigator !== "undefined" &&