@opengeni/react-native 1.4.5-canary.37615713321001

package/dist/timeline/queue-dock.d.ts

@@ -0,0 +1,19 @@
+import type { ComposerDraft } from "@opengeni/sdk";
+import type { useTurnQueue } from "@opengeni/react/session";
+import { type ReactNode } from "react";
+type TurnQueue = ReturnType<typeof useTurnQueue>;
+/** The composer surface the dock checks prompts out into. */
+export interface QueueDockComposer {
+    draftRevision: number;
+    hasDraftContent: () => boolean;
+    applyDraft: (draft: ComposerDraft) => void;
+    draftPersistence?: "durable" | "disabled" | undefined;
+}
+export declare function QueueDock({ queue, composer, onComposerFocus, leading, }: {
+    queue: TurnQueue;
+    composer?: QueueDockComposer | undefined;
+    onComposerFocus?: (() => void) | undefined;
+    /** Chips sharing the queue chip's row (goal, agents, commands). */
+    leading?: ReactNode;
+}): import("react").JSX.Element | null;
+export {};

package/dist/timeline/session-actions.d.ts

@@ -0,0 +1,34 @@
+import type { Session, UpdateSessionPinRequest, UpdateSessionRequest } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+import { type NativeIconName } from "./icon.js";
+export interface SessionActionsClient {
+    updateSession(workspaceId: string, sessionId: string, request: UpdateSessionRequest): Promise<Session>;
+    updateSessionPin(workspaceId: string, sessionId: string, request: UpdateSessionPinRequest): Promise<Session>;
+}
+export interface SessionActionsProps {
+    session: Session;
+    client: SessionActionsClient;
+    /** Called with the server's session after a change, so the host can refresh. */
+    onChanged: (session: Session) => void;
+    /** Host actions appended after Rename and Pin. */
+    extraActions?: SessionAction[] | undefined;
+    onActionFeedback?: (() => void) | undefined;
+    /**
+     * Present the actions in a host-native menu (a UIMenu on iOS) anchored to the
+     * trigger instead of the slide-up sheet. The host wraps `trigger`.
+     */
+    renderMenu?: ((input: {
+        actions: SessionAction[];
+        trigger: ReactNode;
+    }) => ReactNode) | undefined;
+}
+export interface SessionAction {
+    key: string;
+    label: string;
+    icon: NativeIconName;
+    onPress: () => void;
+    destructive?: boolean | undefined;
+    /** SF Symbol for a native menu. */
+    systemImage?: string | undefined;
+}
+export declare function SessionActionsButton(props: SessionActionsProps): import("react").JSX.Element;

package/dist/timeline/session-list.d.ts

@@ -0,0 +1,50 @@
+import type { ClientModel, Session, SessionStatus } from "@opengeni/sdk";
+import { type SessionStatusTone } from "@opengeni/react/session-list-model";
+/** The web StatusDot: an 8pt dot with a gentle pulse for live states. */
+export declare function StatusDot({ tone, pulse, size, }: {
+    tone: SessionStatusTone;
+    pulse?: boolean;
+    size?: number;
+}): import("react").JSX.Element;
+/** The model maker's logo (OpenAI, Claude, Grok) with the web's neutral fallback. */
+export declare function ModelMark({ model, size, color, }: {
+    model: string;
+    size?: number;
+    color: string;
+}): import("react").JSX.Element;
+export interface SessionRowProps {
+    session: Session;
+    /** The deployment's client model catalog, for catalog labels. */
+    models: readonly ClientModel[];
+    onPress: () => void;
+    now?: Date | undefined;
+}
+/** One recent-session row, as the web home canvas renders it. */
+export declare function SessionRow({ session, models, onPress, now }: SessionRowProps): import("react").JSX.Element;
+/** A small-caps section label (web: text-2xs semibold uppercase tracking-wider). */
+export declare function SectionLabel({ children }: {
+    children: string;
+}): import("react").JSX.Element;
+/** The web's divided list: rows separated by a hairline in border/60. */
+export declare function SessionRowList(props: {
+    sessions: readonly Session[];
+    models: readonly ClientModel[];
+    onOpen: (sessionId: string) => void;
+}): import("react").JSX.Element;
+/** The web session status badge: tinted pill, breathing dot for live states. */
+export declare function SessionStatusBadge({ status, label }: {
+    status: SessionStatus;
+    label?: string;
+}): import("react").JSX.Element;
+/**
+ * A native navigation-bar title for a session: the title on one line and, under
+ * it, the run state as a status dot and quiet label (the web header badge's
+ * information without boxing a pill inside the bar's glass).
+ */
+export declare function SessionHeaderTitle({ title, status, statusLabel, align, }: {
+    title: string;
+    status: SessionStatus | null;
+    /** Override the label ("Paused" for a paused workstream). */
+    statusLabel?: string | undefined;
+    align?: "center" | "left";
+}): import("react").JSX.Element;

package/dist/timeline/session-screen.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from "react";
+import type { OpenGeniNativeSessionController } from "../use-native-session.js";
+import type { NativeFileAttachmentsResult } from "../attachments.js";
+import { type SessionComposerProps } from "./composer.js";
+import { type TurnFeedbackTarget } from "./feedback.js";
+import { type ApprovalStripProps, type HumanInputCardProps } from "./decisions.js";
+import type { ClientModel, OpenGeniClient } from "@opengeni/sdk";
+import { type NativeMessageTimelineProps } from "./message-timeline.js";
+export interface NativeSessionScreenProps extends Omit<NativeMessageTimelineProps, "items" | "events" | "status" | "trailing"> {
+    controller: OpenGeniNativeSessionController;
+    /** Composer slots (products add their own actions/options here). */
+    composer?: Partial<Pick<SessionComposerProps, "renderLeading" | "options" | "header" | "placeholder" | "onAttach" | "messages" | "onActionFeedback" | "voice">> | undefined;
+    /** Extra content after the question card (host recovery, banners). */
+    trailing?: ReactNode;
+    /** Fixed host chrome above the timeline, inside the keyboard-avoiding area. */
+    topBar?: ReactNode;
+    bottomInset?: number | undefined;
+    /** Distance from this screen's bottom edge to the window bottom (e.g. a tab bar). */
+    keyboardBottomOffset?: number | undefined;
+    /** Reply feedback (thumbs beside Copy), as the web timeline offers it. */
+    feedback?: TurnFeedbackTarget | undefined;
+    /** Translations for the question card (the shared human-input catalog). */
+    humanInputMessages?: HumanInputCardProps["messages"];
+    /** Translations for the approval strip. */
+    approvalMessages?: ApprovalStripProps["messages"];
+    /** Reads the commands panel (the full client; omit to hide command details). */
+    client?: OpenGeniClient | undefined;
+    /** Model catalog for the agents panel rows. */
+    models?: readonly ClientModel[] | undefined;
+}
+export declare function NativeSessionScreen({ controller, composer: composerSlots, trailing, topBar, bottomInset, keyboardBottomOffset, feedback, humanInputMessages, approvalMessages, client, models, renderMessageActions: hostMessageActions, ...timelineProps }: NativeSessionScreenProps): import("react").JSX.Element;
+/** Composer attachment chips: name, upload state, tap to retry a failure, remove. */
+export declare function AttachmentChips({ attachments }: {
+    attachments: NativeFileAttachmentsResult;
+}): import("react").JSX.Element | null;

package/dist/timeline/session-signals.d.ts

@@ -0,0 +1,37 @@
+import type { ClientModel, LineageNode, SessionBackgroundCommand } from "@opengeni/sdk";
+import type { UseGoalResult } from "@opengeni/react/session";
+import { type ReactNode } from "react";
+import { type TextStyle } from "react-native";
+import { type NativeTimelineTheme } from "./theme.js";
+export interface SessionCommandsSource {
+    commands: SessionBackgroundCommand[];
+    loading: boolean;
+    error: Error | null;
+    cancel: (commandId: string) => Promise<void>;
+}
+export declare function SessionSignals(props: {
+    goal?: UseGoalResult | null | undefined;
+    agents: readonly LineageNode[];
+    commandsCount: number;
+    /** Mounted only while the commands sheet is open, so a closed chip never polls. */
+    renderCommands: (close: () => void) => ReactNode;
+    onOpenSession?: ((sessionId: string) => void) | undefined;
+    models?: readonly ClientModel[] | undefined;
+    readOnly?: boolean | undefined;
+}): import("react").JSX.Element | null;
+/** The web commands panel: each running command with its state and a Stop action. */
+export declare function SessionCommandsList({ commands, readOnly, }: {
+    commands: SessionCommandsSource;
+    readOnly?: boolean | undefined;
+}): import("react").JSX.Element;
+/** The compact signal chip shared by goal, agents, commands and the queue. */
+export declare function signalChipStyle(theme: NativeTimelineTheme, pressed: boolean): {
+    flexDirection: "row";
+    alignItems: "center";
+    gap: number;
+    height: number;
+    paddingHorizontal: number;
+    borderRadius: number;
+    backgroundColor: string;
+};
+export declare function signalChipText(theme: NativeTimelineTheme): TextStyle;

package/dist/timeline/sheet.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+/**
+ * A content-sized bottom sheet: dimmed backdrop, grabber, drag or tap outside
+ * to dismiss, keyboard-aware and safe-area padded. The native counterpart of
+ * the web's anchored menus at phone width.
+ */
+export declare function BottomSheet(props: {
+    open: boolean;
+    onClose: () => void;
+    accessibilityLabel: string;
+    /** Cap as a fraction of the window height (default 0.85). */
+    maxHeightRatio?: number | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element | null;

package/dist/timeline/theme.d.ts

@@ -0,0 +1,58 @@
+import { type ReactNode } from "react";
+import { type TextStyle } from "react-native";
+import { webColorsLight } from "../ui/web-tokens.gen.js";
+export type WebColorToken = keyof typeof webColorsLight;
+export type NativeTimelineColors = Record<WebColorToken, string>;
+export interface NativeTimelineFonts {
+    /** Font family per weight for the sans face; undefined → platform system font. */
+    sans?: Partial<Record<"400" | "500" | "600" | "700", string>> | undefined;
+    /** Font family per weight for the mono face; undefined → platform monospace. */
+    mono?: Partial<Record<"400" | "500", string>> | undefined;
+    /** Regular-weight italic family (custom fonts cannot be synthesized italic on iOS). */
+    sansItalic?: string | undefined;
+    /** Extra sans letter spacing (pt) to match the web face's metrics. */
+    sansTracking?: number | undefined;
+}
+export interface NativeTimelineTheme {
+    scheme: "light" | "dark";
+    colors: NativeTimelineColors;
+    size: {
+        xs: number;
+        sm: number;
+        base: number;
+        md: number;
+        composer: number;
+    };
+    radius: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+        full: number;
+    };
+    fonts: NativeTimelineFonts;
+}
+export interface NativeTimelineThemeOverrides {
+    light?: Partial<NativeTimelineColors> | undefined;
+    dark?: Partial<NativeTimelineColors> | undefined;
+    fonts?: NativeTimelineFonts | undefined;
+}
+export declare function createNativeTimelineTheme(scheme: "light" | "dark", overrides?: NativeTimelineThemeOverrides): NativeTimelineTheme;
+/**
+ * Fill for an inset block on the page (code blocks). Web uses `surface-1`, which reads
+ * as a block on the component `bg`; when the host page itself is `surface-1` (the
+ * white or near-black app canvas), the block falls back to the web component `bg` so
+ * it never disappears into the page.
+ */
+export declare function insetSurface(theme: NativeTimelineTheme): string;
+export declare function NativeTimelineThemeProvider({ scheme, overrides, children, }: {
+    scheme: "light" | "dark";
+    overrides?: NativeTimelineThemeOverrides | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useNativeTimelineTheme(): NativeTimelineTheme;
+/** Text style for a web weight, resolving host font families when supplied. */
+export declare function fontStyle(theme: NativeTimelineTheme, weight?: 400 | 500 | 600 | 700, face?: "sans" | "mono"): TextStyle;
+declare const MONO_FALLBACK = "Menlo";
+export { MONO_FALLBACK };

package/dist/timeline/thinking-orb.d.ts

@@ -0,0 +1,13 @@
+import { type OrbState } from "thinking-orbs/engine";
+/**
+ * The web's ThinkingOrb on native: the same `thinking-orbs` geometry (one
+ * frame of dots and edges per instant) drawn with SVG. Pauses in the
+ * background and holds a still frame under Reduce Motion, as the web does.
+ */
+export declare function ThinkingOrb({ state, size, speed, displaySize, }: {
+    state?: OrbState;
+    size?: 64 | 20;
+    speed?: number;
+    /** Draw the tuned preset larger (for example a call screen) without losing sharpness. */
+    displaySize?: number;
+}): import("react").JSX.Element;

package/dist/timeline/turn.d.ts

@@ -0,0 +1,80 @@
+import type { ActivityItem, TurnOutcome } from "@opengeni/react/session";
+import { type TurnSummaryFacetConfiguration } from "@opengeni/react/timeline-model";
+import { type ReactNode } from "react";
+/** Native counterpart of the web `TurnSummaryStatus` with a renderable preview. */
+export type NativeTurnStatus = {
+    kind: "worked";
+    durationMs?: number | undefined;
+    label?: string | undefined;
+} | {
+    kind: "working" | "waiting";
+    since?: string | undefined;
+    label?: string | undefined;
+    preview?: ReactNode;
+};
+type FoldMemory = Map<string, "open" | "closed">;
+export declare const FoldMemoryProvider: import("react").Provider<FoldMemory | null>;
+/**
+ * An expanded outer turn header stays pinned to the top of the timeline while
+ * its section scrolls (web: sticky inside the section). Each open section
+ * reports its content-space frame and a renderer for the header row; the
+ * timeline draws the pinned copy over the scroll view.
+ */
+export type StickyWorkHeader = {
+    top: number;
+    height: number;
+    headerHeight: number;
+    render: () => ReactNode;
+};
+export type StickyWorkHeaderRegistry = {
+    register: (key: string, entry: StickyWorkHeader | null) => void;
+    /** Bring a section's top back into view (after collapsing from the pinned copy). */
+    reveal: (top: number) => void;
+};
+export declare const StickyWorkHeaderProvider: import("react").Provider<StickyWorkHeaderRegistry | null>;
+export declare function useLiveNow(active: boolean): number;
+export interface TurnSummaryProps {
+    items: ActivityItem[];
+    outcome?: TurnOutcome | undefined;
+    failureText?: string | undefined;
+    durationMs?: number | undefined;
+    defaultOpen?: boolean | undefined;
+    liveHeader?: ReactNode;
+    bare?: boolean | undefined;
+    facets?: TurnSummaryFacetConfiguration | undefined;
+    foldKey?: string | undefined;
+    contextCompactionCount?: number | undefined;
+    status?: NativeTurnStatus | undefined;
+    children: ReactNode;
+}
+export declare function TurnSummary({ items, outcome, failureText, durationMs, defaultOpen, liveHeader, bare, facets: facetConfiguration, foldKey, contextCompactionCount, status, children, }: TurnSummaryProps): import("react").JSX.Element;
+/** The stable left rule under a turn/activity body (web TurnRailFrame). */
+export declare function TurnRailFrame({ children, compact, }: {
+    children: ReactNode;
+    compact?: boolean;
+}): import("react").JSX.Element;
+/** The native ActivityRail (bare): tight same-family rows, breathing room between families. */
+export declare function ActivityRail({ items, startupActive, renderPreparing, }: {
+    items: ActivityItem[];
+    startupActive?: boolean | undefined;
+    renderPreparing?: ((props: PreparingProps) => ReactNode) | undefined;
+}): import("react").JSX.Element;
+export interface PreparingProps {
+    startedAt: string;
+    phase: "preparing" | "waiting";
+    phrase: string;
+    slow: boolean;
+}
+/** The web GenieLoading: a visual (orb by default; hosts supply a character) + rotating copy. */
+export declare function PreparingState({ startedAt, phase, render, }: {
+    startedAt: string;
+    phase: "preparing" | "waiting";
+    render?: ((props: PreparingProps) => ReactNode) | undefined;
+}): import("react").JSX.Element;
+/** One stable 24pt viewport; updates replace its content without moving the conversation. */
+export declare function RollingActivity({ items, previousItem, showCount, }: {
+    items: ActivityItem[];
+    previousItem?: ActivityItem | undefined;
+    showCount?: boolean;
+}): import("react").JSX.Element | null;
+export {};

package/dist/ui/attention.d.ts

@@ -0,0 +1,14 @@
+import type { PendingApproval, PendingHumanInputRequest } from "@opengeni/react/session";
+import type { HumanInputAnswer } from "@opengeni/sdk";
+import type { AgentTheme } from "./theme.js";
+/**
+ * Everything the agent is waiting on, docked directly above the composer. One item at a
+ * time with a counter; decisions never scroll away with the conversation.
+ */
+export declare function AgentAttentionTray(props: {
+    approvals: readonly PendingApproval[];
+    humanInput: readonly PendingHumanInputRequest[];
+    theme: AgentTheme;
+    onApproval(approvalId: string, decision: "approve" | "reject"): void;
+    onAnswer(requestId: string, answers: HumanInputAnswer[] | null): void;
+}): import("react").JSX.Element | null;

package/dist/ui/cards.d.ts

@@ -0,0 +1,21 @@
+import type { PendingApproval, PendingHumanInputRequest } from "@opengeni/react/session";
+import type { HumanInputAnswer } from "@opengeni/sdk";
+import type { AgentTheme } from "./theme.js";
+export declare function ActionButton(props: {
+    label: string;
+    onPress(): void;
+    theme: AgentTheme;
+    variant: "primary" | "secondary" | "danger";
+    disabled?: boolean;
+    flex?: boolean;
+}): import("react").JSX.Element;
+export declare function ApprovalCard(props: {
+    approval: PendingApproval;
+    theme: AgentTheme;
+    onDecision(decision: "approve" | "reject"): void;
+}): import("react").JSX.Element;
+export declare function QuestionCard(props: {
+    request: PendingHumanInputRequest;
+    theme: AgentTheme;
+    onAnswer(answers: HumanInputAnswer[] | null): void;
+}): import("react").JSX.Element | null;

package/dist/ui/composer.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from "react";
+import type { AgentTheme } from "./theme.js";
+export interface AgentComposerProps {
+    theme: AgentTheme;
+    value: string;
+    onChangeText(text: string): void;
+    onSend(): void;
+    onStop?: (() => void) | undefined;
+    onAttach?: (() => void) | undefined;
+    onVoice?: (() => void) | undefined;
+    running: boolean;
+    placeholder: string;
+    /** Chips shown in the bar composer (model, permissions…). */
+    accessories?: ReactNode | undefined;
+    bottomInset: number;
+}
+export declare function AgentComposer(props: AgentComposerProps): import("react").JSX.Element;
+export declare function ComposerChip({ theme, label }: {
+    theme: AgentTheme;
+    label: string;
+}): import("react").JSX.Element;

package/dist/ui/format.d.ts

@@ -0,0 +1,13 @@
+import type { ActivityItem, TimelineGroup, ToolCallItem } from "@opengeni/react/session";
+export declare function toolTitle(item: ToolCallItem): string;
+/** One-line human summary of a tool call's input. */
+export declare function toolDetail(item: ToolCallItem): string | null;
+/** Short preview of a settled tool output. */
+export declare function toolOutputPreview(item: ToolCallItem, lines?: number): string | null;
+export declare function formatDuration(ms: number): string;
+export declare function itemTime(item: {
+    occurredAt?: string;
+}): number;
+/** Flatten nested work details of a group into its activity items, in order. */
+export declare function activityItemsOf(group: TimelineGroup): ActivityItem[];
+export declare function toolCallsOf(items: readonly ActivityItem[]): ToolCallItem[];

package/dist/ui/icons.d.ts

@@ -0,0 +1,9 @@
+export type AgentIconName = "terminal" | "search" | "edit" | "globe" | "check" | "x" | "chevron-right" | "chevron-down" | "sparkle" | "mic" | "plus" | "arrow-up" | "stop" | "tool" | "send" | "alert" | "question" | "rocket";
+export declare function AgentIcon({ name, size, color, strokeWidth, }: {
+    name: AgentIconName;
+    size?: number;
+    color: string;
+    strokeWidth?: number;
+}): import("react").JSX.Element;
+/** Category icon for a tool name (best effort, purely presentational). */
+export declare function toolIconName(name: string): AgentIconName;

package/dist/ui/index.d.ts

@@ -0,0 +1,12 @@
+export { AgentStepList, AgentTimeline, UserMessage, WorkingLine } from "./timeline.js";
+export { AgentStepsSheet } from "./steps-sheet.js";
+export { AgentAttentionTray } from "./attention.js";
+export type { AgentTimelineProps, MarkdownRenderer } from "./timeline.js";
+export { AgentComposer, ComposerChip } from "./composer.js";
+export type { AgentComposerProps } from "./composer.js";
+export { ApprovalCard, QuestionCard, ActionButton } from "./cards.js";
+export { AgentIcon, toolIconName } from "./icons.js";
+export type { AgentIconName } from "./icons.js";
+export { agentDirections, agentTheme } from "./theme.js";
+export type { AgentDirection, AgentDirectionId, AgentTheme, ActivityStyle, ComposerStyle, } from "./theme.js";
+export { formatDuration, toolDetail, toolOutputPreview, toolTitle } from "./format.js";