@opengeni/react 1.0.1 → 1.0.2-canary.37191796234001

package/dist/hooks/use-file-attachments.d.ts

@@ -8,6 +8,8 @@ export type UseFileAttachmentsOptions = EmbeddedFileAttachmentClientOverride & {
      * UseFileAttachmentsResult.addFiles} (the explicit picker / drop path)
      * bypasses it.
      */
+    /** Retain original uploads in the chat owner’s personal scope when private. */
+    scope?: "workspace" | "personal";
     pasteFilter?: ((file: File) => boolean) | undefined;
 };
 export type FileAttachment = {
@@ -20,7 +22,11 @@ export type FileAttachment = {
     file?: FileAsset | undefined;
     /** Object-URL for an inline preview; minted for `image/*` files only. */
     previewUrl?: string | undefined;
+    /** Stable SDK failure code for UI behavior that must not parse error copy. */
+    errorCode?: "secure_context_required" | undefined;
     error?: string | undefined;
+    /** Original diagnostic failure; presentation copy is kept separately in `error`. */
+    errorCause?: unknown;
 };
 export type UseFileAttachmentsResult = {
     attachments: FileAttachment[];
@@ -45,12 +51,25 @@ export type UseFileAttachmentsResult = {
     }) => void;
     /** Restore already-ready server assets without recreating browser-local bytes. */
     restoreReadyFiles: (files: Iterable<FileAsset>) => void;
+    /**
+     * Resolve a ready image's short-lived server preview URL on demand. Optional
+     * for upload-only embedded clients; local object-URL previews remain usable
+     * without it.
+     */
+    loadPreview?: ((id: string, signal?: AbortSignal) => Promise<string | undefined>) | undefined;
     /**
      * Re-run the upload for a `failed` attachment, in place (same id, same
      * source file). No-op for an id that isn't a known failed upload.
      */
     retry: (id: string) => void;
-    /** Remove one attachment; revokes its object-URL. */
+    /**
+     * Keep an attachment's object-URL alive for a consumer that outlives its
+     * queue entry (for example, an open route-level lightbox). The returned
+     * release is idempotent; pending revocation finishes after the last holder
+     * releases. Returns `undefined` when the attachment has no local preview.
+     */
+    retainPreview: (id: string) => (() => void) | undefined;
+    /** Remove one attachment; revokes its object-URL after retained users finish. */
     remove: (id: string) => void;
     /**
      * Remove only finalized files whose durable ids were accepted by a send.
@@ -58,7 +77,7 @@ export type UseFileAttachmentsResult = {
      * next message.
      */
     removeReadyFiles: (fileIds: Iterable<string>) => void;
-    /** Remove all attachments and revoke every object-URL. */
+    /** Remove all attachments and revoke every unretained object-URL. */
     clear: () => void;
 };
 /**

package/dist/hooks/use-machine-chip.d.ts

@@ -1,11 +1,11 @@
 import type { MachineState } from "@opengeni/sdk";
 import type { SessionCapabilitiesState } from "./use-session-capabilities.js";
-/** The one truthful machine indicator. Honest staleness beats
- *  fake liveness: a cold/asleep box reads "offline — as of <time>", never "live". */
+/** The one truthful machine indicator. Managed cold compute is sleeping; a
+ *  Connected Machine that is genuinely unreachable remains offline. */
 export type MachineChipState = "live" | "waking" | "offline";
 export type MachineChip = {
     state: MachineChipState;
-    /** A ready-to-render label ("Live" / "Waking…" / "Offline — as of 3m ago"). */
+    /** A ready-to-render label ("Live" / "Waking…" / "Sleeping · saved 3m ago"). */
     label: string;
     /** The capture time backing an offline/stale label (ISO), or null. M4 may
      *  reformat this; `label` already embeds a relative form. */

package/dist/hooks/use-machines.d.ts

@@ -1,6 +1,12 @@
-import type { RemoveEnrollmentRequest, RemoveEnrollmentResponse, SwapActiveSandboxResponse } from "@opengeni/sdk";
+import type { RemoveEnrollmentRequest, RemoveEnrollmentResponse, MachineOperationPolicy, SwapActiveSandboxResponse, UpdateMachineOperationPolicyRequest, UpdateMachineAgentResponse } from "@opengeni/sdk";
 import { type ClientOverride } from "../provider.js";
 import type { MachinesResponse, MachineView, MetricSample } from "../types/machines.js";
+/** Dashboard list: cheap heartbeat read, keep the pill reasonably fresh. */
+export declare const MACHINES_DASHBOARD_POLL_MS = 10000;
+/** Session surfaces share one poll for the same workspace+session. */
+export declare const MACHINES_SESSION_POLL_MS = 15000;
+/** Composer polls after the first load shows a machine, or to retry a real error. */
+export declare const MACHINES_COMPOSER_POLL_MS = 30000;
 /**
  * The slice of the SDK client the Machines surface needs. The method NAMES +
  * SIGNATURES match M10's `OpenGeniClient` (`listMachines`, `machineMetricsSeries`)
@@ -29,6 +35,10 @@ export type MachinesClientLike = {
     }) => Promise<MetricSample[]>;
     /** POST .../enrollments/:enrollmentId/revoke — workspace-admin removal. */
     removeEnrollment?: (workspaceId: string, enrollmentId: string, request?: RemoveEnrollmentRequest) => Promise<RemoveEnrollmentResponse>;
+    /** POST .../machines/:enrollmentId/update — signed, generation-fenced update. */
+    updateMachineAgent?: (workspaceId: string, enrollmentId: string) => Promise<UpdateMachineAgentResponse>;
+    /** PATCH .../machines/:enrollmentId/operation-policy — revision-fenced policy. */
+    updateMachineOperationPolicy?: (workspaceId: string, enrollmentId: string, request: UpdateMachineOperationPolicyRequest) => Promise<MachineOperationPolicy>;
     /**
      * POST .../sessions/:sessionId/active-sandbox — swap the session's active
      * sandbox to a machine. The default swap path; the real SDK client provides it.
@@ -67,6 +77,14 @@ export type UseMachinesResult = {
     remove: (enrollmentId: string, request?: RemoveEnrollmentRequest) => Promise<RemoveEnrollmentResponse | null>;
     canRemove: boolean;
     removingEnrollmentId: string | null;
+    /** Start/retry the signed self-update for one Connected Machine. */
+    updateAgent: (enrollmentId: string) => Promise<UpdateMachineAgentResponse | null>;
+    canUpdateAgent: boolean;
+    updatingEnrollmentId: string | null;
+    /** Update the optional per-enrollment command memory policy. */
+    updateOperationPolicy: (enrollmentId: string, request: UpdateMachineOperationPolicyRequest) => Promise<MachineOperationPolicy | null>;
+    canUpdateOperationPolicy: boolean;
+    updatingOperationPolicyEnrollmentId: string | null;
     /** Whether the host wired an attach/swap path (drives the card affordance). */
     canAttach: boolean;
     /** Fetch a downsampled metric series for one enrolled machine. */

package/dist/hooks/use-sandbox-files.d.ts

@@ -1,4 +1,4 @@
-import type { FsReadResponse, FsWriteResponse, OpenGeniRequestOptions, SessionCapabilities, SessionEvent, WorkspaceCaptureManifest } from "@opengeni/sdk";
+import type { FileSystemRouteIdentity, FsReadResponse, FsWriteResponse, OpenGeniRequestOptions, SessionCapabilities, SessionEvent, WorkspaceCaptureManifest } from "@opengeni/sdk";
 import { type ClientOverride } from "../provider.js";
 /** The git-status overlay a file row may carry (tints modified files in the tree). */
 export type FileTreeStatus = "added" | "modified" | "deleted" | "renamed" | "untracked";
@@ -29,6 +29,7 @@ export type SandboxWriteFileOptions = {
 /** A node in the Pierre file tree. `children === undefined` ⇒ an unexpanded dir
  *  (lazy treeMode); `children: []` ⇒ an expanded-but-empty dir. */
 export type FileTreeNode = {
+    /** Opaque path returned by the selected target's FileSystem boundary. */
     path: string;
     name: string;
     kind: "file" | "dir";
@@ -46,6 +47,9 @@ export type UseSandboxFilesOptions = ClientOverride & {
     events?: SessionEvent[] | undefined;
     /** Initial path to list (workspace root by default). */
     rootPath?: string | undefined;
+    /** Exact capability identity for the selected filesystem route. A route/root
+     * change resets this hook and makes stale provider requests fail retryably. */
+    route?: FileSystemRouteIdentity | undefined;
     /** Hold off the initial list (e.g. panel collapsed). Default true. */
     enabled?: boolean | undefined;
     /** Pause live reads/invalidation while preserving the last rendered result. */

package/dist/hooks/use-session-background-commands.d.ts

@@ -0,0 +1,14 @@
+import type { SessionBackgroundCommand } from "@opengeni/sdk";
+import { type ClientOverride } from "../provider.js";
+export type UseSessionBackgroundCommandsOptions = ClientOverride & {
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+};
+export type UseSessionBackgroundCommandsResult = {
+    commands: SessionBackgroundCommand[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    cancel: (commandId: string) => Promise<void>;
+};
+export declare function useSessionBackgroundCommands(sessionId: string | null | undefined, options?: UseSessionBackgroundCommandsOptions): UseSessionBackgroundCommandsResult;

package/dist/hooks/use-session-events.d.ts

@@ -1,6 +1,8 @@
-import type { SessionEvent, SessionStatus, StreamConnectionState } from "@opengeni/sdk";
+import { type SessionEvent, type SessionStatus, type StreamConnectionState } from "@opengeni/sdk";
 import { type EmbeddedSessionClientOverride } from "../session-context.js";
+import { type OlderHistoryLoadReceipt } from "../older-history.js";
 import type { TimelineItem } from "../timeline/types.js";
+import type { LatestQuestionOptions } from "./latest-question.js";
 export type SessionEventsConnectionState = StreamConnectionState | "idle" | "ended" | "error";
 export type UseSessionEventsOptions = EmbeddedSessionClientOverride & {
     /** Resume after this sequence (exclusive). Nonzero keeps full replay/resume semantics. */
@@ -13,10 +15,12 @@ export type UseSessionEventsOptions = EmbeddedSessionClientOverride & {
 export type UseSessionEventsResult = {
     /** Replayed + live events, ordered by sequence, no gaps, no duplicates. */
     events: SessionEvent[];
-    /** Projected, renderable timeline (memoized over `events`). */
+    /** Renderable timeline, including the bounded navigation witness for a distant queued prompt. */
     timeline: TimelineItem[];
     /** Latest session status observed in the event log, if any. */
     sessionStatus: SessionStatus | null;
+    /** Sequence of the retained status projection, including events evicted from the window. */
+    sessionStatusSequence?: number;
     connectionState: SessionEventsConnectionState;
     /** Highest sequence seen so far (0 before the first event). */
     lastSequence: number;
@@ -26,12 +30,16 @@ export type UseSessionEventsResult = {
     windowTruncated: boolean;
     /** True until the initial tail window has been applied (windowed mode). */
     initialLoading: boolean;
+    /** A history window (including an empty tail) succeeded for this session/replay
+     * identity. Stays true through later stream errors and navigation/reloads.
+     * Full replay has no snapshot-completion watermark and does not set this by itself. */
+    initialHistoryReady: boolean;
     /** Whether older durable events are available before the current window. */
     hasOlder: boolean;
     /** True while an older window is being fetched. */
     loadingOlder: boolean;
     /** Prepend an older density-bounded window; resolves true when more remain. */
-    loadOlder: () => Promise<boolean>;
+    loadOlder: () => OlderHistoryLoadReceipt;
     /**
      * Durable events exist after the current window (history view jumped away
      * from the live tip, or a forward page is incomplete).
@@ -58,11 +66,19 @@ export type UseSessionEventsResult = {
      * "Jump to latest" when the tip is not in memory (history view).
      */
     jumpToLatest: () => Promise<void>;
+    /** Resolve the newest eligible durable human question. Pending prompts use the
+     * optional queue destination and return null; started prompts load their actual
+     * turn context (pass `timeline` to MessageTimeline as `items`). */
+    jumpToLatestQuestion: (options?: LatestQuestionOptions) => Promise<number | null>;
+    /** Replace history with a bounded window containing this exact durable event. */
+    jumpToSequence: (sequence: number, options?: {
+        signal?: AbortSignal;
+    }) => Promise<boolean>;
+    loadingTarget: boolean;
     error: Error | null;
 };
 export declare const SESSION_EVENT_BROWSER_MAX_BYTES: number;
-export declare const SESSION_EVENT_BROWSER_MAX_COUNT = 10000;
-export declare const SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES: number;
+export declare const SESSION_EVENT_BROWSER_MAX_COUNT = 20000;
 export declare const SESSION_EVENT_BROWSER_PENDING_MAX_BYTES: number;
 export declare const SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
 export type BrowserSessionEventWindow = {
@@ -81,12 +97,18 @@ export declare function useSessionEvents(sessionId: string | null | undefined, o
  * accumulation retains the newest suffix; backward paging retains the oldest
  * prefix so newly fetched history cannot be immediately evicted. This is
  * deliberately separate from durable history and transport paging: when a
- * backward page evicts the live tail, the hook reconnects from the retained
- * high-water mark while preserving the highest-ever-observed sequence
- * separately. The source event remains durable in PostgreSQL throughout.
+ * backward page evicts the live tail, the hook enters bounded history mode and
+ * preserves the highest-ever-observed sequence separately for forward paging.
+ * The source event remains durable in PostgreSQL throughout. An event larger
+ * than the byte target is retained alone, never replaced by a lossy preview.
  */
 export declare function boundBrowserSessionEventWindow(events: readonly SessionEvent[], options?: {
     maxBytes?: number;
     maxCount?: number;
     direction?: "newest" | "oldest";
 }): BrowserSessionEventWindow;
+/** @internal Append immutable events without serializing the retained history again. */
+export declare function appendBrowserSessionEventWindow(current: BrowserSessionEventWindow, batch: readonly SessionEvent[], options?: {
+    maxBytes?: number;
+    maxCount?: number;
+}): BrowserSessionEventWindow;

package/dist/hooks/use-session-lineage.d.ts

@@ -5,11 +5,15 @@ export type UseSessionLineageOptions = EmbeddedSessionLineageClientOverride & {
     /** Refresh interval (ms). Off by default. */
     pollIntervalMs?: number | undefined;
     enabled?: boolean | undefined;
+    /** Optional shared causal clock invoked when each network read starts. */
+    beginRead?: (() => number) | undefined;
 };
 export type UseSessionLineageResult = {
     lineage: SessionLineageResponse | null;
     loading: boolean;
     error: Error | null;
+    /** Causal generation captured when the accepted lineage read started. */
+    readGeneration: number;
     refresh: () => Promise<void>;
 };
 export declare function isLineageRefreshEvent(event: SessionEvent): boolean;

package/dist/hooks/use-session-mcp-approval-policy.d.ts

@@ -1,4 +1,4 @@
-import type { SessionEvent, SessionMcpApprovalPolicy, SessionMcpServerMetadata, UpdateSessionMcpApprovalPolicyResponse } from "@opengeni/sdk";
+import type { SessionEvent, SessionMcpApprovalPolicy, SessionMcpApprovalPolicyTarget, UpdateSessionMcpApprovalPolicyResponse } from "@opengeni/sdk";
 import { type EmbeddedSessionMcpApprovalPolicyClientOverride } from "../session-context.js";
 import { type SessionEventFeedOptions } from "./internal.js";
 export declare function isSessionMcpApprovalPolicyEvent(event: Pick<SessionEvent, "type" | "payload">, serverId?: string): boolean;
@@ -7,7 +7,7 @@ export type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolic
     pollIntervalMs?: number | undefined;
 };
 export type UseSessionMcpApprovalPolicyResult = {
-    server: SessionMcpServerMetadata | null;
+    server: SessionMcpApprovalPolicyTarget | null;
     policy: SessionMcpApprovalPolicy | null;
     loading: boolean;
     error: Error | null;

package/dist/hooks/use-session.d.ts

@@ -4,11 +4,17 @@ import { type SessionEventFeedOptions } from "./internal.js";
 export type UseSessionOptions = EmbeddedSessionReadClientOverride & SessionEventFeedOptions & {
     /** Re-fetch on an interval (ms). Off by default — pair with `useSessionEvents` for live status. */
     pollIntervalMs?: number | undefined;
+    /** Optional shared causal clock invoked when each network read starts. */
+    beginRead?: (() => number) | undefined;
 };
 export type UseSessionResult = {
     session: Session | null;
     loading: boolean;
     error: Error | null;
+    /** Monotonic revision of accepted authoritative detail reads. */
+    readRevision: number;
+    /** Causal generation captured when the accepted network read started. */
+    readGeneration: number;
     refresh: () => Promise<void>;
     /** Manually rename the session (PATCH, source='user'). Returns the updated session, or null on failure. */
     updateTitle: (title: string) => Promise<Session | null>;

package/dist/hooks/use-turn-queue.d.ts

@@ -4,6 +4,16 @@ import { type SessionEventFeedOptions } from "./internal.js";
 /** Events that can change the authoritative prompt queue or effective control. */
 export declare function isTurnQueueEvent(event: Pick<SessionEvent, "type">): boolean;
 export type QueueMutationKind = "move" | "edit" | "steer" | "delete";
+export type AcceptedQueueSteer = {
+    turnId: string;
+    triggerEventId: string;
+    text: string;
+    annotations: SessionTurn["annotations"];
+    resources: SessionTurn["resources"];
+    tools: SessionTurn["tools"];
+    occurredAt: string;
+    state: "sending" | "queued";
+};
 export type UseTurnQueueOptions = EmbeddedSessionClientOverride & SessionEventFeedOptions & {
     pollIntervalMs?: number | undefined;
 };
@@ -37,6 +47,8 @@ export type UseTurnQueueResult = {
     mutating: boolean;
     mutationError: Error | null;
     clearMutationError: () => void;
+    /** Immediate chat bridge while the durable Steer event catches up over SSE. */
+    acceptedSteers?: AcceptedQueueSteer[] | undefined;
 };
 /**
  * The one authoritative human prompt queue. Every mutation carries the exact

package/dist/hooks/use-usage.d.ts

@@ -0,0 +1,40 @@
+import type { OpenGeniClient } from "@opengeni/sdk";
+import { type UsageAllowancePeriod, type WorkspaceUsageResponse } from "@opengeni/sdk/usage-allowances";
+import { type UsageSummary } from "../usage/summary.js";
+/**
+ * Anything that can read the signed-in member's own usage: the root SDK client
+ * pointed at your session proxy (`getMyUsage`), or any client exposing
+ * `requestJson` (for example the narrower browser client).
+ */
+export type UsageClientLike = Pick<OpenGeniClient, "getMyUsage"> | Pick<OpenGeniClient, "requestJson">;
+export type UseUsageOptions = {
+    /** Defaults to the `<OpenGeniProvider>` client. */
+    client?: UsageClientLike | undefined;
+    /** Defaults to the `<OpenGeniProvider>` workspace. */
+    workspaceId?: string | undefined;
+    /** `"current"` (default) or a `YYYY-MM` allowance period. */
+    period?: UsageAllowancePeriod | undefined;
+    /** Re-read on an interval. Off by default; usage changes only when work settles. */
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+    /**
+     * Re-read whenever this value changes, keeping the current reading while it
+     * loads. Pass something that changes when work settles (a turn count, the
+     * session status) so the meter follows real usage without polling.
+     */
+    refreshKey?: unknown;
+};
+export type UseUsageResult = {
+    /** The raw `/usage/me` response: the workspace pool and your own row. */
+    usage: WorkspaceUsageResponse | null;
+    /** What to tell this member; null until loaded. */
+    summary: UsageSummary | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * The signed-in member's own usage in one workspace, read through `/usage/me`
+ * (the session proxy serves exactly this route). Never reads another member.
+ */
+export declare function useUsage(options?: UseUsageOptions): UseUsageResult;

package/dist/hooks/use-workspace-edit.d.ts

@@ -1,3 +1,4 @@
+import type { FileSystemRouteIdentity } from "@opengeni/sdk";
 import { type ClientOverride } from "../provider.js";
 /**
  * The wake-on-edit state machine. This hook owns the logic and the UI renders
@@ -27,6 +28,9 @@ export type UseWorkspaceEditOptions = ClientOverride & {
     path?: string | null | undefined;
     /** The capture-served content loaded into the editor — the flush base (C2). */
     baseContent?: string | null | undefined;
+    /** Exact capability identity for the selected filesystem route. A route/root
+     * change discards the buffered edit and makes stale flushes fail retryably. */
+    route?: FileSystemRouteIdentity | undefined;
     /** `capabilities.liveness` — "warm" | "draining" | "cold". Drives the flush. */
     liveness?: string | undefined;
     /** True while the host is actively warming the box (attach in flight, not warm

package/dist/hooks/use-workspace-sessions.d.ts

@@ -1,30 +1,52 @@
-import type { Session } from "@opengeni/sdk";
+import type { Session, SessionListEntry, SessionListTotals } from "@opengeni/sdk";
 import { type ClientOverride } from "../provider.js";
 export type UseWorkspaceSessionsOptions = ClientOverride & {
+    includeTotals?: boolean | undefined;
+    needsYouOnly?: boolean | undefined;
+    /** Compact list records; detail reads remain full sessions. */
+    projection?: "summary" | undefined;
     limit?: number | undefined;
     parentSessionId?: string | null | undefined;
     cursor?: string | undefined;
     search?: string | undefined;
     /** Return only the complete personal pinned projection. */
     pinsOnly?: boolean | undefined;
+    /** Skip pinned details when the pinned section is loaded separately. */
+    includePinned?: boolean | undefined;
+    archivedOnly?: boolean | undefined;
+    sortBy?: "updatedAt" | "createdAt" | "name" | undefined;
+    archiveStatus?: "active" | "archived" | "all" | undefined;
     /** Refresh interval (ms) for fleet/manager views. Off by default. */
     pollIntervalMs?: number | undefined;
     enabled?: boolean | undefined;
+    /** Optional shared causal clock invoked when each network read starts. */
+    beginRead?: (() => number) | undefined;
 };
-export type UseWorkspaceSessionsResult = {
+export type UseWorkspaceSessionsResult<T extends Session | SessionListEntry = Session> = {
     /**
      * All visible rows, with pins first. This preserves the pre-pinning hook
      * contract for consumers that only read `sessions`.
      */
-    sessions: Session[];
+    sessions: T[];
     /** The complete personal pinned section, also present in `sessions`. */
-    pinned: Session[];
+    pinned: T[];
     /** True when the server omitted older pins from its bounded pinned section. */
     pinnedTruncated: boolean;
+    totals: SessionListTotals | null;
     nextCursor: string | null;
     loading: boolean;
     error: Error | null;
+    /** Monotonic revision of accepted authoritative list-page reads. */
+    readRevision: number;
+    /** Causal generation captured when the accepted network read started. */
+    readGeneration: number;
     refresh: () => Promise<void>;
 };
 /** List the workspace's sessions — the data behind fleet and manager views. */
-export declare function useWorkspaceSessions(options?: UseWorkspaceSessionsOptions): UseWorkspaceSessionsResult;
+export declare function useWorkspaceSessions(options: UseWorkspaceSessionsOptions & {
+    projection: "summary";
+}): UseWorkspaceSessionsResult<SessionListEntry>;
+export declare function useWorkspaceSessions(options?: UseWorkspaceSessionsOptions & {
+    projection?: undefined;
+}): UseWorkspaceSessionsResult;
+export declare function useWorkspaceSessions(options: UseWorkspaceSessionsOptions): UseWorkspaceSessionsResult<Session | SessionListEntry>;

package/dist/human-input.d.ts

@@ -1,4 +1,4 @@
-import type { HumanInputQuestion, SessionEvent } from "@opengeni/sdk";
+import type { HumanInputQuestion, SessionEvent, SessionHumanInputRequest } from "@opengeni/sdk";
 /** Minimal actionable request shape available from the durable event log. */
 export type PendingHumanInputRequest = {
     id: string;
@@ -7,6 +7,8 @@ export type PendingHumanInputRequest = {
     allowSkip: boolean;
     expiresAt: string | null;
 };
+/** A pending row stops being actionable at its durable deadline, even before refresh. */
+export declare function isActionableHumanInputRequest(request: Pick<SessionHumanInputRequest, "status" | "expiresAt">, nowMs?: number): boolean;
 /** Parse one generic `session.humanInput.requested` event defensively. */
 export declare function humanInputRequestFromEvent(event: Pick<SessionEvent, "type" | "payload" | "turnId">): PendingHumanInputRequest | null;
 /**

package/dist/identity-link-accounts.d.ts

@@ -0,0 +1,11 @@
+import type { ExternalIdentityLink, ExternalIdentityLinkPage } from "@opengeni/sdk";
+export type IdentityLinkAccountsClient = {
+    listIdentityLinks(workspaceId: string, cursor?: string): Promise<ExternalIdentityLinkPage>;
+    revokeIdentityLink(workspaceId: string, linkId: string, expectedRevision: number): Promise<ExternalIdentityLink>;
+};
+/** Participant-scoped inventory. Revocation never deletes native work or merges
+ * identities. The caller remounts this component when the signed-in user changes. */
+export declare function IdentityLinkAccounts({ client, workspaceId, }: {
+    client: IdentityLinkAccountsClient;
+    workspaceId: string;
+}): import("react").JSX.Element;

package/dist/identity-link-consent.d.ts

@@ -0,0 +1,18 @@
+import type { ExternalIdentityLink, ConfirmExternalIdentityLinkRequest, ExternalIdentityLinkPreview } from "@opengeni/sdk";
+export type IdentityLinkClient = {
+    previewIdentityLink(workspaceId: string, linkId: string, challenge: string): Promise<ExternalIdentityLinkPreview>;
+    confirmIdentityLink(workspaceId: string, linkId: string, input: ConfirmExternalIdentityLinkRequest): Promise<ExternalIdentityLink>;
+    revokeIdentityLink(workspaceId: string, linkId: string, expectedRevision: number): Promise<ExternalIdentityLink>;
+};
+export type IdentityLinkConsentProps = {
+    client: IdentityLinkClient;
+    workspaceId: string;
+    linkId: string;
+    challenge: string;
+    /** Host label is explanatory, never proof of the requesting application. */
+    className?: string;
+    onComplete?: (link: ExternalIdentityLink) => void;
+};
+/** Optional native-login consent. Ordinary Connect does not use this surface.
+ * Permission choices only narrow the server's request; no automatic approval. */
+export declare function IdentityLinkConsent({ client, workspaceId, linkId, challenge, className, onComplete, }: IdentityLinkConsentProps): import("react").JSX.Element;