@opengeni/react 0.23.0 → 0.25.5

package/dist/machines.js

@@ -24,9 +24,10 @@ import {
   healthPulses,
   pointsFor,
   useMachines
-} from "./chunk-6XUS5VFM.js";
+} from "./chunk-YU5PGUK7.js";
 import "./chunk-TK7G6XLT.js";
-import "./chunk-I3BJZIG5.js";
+import "./chunk-HIWPQYWI.js";
+import "./chunk-M7X4JZOD.js";
 export {
   CONNECTION_STATUS_META,
   ConnectionDot,

package/dist/session-Du_FsrZ1.d.ts

@@ -0,0 +1,264 @@
+import { C as ClientOverride, E as EmbeddedSessionClientOverride, e as EmbeddedSessionMcpApprovalPolicyClientOverride, f as EmbeddedHumanInputClientOverride } from './session-context-rgrfElMl.js';
+import { Session, SessionEvent, StreamConnectionState, SessionStatus, SessionGoal, SessionControlResponse, SessionMcpServerMetadata, SessionMcpApprovalPolicy, UpdateSessionMcpApprovalPolicyResponse, SessionLineageResponse, HumanInputQuestion, SessionHumanInputRequest, SubmitHumanInputResponseRequest } from '@opengeni/sdk';
+import { S as SessionEventFeedOptions } from './use-composer-BnEzheSk.js';
+import { e as TimelineItem, d as TimelineGroup } from './use-turn-queue-3rkJwjFv.js';
+import './use-file-attachments-C0kpHrs9.js';
+
+type UseSessionOptions = ClientOverride & SessionEventFeedOptions & {
+    /** Re-fetch on an interval (ms). Off by default — pair with `useSessionEvents` for live status. */
+    pollIntervalMs?: number | undefined;
+};
+type UseSessionResult = {
+    session: Session | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    /** Manually rename the session (PATCH, source='user'). Returns the updated session, or null on failure. */
+    updateTitle: (title: string) => Promise<Session | null>;
+    /** True while a rename is in flight. */
+    updating: boolean;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/** Event types that change the session title (auto + cross-client renames). */
+declare function isTitleEvent(event: Pick<SessionEvent, "type">): boolean;
+/** Fetch one session (with optional polling), live-patching its title on `session.title_set`. */
+declare function useSession(sessionId: string | null | undefined, options?: UseSessionOptions): UseSessionResult;
+
+type SessionEventsConnectionState = StreamConnectionState | "idle" | "ended" | "error";
+type UseSessionEventsOptions = EmbeddedSessionClientOverride & {
+    /** Resume after this sequence (exclusive). Nonzero keeps full replay/resume semantics. */
+    after?: number | undefined;
+    /** Load a bounded tail by default, or opt back into full replay from `after`. */
+    replay?: "windowed" | "full" | undefined;
+    /** Pause the stream without unmounting (e.g. hidden tab). Defaults to true. */
+    enabled?: boolean | undefined;
+};
+type UseSessionEventsResult = {
+    /** Replayed + live events, ordered by sequence, no gaps, no duplicates. */
+    events: SessionEvent[];
+    /** Projected, renderable timeline (memoized over `events`). */
+    timeline: TimelineItem[];
+    /** Latest session status observed in the event log, if any. */
+    sessionStatus: SessionStatus | null;
+    connectionState: SessionEventsConnectionState;
+    /** Highest sequence seen so far (0 before the first event). */
+    lastSequence: number;
+    /** Exact serialized bytes retained in the current browser event window. */
+    windowBytes: number;
+    /** Whether older delivered events were evicted from the browser window. */
+    windowTruncated: boolean;
+    /** True until the initial tail window has been applied (windowed mode). */
+    initialLoading: 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>;
+    error: Error | null;
+};
+declare const SESSION_EVENT_BROWSER_MAX_BYTES: number;
+declare const SESSION_EVENT_BROWSER_MAX_COUNT = 10000;
+declare const SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES: number;
+declare const SESSION_EVENT_BROWSER_PENDING_MAX_BYTES: number;
+declare const SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
+type BrowserSessionEventWindow = {
+    events: SessionEvent[];
+    bytes: number;
+    truncated: boolean;
+};
+/**
+ * Live-stream a session's event log with replay-by-sequence, reconnect, and
+ * batched React updates. Fresh loads default to a bounded tail window; pass
+ * `replay: "full"` or a nonzero `after` for the previous full replay path.
+ */
+declare function useSessionEvents(sessionId: string | null | undefined, options?: UseSessionEventsOptions): UseSessionEventsResult;
+/**
+ * Keep one direction-aware count+byte-bounded browser window. Live/default
+ * 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.
+ */
+declare function boundBrowserSessionEventWindow(events: readonly SessionEvent[], options?: {
+    maxBytes?: number;
+    maxCount?: number;
+    direction?: "newest" | "oldest";
+}): BrowserSessionEventWindow;
+
+/** Event types that change the session goal (set/updated/completed/paused/...). */
+declare function isGoalEvent(event: Pick<SessionEvent, "type">): boolean;
+type UseGoalOptions = ClientOverride & SessionEventFeedOptions & {
+    /** Optional safety-net polling (ms). Off by default — event refreshes drive updates. */
+    pollIntervalMs?: number | undefined;
+};
+type UseGoalResult = {
+    /** The session goal, or null when the session has none. */
+    goal: SessionGoal | null;
+    /** Convenience flags over `goal.status`. */
+    isActive: boolean;
+    isPaused: boolean;
+    isCompleted: boolean;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    /** Pause the goal loop (PATCH status=paused). */
+    pause: (rationale?: string) => Promise<SessionGoal | null>;
+    /** Resume a paused goal: resets counters and re-arms continuations. */
+    resume: () => Promise<SessionGoal | null>;
+    /** Clear the session goal; goal-less sessions remain a successful no-op. */
+    clearGoal: () => Promise<void>;
+    /** Alias for `clearGoal`. */
+    deleteGoal: () => Promise<void>;
+    /** True while a pause/resume/clear is in flight. */
+    updating: boolean;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/**
+ * The session's goal: state, the autonomy counters (`autoContinuations`,
+ * `noProgressStreak`), and pause/resume control. A goal-less session yields
+ * `goal: null` (the 404 is absorbed). Live-updates on goal, turn, session,
+ * control, and system-update events — pass `options.events` from
+ * `useSessionEvents` to reuse its stream.
+ */
+declare function useGoal(sessionId: string | null | undefined, options?: UseGoalOptions): UseGoalResult;
+
+type UseSessionControlOptions = EmbeddedSessionClientOverride;
+type UseSessionControlResult = {
+    pause: (reason?: string) => Promise<SessionControlResponse | null>;
+    resume: (reason?: string) => Promise<SessionControlResponse | null>;
+    controlling: boolean;
+    /** Approve a pending `requires_action` approval. */
+    approve: (approvalId: string, message?: string) => Promise<SessionEvent | null>;
+    /** Reject a pending `requires_action` approval. */
+    reject: (approvalId: string, message?: string) => Promise<SessionEvent | null>;
+    /** True while an approval decision is in flight. */
+    responding: boolean;
+    error: Error | null;
+    clearError: () => void;
+};
+/**
+ * Session pause/resume and approval decisions. Pair with
+ * `useSessionEvents` (for `session.requiresAction` payloads carrying the
+ * `approvalId`) to render an approval bar.
+ */
+declare function useSessionControl(sessionId: string | null | undefined, options?: UseSessionControlOptions): UseSessionControlResult;
+
+declare function isSessionMcpApprovalPolicyEvent(event: Pick<SessionEvent, "type" | "payload">, serverId?: string): boolean;
+type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolicyClientOverride & SessionEventFeedOptions & {
+    /** Optional safety-net polling (ms). Off by default; policy events drive refreshes. */
+    pollIntervalMs?: number | undefined;
+};
+type UseSessionMcpApprovalPolicyResult = {
+    server: SessionMcpServerMetadata | null;
+    policy: SessionMcpApprovalPolicy | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    update: (policy: SessionMcpApprovalPolicy) => Promise<UpdateSessionMcpApprovalPolicyResponse | null>;
+    updating: boolean;
+    clearError: () => void;
+};
+/**
+ * Read and update one existing session MCP server's approval policy. Updates
+ * become effective for the next claimed attempt; current work is unchanged.
+ */
+declare function useSessionMcpApprovalPolicy(sessionId: string | null | undefined, serverId: string | null | undefined, options?: UseSessionMcpApprovalPolicyOptions): UseSessionMcpApprovalPolicyResult;
+
+type UseSessionLineageOptions = ClientOverride & {
+    events?: SessionEvent[] | undefined;
+    /** Refresh interval (ms). Off by default. */
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+};
+type UseSessionLineageResult = {
+    lineage: SessionLineageResponse | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+declare function isLineageRefreshEvent(event: SessionEvent): boolean;
+/** Read the ancestors + descendant tree for one session. Data-only; no UI state. */
+declare function useSessionLineage(sessionId: string | null | undefined, options?: UseSessionLineageOptions): UseSessionLineageResult;
+
+type PendingApproval = {
+    /** The id to send back via `user.approvalDecision` (`approvalId`). */
+    id: string;
+    /** Tool/function name awaiting the decision. */
+    name: string;
+    arguments?: unknown;
+    /** The raw approval entry from the `session.requiresAction` payload. */
+    raw?: unknown;
+};
+/** The approvals carried by one `session.requiresAction` payload. */
+declare function approvalsFromRequiresAction(payload: unknown): PendingApproval[];
+/** The approvals still awaiting a decision after replaying `events` in order. */
+declare function projectPendingApprovals(events: SessionEvent[]): PendingApproval[];
+
+/** Minimal actionable request shape available from the durable event log. */
+type PendingHumanInputRequest = {
+    id: string;
+    turnId: string | null;
+    questions: HumanInputQuestion[];
+    allowSkip: boolean;
+    expiresAt: string | null;
+};
+/** Parse one generic `session.humanInput.requested` event defensively. */
+declare function humanInputRequestFromEvent(event: Pick<SessionEvent, "type" | "payload" | "turnId">): PendingHumanInputRequest | null;
+/**
+ * Fold a durable event log into the structured requests that are actionable
+ * now. Responses remove one request; a terminal owning turn clears any
+ * unresolved requests that died with it. Replaying history cannot resurrect a
+ * previously answered card.
+ */
+declare function projectPendingHumanInputRequests(events: SessionEvent[]): PendingHumanInputRequest[];
+
+/** Events that can create, settle, or invalidate an actionable request. */
+declare function isHumanInputEvent(event: Pick<SessionEvent, "type">): boolean;
+type UseHumanInputRequestsOptions = EmbeddedHumanInputClientOverride & SessionEventFeedOptions & {
+    /** Optional safety-net polling. Durable events drive refresh by default. */
+    pollIntervalMs?: number | undefined;
+};
+type UseHumanInputRequestsResult = {
+    requests: SessionHumanInputRequest[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    respond: (requestId: string, response: SubmitHumanInputResponseRequest) => Promise<SessionEvent | null>;
+    respondingRequestId: string | null;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/**
+ * Authoritative structured-human-input hook. The server's pending-request
+ * table is the read model; events only trigger reconciliation. This lets an
+ * embedded host use the same primitive with a shared event feed or its own SDK
+ * proxy without rebuilding request lifecycle logic.
+ */
+declare function useHumanInputRequests(sessionId: string | null | undefined, options?: UseHumanInputRequestsOptions): UseHumanInputRequestsResult;
+
+/** Readable label for a tool call, without leaking an MCP server prefix. */
+declare function toolDisplayName(name: string): string;
+declare function buildTimeline(events: SessionEvent[]): TimelineItem[];
+/**
+ * Whether the session's most recent turn ended in credit exhaustion — the
+ * terminal credit state apps key their "add credits" affordances on. Derived
+ * from the LAST turn-end event (completed/failed/cancelled): a later turn that
+ * settles any other way (someone topped up and kept working) clears it.
+ */
+declare function creditExhaustedFromEvents(events: SessionEvent[]): boolean;
+/** The latest session status carried in the event log, if any. */
+declare function sessionStatusFromEvents(events: SessionEvent[]): SessionStatus | null;
+declare function groupTimeline(items: TimelineItem[]): TimelineGroup[];
+/**
+ * Find a session id in orchestration tool arguments or output. Handles raw
+ * objects, JSON strings, and MCP tool results (`{ content: [{ type: "text",
+ * text: "{...}" }], structuredContent? }`).
+ */
+declare function extractSessionRef(value: unknown, depth?: number): string | null;
+
+export { isGoalEvent as A, type BrowserSessionEventWindow as B, isHumanInputEvent as C, isLineageRefreshEvent as D, isSessionMcpApprovalPolicyEvent as E, isTitleEvent as F, projectPendingApprovals as G, projectPendingHumanInputRequests as H, sessionStatusFromEvents as I, toolDisplayName as J, useGoal as K, useHumanInputRequests as L, useSession as M, useSessionControl as N, useSessionEvents as O, type PendingApproval as P, useSessionLineage as Q, useSessionMcpApprovalPolicy as R, SESSION_EVENT_BROWSER_MAX_BYTES as S, type UseGoalOptions as U, type PendingHumanInputRequest as a, SESSION_EVENT_BROWSER_MAX_COUNT as b, SESSION_EVENT_BROWSER_PENDING_MAX_BYTES as c, SESSION_EVENT_BROWSER_PENDING_MAX_COUNT as d, SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES as e, type SessionEventsConnectionState as f, type UseGoalResult as g, type UseHumanInputRequestsOptions as h, type UseHumanInputRequestsResult as i, type UseSessionControlOptions as j, type UseSessionControlResult as k, type UseSessionEventsOptions as l, type UseSessionEventsResult as m, type UseSessionLineageOptions as n, type UseSessionLineageResult as o, type UseSessionMcpApprovalPolicyOptions as p, type UseSessionMcpApprovalPolicyResult as q, type UseSessionOptions as r, type UseSessionResult as s, approvalsFromRequiresAction as t, boundBrowserSessionEventWindow as u, buildTimeline as v, creditExhaustedFromEvents as w, extractSessionRef as x, groupTimeline as y, humanInputRequestFromEvent as z };

package/dist/session-ui-BqQDH7YV.d.ts

@@ -0,0 +1,183 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { SessionHumanInputRequest, SubmitHumanInputResponseRequest, HumanInputQuestion, HumanInputAnswer, SessionEvent, SessionStatus } from '@opengeni/sdk';
+import { ReactNode, ComponentType } from 'react';
+import { h as UseTurnQueueResult, f as ToolCallItem, e as TimelineItem, a as AgentMessageItem, i as UserMessageItem, b as AuthNeededItem } from './use-turn-queue-3rkJwjFv.js';
+import { C as ComposerState } from './use-composer-BnEzheSk.js';
+
+/** The sole human prompt queue: compact above Goal, Agents, and composer. */
+type QueueSurfaceCommonProps = {
+    /** Focus the composer owned by this queue after checkout/removal. */
+    onRequestComposerFocus?: (() => void) | undefined;
+};
+type QueueSurfaceProps = (QueueSurfaceCommonProps & {
+    queue: UseTurnQueueResult;
+    composer: ComposerState;
+    readOnly?: false | undefined;
+}) | (QueueSurfaceCommonProps & {
+    queue: UseTurnQueueResult;
+    composer?: undefined;
+    readOnly: true;
+});
+
+/** The sole human prompt queue: compact above Goal, Agents, and composer. */
+declare const QueueSurface: (props: QueueSurfaceProps) => react_jsx_runtime.JSX.Element | null;
+
+type HumanInputAnswerDraft = {
+    values: string[];
+    other: string;
+    otherSelected: boolean;
+};
+type HumanInputFormMessages = {
+    title: string;
+    description: string;
+    submit: string;
+    skip: string;
+    submitting: string;
+    other: string;
+    deadlineLabel: string;
+    formatDeadline: (value: string) => string;
+    required: string;
+    minLength: (count: number) => string;
+    maxLength: (count: number) => string;
+    otherRequired: string;
+    minSelections: (count: number) => string;
+    maxSelections: (count: number) => string;
+};
+declare const defaultHumanInputFormMessages: HumanInputFormMessages;
+type HumanInputFormProps = {
+    request: Pick<SessionHumanInputRequest, "id" | "questions" | "allowSkip" | "expiresAt">;
+    onSubmit: (response: SubmitHumanInputResponseRequest) => void | Promise<void>;
+    submitting?: boolean | undefined;
+    error?: string | null | undefined;
+    title?: ReactNode;
+    description?: ReactNode;
+    submitLabel?: string | undefined;
+    skipLabel?: string | undefined;
+    messages?: Partial<HumanInputFormMessages> | undefined;
+    autoFocus?: boolean | undefined;
+    className?: string | undefined;
+};
+/**
+ * Styled but host-neutral renderer for one structured request. Hosts can use
+ * the headless `useHumanInputRequests` hook instead, or replace the title and
+ * description while retaining accessible field semantics and validation.
+ */
+declare function HumanInputForm({ request, onSubmit, submitting, error, title, description, submitLabel, skipLabel, messages: messageOverrides, autoFocus, className, }: HumanInputFormProps): react_jsx_runtime.JSX.Element;
+declare function answersFromDrafts(questions: HumanInputQuestion[], drafts: Record<string, HumanInputAnswerDraft>, messageOverrides?: Partial<HumanInputFormMessages>): {
+    answers: HumanInputAnswer[];
+    errors: Record<string, string>;
+};
+
+type ToolRendererProps = {
+    item: ToolCallItem;
+};
+type ToolRenderer = ComponentType<ToolRendererProps>;
+/** A registry entry: which key it matches and the component that renders it. */
+type ToolRegistryEntry = {
+    match: "rawType";
+    type: string;
+    render: ToolRenderer;
+} | {
+    match: "name";
+    name: string;
+    render: ToolRenderer;
+};
+type ToolRegistry = {
+    /** Resolve the renderer for a call (never null — falls back to generic). */
+    resolve: (item: ToolCallItem) => ToolRenderer;
+    /** The generic fallback renderer. */
+    fallback: ToolRenderer;
+};
+type CreateToolRegistryOptions = {
+    /**
+     * Entries that take precedence over the built-ins. Earlier entries win, so a
+     * consumer can shadow a default renderer for the same key.
+     */
+    entries?: ToolRegistryEntry[] | undefined;
+    /** Replace the generic fallback used for unmatched tools. */
+    fallback?: ToolRenderer | undefined;
+};
+/** The `raw.type` of a projected tool call, when the provider item carries one. */
+declare function rawTypeOf(item: ToolCallItem): string | null;
+/**
+ * Build a tool registry from a set of entries and a fallback. The returned
+ * registry resolves in priority order: `raw.type` entries first, then `name`
+ * entries, then the fallback. Consumer `entries` are consulted before the
+ * built-in `baseEntries`, so they shadow defaults cleanly.
+ */
+declare function createToolRegistry(baseEntries: ToolRegistryEntry[], baseFallback: ToolRenderer, options?: CreateToolRegistryOptions): ToolRegistry;
+
+type MessageTimelineProps = {
+    /** Raw session events (projected internally) … */
+    events?: SessionEvent[] | undefined;
+    /** … or pre-projected items (e.g. from `useSessionEvents().timeline`). */
+    items?: TimelineItem[] | undefined;
+    /** Current session status; drives the live "working" indicator. */
+    status?: SessionStatus | null | undefined;
+    /** Plug a markdown renderer for message bodies (e.g. streamdown). */
+    renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
+    /** Drill into a spawned worker session. */
+    onOpenSession?: ((sessionId: string) => void) | undefined;
+    /**
+     * Deep-link a memory row (a `memory.saved` / `memory.corrected` step) to its
+     * record in the host's memory pane. Opt-in, exactly like `onReconnect`: the
+     * library draws no "View in memory" affordance without a handler — the memory
+     * row is then non-interactive rich content. This is the switch that makes the
+     * deep-link a first-party OpenGeni capability without other SDK consumers
+     * opting into it. The app supplies it (it owns routing to the memory pane).
+     */
+    onMemoryClick?: ((memoryId: string) => void) | undefined;
+    /**
+     * Start the reconnect flow when a tool needs its connection reauthorized. The
+     * app supplies this (it owns the SDK client + workspace): it typically kicks
+     * off `startConnectionOAuth` and redirects, or routes to credential entry.
+     * Rejecting surfaces a calm inline error on the card; the library never draws
+     * a Reconnect button without a handler to run it.
+     */
+    onReconnect?: ((item: AuthNeededItem) => void | Promise<void>) | undefined;
+    /**
+     * Resolve a provider domain (from a reconnect card) to a logo URL the host
+     * serves itself — the app maps it through its catalog + `catalogAssetUrl`.
+     * Return null/undefined to fall back to a calm monogram. The library never
+     * fetches an off-origin favicon (CSP + privacy); an unresolved logo is a
+     * monogram, not an external image.
+     */
+    resolveProviderLogo?: ((providerDomain: string) => string | null | undefined) | undefined;
+    /**
+     * The tool-renderer registry that resolves how each tool call is drawn.
+     * Defaults to {@link defaultToolRegistry}; pass a registry from
+     * `createDefaultToolRegistry({ entries })` to add custom tool renderers.
+     */
+    toolRegistry?: ToolRegistry | undefined;
+    /** Follow new events when pinned to the bottom. Defaults to true. */
+    autoFollow?: boolean | undefined;
+    /** Older durable history exists above the current window (see useSessionEvents). */
+    hasOlder?: boolean | undefined;
+    /** An older window is being fetched; shows the quiet top shimmer. */
+    loadingOlder?: boolean | undefined;
+    /** Called when the reader nears the top and older history should backfill. */
+    onLoadOlder?: (() => void) | undefined;
+    emptyState?: ReactNode | undefined;
+    className?: string | undefined;
+};
+/**
+ * The session timeline: chat messages with streaming deltas, collapsed
+ * activity clusters (reasoning, tool calls, sandbox work), spawned-worker
+ * cards, goal markers, and status transitions. Owns stick-to-bottom scrolling
+ * with a "jump to latest" affordance when the reader scrolls back.
+ */
+declare function MessageTimeline({ events, items, status, renderMessageText, onOpenSession, onMemoryClick, onReconnect, resolveProviderLogo, toolRegistry, autoFollow, hasOlder, loadingOlder, onLoadOlder, emptyState, className, }: MessageTimelineProps): react_jsx_runtime.JSX.Element;
+/**
+ * Render one non-activity timeline item (chat message, status divider, goal
+ * landmark, notice). Exported so the component demo draws the EXACT same rows as
+ * the live app — no forked bubble/goal markup.
+ */
+declare function TimelineRow({ item, renderMessageText, onReconnect, resolveProviderLogo, onOpenSession, }: {
+    item: TimelineItem;
+    renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
+    onReconnect?: ((item: AuthNeededItem) => void | Promise<void>) | undefined;
+    resolveProviderLogo?: ((providerDomain: string) => string | null | undefined) | undefined;
+    onOpenSession?: ((sessionId: string) => void) | undefined;
+}): react_jsx_runtime.JSX.Element | null;
+
+export { type CreateToolRegistryOptions as C, type HumanInputAnswerDraft as H, MessageTimeline as M, QueueSurface as Q, type ToolRegistry as T, HumanInputForm as a, type HumanInputFormMessages as b, createToolRegistry as c, type HumanInputFormProps as d, type MessageTimelineProps as e, type QueueSurfaceProps as f, TimelineRow as g, type ToolRegistryEntry as h, type ToolRenderer as i, type ToolRendererProps as j, answersFromDrafts as k, defaultHumanInputFormMessages as l, rawTypeOf as r };

package/dist/session-ui.d.ts

@@ -0,0 +1,7 @@
+export { H as HumanInputAnswerDraft, a as HumanInputForm, b as HumanInputFormMessages, d as HumanInputFormProps, M as MessageTimeline, e as MessageTimelineProps, Q as QueueSurface, f as QueueSurfaceProps, g as TimelineRow } from './session-ui-BqQDH7YV.js';
+import 'react/jsx-runtime';
+import '@opengeni/sdk';
+import 'react';
+import './use-turn-queue-3rkJwjFv.js';
+import './session-context-rgrfElMl.js';
+import './use-composer-BnEzheSk.js';

package/dist/session-ui.js

@@ -0,0 +1,17 @@
+import {
+  HumanInputForm,
+  MessageTimeline,
+  QueueSurface,
+  TimelineRow
+} from "./chunk-GQN2QIR2.js";
+import "./chunk-TK7G6XLT.js";
+import "./chunk-OZDLELJQ.js";
+import "./chunk-M7X4JZOD.js";
+import "./chunk-YDNWMKXO.js";
+export {
+  HumanInputForm,
+  MessageTimeline,
+  QueueSurface,
+  TimelineRow
+};
+//# sourceMappingURL=session-ui.js.map

package/dist/session-ui.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/session.d.ts

@@ -1,4 +1,6 @@
 export { E as ClientOverride, f as HumanInputClientOverride, a as HumanInputSessionClientLike, b as SessionClientLike, c as SessionMcpApprovalPolicyClientLike, e as SessionMcpApprovalPolicyClientOverride } from './session-context-rgrfElMl.js';
-export { A as ActivityItem, c as AgentMessageItem, e as AuthNeededItem, G as GoalItem, a0 as MemoryItem, N as NoticeItem, P as PendingApproval, f as PendingHumanInputRequest, Q as QueueMutationKind, R as ReasoningItem, k as SandboxItem, l as SessionEventsConnectionState, m as SessionStatusItem, n as TimelineGroup, b as TimelineItem, T as ToolCallItem, o as TurnEndItem, a as TurnOutcome, p as UseHumanInputRequestsOptions, q as UseHumanInputRequestsResult, r as UseSessionControlOptions, s as UseSessionControlResult, t as UseSessionEventsOptions, u as UseSessionEventsResult, v as UseSessionMcpApprovalPolicyOptions, w as UseSessionMcpApprovalPolicyResult, x as UseTurnQueueOptions, U as UseTurnQueueResult, d as UserMessageItem, a1 as WorkerCompletionItem, W as WorkerItem, y as approvalsFromRequiresAction, C as buildTimeline, D as creditExhaustedFromEvents, E as extractSessionRef, F as groupTimeline, H as humanInputRequestFromEvent, I as isHumanInputEvent, J as isSessionMcpApprovalPolicyEvent, K as isTurnQueueEvent, L as projectPendingApprovals, M as projectPendingHumanInputRequests, O as sessionStatusFromEvents, V as toolDisplayName, X as useHumanInputRequests, Y as useSessionControl, Z as useSessionEvents, _ as useSessionMcpApprovalPolicy, $ as useTurnQueue } from './session-Db00TRwl.js';
-export { a as ComposerSendExtras, C as ComposerState, F as FILE_ONLY_MESSAGE_TEXT, U as UseComposerOptions, c as composeSendInput, s as shouldSteerOnKey, b as shouldSubmitOnKey, u as useComposer } from './use-composer-By1wn3MM.js';
+export { P as PendingApproval, a as PendingHumanInputRequest, f as SessionEventsConnectionState, U as UseGoalOptions, g as UseGoalResult, h as UseHumanInputRequestsOptions, i as UseHumanInputRequestsResult, j as UseSessionControlOptions, k as UseSessionControlResult, l as UseSessionEventsOptions, m as UseSessionEventsResult, n as UseSessionLineageOptions, o as UseSessionLineageResult, p as UseSessionMcpApprovalPolicyOptions, q as UseSessionMcpApprovalPolicyResult, r as UseSessionOptions, s as UseSessionResult, t as approvalsFromRequiresAction, v as buildTimeline, w as creditExhaustedFromEvents, x as extractSessionRef, y as groupTimeline, z as humanInputRequestFromEvent, A as isGoalEvent, C as isHumanInputEvent, D as isLineageRefreshEvent, E as isSessionMcpApprovalPolicyEvent, F as isTitleEvent, G as projectPendingApprovals, H as projectPendingHumanInputRequests, I as sessionStatusFromEvents, J as toolDisplayName, K as useGoal, L as useHumanInputRequests, M as useSession, N as useSessionControl, O as useSessionEvents, Q as useSessionLineage, R as useSessionMcpApprovalPolicy } from './session-Du_FsrZ1.js';
+export { a as ComposerSendExtras, C as ComposerState, F as FILE_ONLY_MESSAGE_TEXT, U as UseComposerOptions, c as composeSendInput, s as shouldSteerOnKey, b as shouldSubmitOnKey, u as useComposer } from './use-composer-BnEzheSk.js';
+export { F as FileAttachment, a as UseFileAttachmentsOptions, U as UseFileAttachmentsResult, u as useFileAttachments } from './use-file-attachments-C0kpHrs9.js';
+export { A as ActivityItem, a as AgentMessageItem, b as AuthNeededItem, G as GoalItem, M as MemoryItem, N as NoticeItem, Q as QueueMutationKind, R as ReasoningItem, S as SandboxItem, c as SessionStatusItem, d as TimelineGroup, e as TimelineItem, f as ToolCallItem, g as TurnEndItem, T as TurnOutcome, U as UseTurnQueueOptions, h as UseTurnQueueResult, i as UserMessageItem, k as WorkerCompletionItem, W as WorkerItem, j as isTurnQueueEvent, u as useTurnQueue } from './use-turn-queue-3rkJwjFv.js';
 import '@opengeni/sdk';

package/dist/session.js

@@ -1,31 +1,41 @@
 import {
   approvalsFromRequiresAction,
-  buildTimeline,
-  creditExhaustedFromEvents,
-  extractSessionRef,
-  groupTimeline,
   humanInputRequestFromEvent,
+  isGoalEvent,
   isHumanInputEvent,
+  isLineageRefreshEvent,
   isSessionMcpApprovalPolicyEvent,
+  isTitleEvent,
   isTurnQueueEvent,
   projectPendingApprovals,
   projectPendingHumanInputRequests,
-  sessionStatusFromEvents,
-  toolDisplayName,
+  useFileAttachments,
+  useGoal,
   useHumanInputRequests,
+  useSession,
   useSessionControl,
   useSessionEvents,
+  useSessionLineage,
   useSessionMcpApprovalPolicy,
   useTurnQueue
-} from "./chunk-UAHPKLB6.js";
+} from "./chunk-MP6237JB.js";
 import {
   FILE_ONLY_MESSAGE_TEXT,
   composeSendInput,
   shouldSteerOnKey,
   shouldSubmitOnKey,
   useComposer
-} from "./chunk-UQS7OQDE.js";
-import "./chunk-I3BJZIG5.js";
+} from "./chunk-F4CFWKVI.js";
+import "./chunk-HIWPQYWI.js";
+import {
+  buildTimeline,
+  creditExhaustedFromEvents,
+  extractSessionRef,
+  groupTimeline,
+  sessionStatusFromEvents,
+  toolDisplayName
+} from "./chunk-OZDLELJQ.js";
+import "./chunk-M7X4JZOD.js";
 export {
   FILE_ONLY_MESSAGE_TEXT,
   approvalsFromRequiresAction,
@@ -35,8 +45,11 @@ export {
   extractSessionRef,
   groupTimeline,
   humanInputRequestFromEvent,
+  isGoalEvent,
   isHumanInputEvent,
+  isLineageRefreshEvent,
   isSessionMcpApprovalPolicyEvent,
+  isTitleEvent,
   isTurnQueueEvent,
   projectPendingApprovals,
   projectPendingHumanInputRequests,
@@ -45,9 +58,13 @@ export {
   shouldSubmitOnKey,
   toolDisplayName,
   useComposer,
+  useFileAttachments,
+  useGoal,
   useHumanInputRequests,
+  useSession,
   useSessionControl,
   useSessionEvents,
+  useSessionLineage,
   useSessionMcpApprovalPolicy,
   useTurnQueue
 };

package/dist/{use-composer-By1wn3MM.d.ts → use-composer-BnEzheSk.d.ts}

@@ -13,14 +13,20 @@ type SessionEventFeedOptions = {
 
 type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId">;
 type UseComposerOptions = EmbeddedSessionClientOverride & SessionEventFeedOptions & {
-    /** Called with the accepted text after a successful send. */
-    onSent?: ((text: string) => void) | undefined;
+    /** Called with the exact accepted wire input after a successful send. */
+    onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
     /**
      * Extra message fields (resources, tools, model, reasoningEffort) merged
      * into every send. A function is evaluated at send time so it can read the
      * surrounding UI state (attachment pickers, model selectors, ...).
      */
     sendExtras?: ComposerSendExtras | (() => ComposerSendExtras) | undefined;
+    /**
+     * Fail-closed delivery guard evaluated at send time. Attachment hosts use
+     * this to preserve unresolved upload cards until the operator waits,
+     * retries, or removes them; direct hook callers cannot bypass the UI gate.
+     */
+    sendBlocked?: (() => boolean) | undefined;
     /** Latest server-derived workstream control; bound into Send/Steer OCC. */
     effectiveControl?: EffectiveSessionControl | null | undefined;
     /** Apply durable model/tool/reasoning settings in the host's controlled UI. */