@opengeni/react-native 1.4.5-canary.37615713321001

package/dist/presentation.d.ts

@@ -0,0 +1,262 @@
+export interface OpenGeniNativeTheme {
+    dark: boolean;
+    colors: {
+        background: string;
+        surface: string;
+        elevated: string;
+        border: string;
+        text: string;
+        secondaryText: string;
+        mutedText: string;
+        accent: string;
+        accentForeground: string;
+        userBubble: string;
+        userBubbleText: string;
+        danger: string;
+        dangerSurface: string;
+        warning: string;
+        warningSurface: string;
+        success: string;
+    };
+}
+export interface OpenGeniNativeLabels {
+    knowledgeOutcome?: Record<"published" | "pending" | "rejected" | "archived" | "failed", string>;
+    emptyTitle: string;
+    emptyDescription: string;
+    loadEarlier: string;
+    loadingEarlier: string;
+    reconnecting: string;
+    connecting: string;
+    offlinePaused: string;
+    error: string;
+    retry: string;
+    dismiss: string;
+    queueTitle: string;
+    queueEmpty: string;
+    edit: string;
+    runNext: string;
+    remove: string;
+    moveEarlier: string;
+    moveLater: string;
+    approvalsTitle: string;
+    approve: string;
+    deny: string;
+    questionsTitle: string;
+    humanInputAsked: string;
+    humanInputOutcome: {
+        answered: string;
+        skipped: string;
+        expired: string;
+        cancelled: string;
+    };
+    submitAnswers: string;
+    skip: string;
+    other: string;
+    required: string;
+    attachDocument: string;
+    attachImage: string;
+    preparingAttachment: string;
+    uploading: string;
+    uploadFailed: string;
+    attachmentError: string;
+    removeAttachment: string;
+    retryUpload: string;
+    restoredAttachment: string;
+    composerPlaceholder: string;
+    send: string;
+    steer: string;
+    pause: string;
+    resume: string;
+    savingDraft: string;
+    draftConflict: string;
+    keepMine: string;
+    useRemote: string;
+    thinking: string;
+    thought: string;
+    reasoning: string;
+    tool: string;
+    worker: string;
+    user: string;
+    assistant: string;
+    sandbox: string;
+    goal: string;
+    goalAction: {
+        set: string;
+        updated: string;
+        completed: string;
+        paused: string;
+        resumed: string;
+        cleared: string;
+        held: string;
+        continuation: string;
+    };
+    contextUpdated: string;
+    contextCompactionPhase: {
+        started: string;
+        compacted: string;
+        skipped: string;
+    };
+    machineUpdates: string;
+    connectionRequired: string;
+    memory: string;
+    memoryAction: {
+        saved: string;
+        corrected: string;
+        updated: string;
+        archived: string;
+    };
+    fleetDecision: string;
+    fleetOutcome: {
+        selected: string;
+        waiting: string;
+        none: string;
+    };
+    fleetReason: {
+        leaseReused: string;
+        pin: string;
+        rotation: string;
+        active: string;
+        allCapped: string;
+        none: string;
+    };
+    turn: string;
+    activity: string;
+    statusQueued: string;
+    statusRunning: string;
+    statusComplete: string;
+    statusRecovering: string;
+    statusWaitingCapacity: string;
+    statusIdle: string;
+    statusRequiresAction: string;
+    statusFailed: string;
+    statusCancelled: string;
+    relativeNow: string;
+    relativeSeconds: string;
+    relativeMinutes: string;
+    relativeHours: string;
+    relativeDays: string;
+}
+export declare const DEFAULT_OPENGENI_NATIVE_LABELS: {
+    knowledgeOutcome: {
+        published: string;
+        pending: string;
+        rejected: string;
+        archived: string;
+        failed: string;
+    };
+    emptyTitle: string;
+    emptyDescription: string;
+    loadEarlier: string;
+    loadingEarlier: string;
+    reconnecting: string;
+    connecting: string;
+    offlinePaused: string;
+    error: string;
+    retry: string;
+    dismiss: string;
+    queueTitle: string;
+    queueEmpty: string;
+    edit: string;
+    runNext: string;
+    remove: string;
+    moveEarlier: string;
+    moveLater: string;
+    approvalsTitle: string;
+    approve: string;
+    deny: string;
+    questionsTitle: string;
+    humanInputAsked: string;
+    humanInputOutcome: {
+        answered: string;
+        skipped: string;
+        expired: string;
+        cancelled: string;
+    };
+    submitAnswers: string;
+    skip: string;
+    other: string;
+    required: string;
+    attachDocument: string;
+    attachImage: string;
+    preparingAttachment: string;
+    uploading: string;
+    uploadFailed: string;
+    attachmentError: string;
+    removeAttachment: string;
+    retryUpload: string;
+    restoredAttachment: string;
+    composerPlaceholder: string;
+    send: string;
+    steer: string;
+    pause: string;
+    resume: string;
+    savingDraft: string;
+    draftConflict: string;
+    keepMine: string;
+    useRemote: string;
+    thinking: string;
+    thought: string;
+    reasoning: string;
+    tool: string;
+    worker: string;
+    user: string;
+    assistant: string;
+    sandbox: string;
+    goal: string;
+    goalAction: {
+        set: string;
+        updated: string;
+        completed: string;
+        paused: string;
+        resumed: string;
+        cleared: string;
+        held: string;
+        continuation: string;
+    };
+    contextUpdated: string;
+    contextCompactionPhase: {
+        started: string;
+        compacted: string;
+        skipped: string;
+    };
+    machineUpdates: string;
+    connectionRequired: string;
+    memory: string;
+    memoryAction: {
+        saved: string;
+        corrected: string;
+        updated: string;
+        archived: string;
+    };
+    fleetDecision: string;
+    fleetOutcome: {
+        selected: string;
+        waiting: string;
+        none: string;
+    };
+    fleetReason: {
+        leaseReused: string;
+        pin: string;
+        rotation: string;
+        active: string;
+        allCapped: string;
+        none: string;
+    };
+    turn: string;
+    activity: string;
+    statusQueued: string;
+    statusRunning: string;
+    statusComplete: string;
+    statusRecovering: string;
+    statusWaitingCapacity: string;
+    statusIdle: string;
+    statusRequiresAction: string;
+    statusFailed: string;
+    statusCancelled: string;
+    relativeNow: string;
+    relativeSeconds: string;
+    relativeMinutes: string;
+    relativeHours: string;
+    relativeDays: string;
+};
+export declare const DEFAULT_OPENGENI_NATIVE_THEME: OpenGeniNativeTheme;

package/dist/read-acknowledgement.d.ts

@@ -0,0 +1,39 @@
+import type { SessionEvent } from "@opengeni/sdk";
+/** The optional attention mutation a host client may expose (the SDK client does). */
+export type SessionAttentionClientLike = {
+    updateSessionAttention?(workspaceId: string, sessionId: string, body: {
+        unread?: boolean;
+        acknowledgedThroughSequence?: number;
+    }): Promise<unknown>;
+};
+/**
+ * Where an open conversation should be acknowledged through, and whether it
+ * needs it: the server says unread, or newer attention events have arrived
+ * since the session row was read.
+ */
+export declare function readAcknowledgementFrontier(session: {
+    unread?: boolean;
+    lastSequence?: number;
+} | null, attentionThrough: number): {
+    readThrough: number;
+    unread: boolean;
+};
+/**
+ * Mark the open conversation read, as the web session page does: while it is on
+ * screen and the app is in the foreground, acknowledge through the latest
+ * delivered attention boundary (completed reply, question, failure), never per
+ * streaming flush. Reading a session does not acknowledge it on the server;
+ * without this, every reply stays unread and attention notifications (pushes,
+ * webhooks a host turns into alerts) fire even while the person watches it.
+ */
+export declare function useNativeReadAcknowledgement(input: {
+    client: SessionAttentionClientLike;
+    workspaceId: string;
+    sessionId: string;
+    session: {
+        unread?: boolean;
+        lastSequence?: number;
+    } | null;
+    events: readonly SessionEvent[];
+    active: boolean;
+}): void;

package/dist/realtime/call-events.d.ts

@@ -0,0 +1,11 @@
+import type { NativeCallEvent } from "./native-call.js";
+/** A call event as the native module sends it. */
+export type RawNativeCallEvent = {
+    type: string;
+    callId?: string;
+    muted?: boolean;
+    route?: string;
+    target?: string | null;
+};
+/** Map a raw native event onto the typed call event, dropping anything unknown. */
+export declare function parseNativeCallEvent(raw: RawNativeCallEvent): NativeCallEvent | null;

package/dist/realtime/call-view.d.ts

@@ -0,0 +1,26 @@
+import type { NativeRealtimeCall } from "./native-call.js";
+export type OpenGeniNativeCallLabels = {
+    connecting: string;
+    live: string;
+    reconnecting: string;
+    ending: string;
+    muted: string;
+    mute: string;
+    unmute: string;
+    speaker: string;
+    end: string;
+    minimize: string;
+};
+export declare const DEFAULT_OPENGENI_NATIVE_CALL_LABELS: OpenGeniNativeCallLabels;
+/**
+ * The full-screen call with an agent: the web's thinking orb, the call state,
+ * and mute, speaker and end controls. The host owns navigation (`onMinimize`
+ * returns to the conversation while the call continues) and safe areas.
+ */
+export declare function OpenGeniNativeCallView({ call, title, subtitle, onMinimize, labels: labelOverrides, }: {
+    call: NativeRealtimeCall;
+    title: string;
+    subtitle?: string | null | undefined;
+    onMinimize?: (() => void) | undefined;
+    labels?: Partial<OpenGeniNativeCallLabels> | undefined;
+}): import("react").JSX.Element;

package/dist/realtime/expo-call.d.ts

@@ -0,0 +1,11 @@
+import { parseNativeCallEvent } from "./call-events.js";
+import type { NativeCallAdapter } from "./native-call.js";
+export { parseNativeCallEvent };
+/**
+ * CallKit for Expo hosts, from the native module this package ships (linked by
+ * Expo autolinking). Returns null where it is unavailable (Android, web, or a
+ * build without the module), so voice still works without a system call.
+ */
+export declare function createExpoCallAdapter(options?: {
+    includeInRecents?: boolean;
+}): NativeCallAdapter | null;

package/dist/realtime/native-call.d.ts

@@ -0,0 +1,104 @@
+import type { SessionRealtimeControllerSnapshot } from "@opengeni/sdk/realtime";
+import type { SessionRealtimeModel } from "@opengeni/sdk";
+/** System events from the platform call service (CallKit on iOS). */
+export type NativeCallEvent = 
+/** The person ended the call from the system UI, lock screen or headset. */
+{
+    type: "ended";
+    callId: string;
+}
+/** The person muted or unmuted from the system UI. */
+ | {
+    type: "muteChanged";
+    callId: string;
+    muted: boolean;
+}
+/** The audio route changed (speaker, receiver, AirPods, CarPlay). */
+ | {
+    type: "routeChanged";
+    route: NativeCallAudioRoute;
+}
+/** The system activated or released the call audio session (forwarded to WebRTC). */
+ | {
+    type: "audioSessionActivated";
+} | {
+    type: "audioSessionDeactivated";
+}
+/**
+ * The system asked the app to start a call from outside it (Siri, the Phone
+ * app's recents, an App Intent or a shortcut). `target` is the host's own
+ * call target, for example a session id, or absent for the default.
+ */
+ | {
+    type: "startRequested";
+    target: string | null;
+};
+export type NativeCallAudioRoute = "receiver" | "speaker" | "bluetooth" | "headphones" | "other";
+/**
+ * The platform call service seam. The OpenGeni Expo module implements it with
+ * CallKit; hosts on other platforms can implement it or omit it, in which case
+ * the realtime session runs without a system call.
+ */
+export interface NativeCallAdapter {
+    /** Report an outgoing call to the system and activate the call audio session. */
+    startCall(call: {
+        callId: string;
+        title: string;
+        target: string | null;
+    }): Promise<void>;
+    /** The voice connection is live: the system call shows as connected. */
+    reportConnected(callId: string): void;
+    /** End the system call. `failed` reports a failure rather than a normal hang-up. */
+    endCall(callId: string, reason?: "ended" | "failed"): Promise<void>;
+    setMuted(callId: string, muted: boolean): Promise<void>;
+    /** Route call audio to the loudspeaker, or back to the default route. */
+    setSpeaker(on: boolean): Promise<void>;
+    subscribe(listener: (event: NativeCallEvent) => void): () => void;
+    /** A start request that launched the app before JavaScript subscribed. */
+    takePendingStartRequest(): Promise<{
+        target: string | null;
+    } | null>;
+}
+/** Native hosts can stream voice over WebRTC; WebSocket audio transports need a browser. */
+export declare function nativeRealtimeModelSupported(model: SessionRealtimeModel): boolean;
+/** The slice of `useSessionRealtime` a call drives. */
+export type NativeCallRealtime = {
+    snapshot: SessionRealtimeControllerSnapshot;
+    canStart: boolean;
+    admissionBlocker: string | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    setInputMuted(muted: boolean): void;
+};
+export type NativeCallPhase = "idle" | "connecting" | "active" | "reconnecting" | "ending";
+export type NativeRealtimeCall = {
+    phase: NativeCallPhase;
+    muted: boolean;
+    speaker: boolean;
+    route: NativeCallAudioRoute | null;
+    error: string | null;
+    /**
+     * Whether the system shows this call (CallKit). False when the platform has
+     * no call service or refused the call; voice then runs as an in-app call.
+     */
+    systemCall: boolean;
+    canStart: boolean;
+    start(): Promise<void>;
+    end(): Promise<void>;
+    setMuted(muted: boolean): void;
+    setSpeaker(on: boolean): void;
+};
+/**
+ * Keep one system call and one shared realtime session in lockstep: starting
+ * reports an outgoing call and starts voice; the call shows connected once
+ * voice is live; hanging up anywhere (app, lock screen, headset) stops voice,
+ * and voice ending or failing ends the call. Mute is mirrored both ways.
+ * If the system refuses the call (no call service, a region without CallKit,
+ * the simulator), voice still starts as an in-app call.
+ */
+export declare function useNativeRealtimeCall(options: {
+    realtime: NativeCallRealtime;
+    call?: NativeCallAdapter | null | undefined;
+    title: string;
+    target?: string | null | undefined;
+}): NativeRealtimeCall;

package/dist/realtime/native-realtime.d.ts

@@ -0,0 +1,35 @@
+import { type SessionRealtimeOwnerStorage } from "@opengeni/sdk/realtime";
+import type { SessionRealtimeControllerFactory } from "@opengeni/react/session-realtime";
+/**
+ * The WebRTC entry points a native host supplies, in the shape of
+ * `react-native-webrtc`. Everything else (negotiation, the realtime ledger,
+ * delegation, recovery and lifecycle) stays in the shared SDK controller that
+ * the web uses.
+ */
+export interface NativeWebRtcAdapter {
+    createPeerConnection(): RTCPeerConnection;
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
+}
+export type NativeRealtimeControllerFactoryOptions = {
+    /**
+     * Owner-proof storage. Defaults to process memory, which matches the web's
+     * tab-scoped session storage: a relaunched app recovers through the server
+     * lifecycle rather than a stale local proof.
+     */
+    storage?: SessionRealtimeOwnerStorage | undefined;
+};
+/** Process-lifetime owner storage, the native counterpart of `sessionStorage`. */
+export declare function createMemoryRealtimeOwnerStorage(): SessionRealtimeOwnerStorage;
+/**
+ * Native WebRTC plays remote audio itself, through the call audio session. The
+ * SDK still drives an audio element (attach, mute, play, detach), so this
+ * stand-in maps those calls onto the remote audio tracks: muting disables the
+ * tracks, and play resolves because playback is already live.
+ */
+export declare function createNativeRemoteAudio(): HTMLAudioElement;
+/**
+ * Controller factory for `useSessionRealtime({ controllerFactory })`: the
+ * shared SDK controller with native WebRTC, a native remote-audio stand-in and
+ * owner storage injected. No realtime logic is forked.
+ */
+export declare function createNativeRealtimeControllerFactory(webrtc: NativeWebRtcAdapter, options?: NativeRealtimeControllerFactoryOptions): SessionRealtimeControllerFactory;

package/dist/realtime/use-native-session-realtime.d.ts

@@ -0,0 +1,25 @@
+import { useSessionRealtime } from "@opengeni/react/session-realtime";
+import { type NativeRealtimeControllerFactoryOptions, type NativeWebRtcAdapter } from "./native-realtime.js";
+export type UseNativeSessionRealtimeOptions = Omit<Parameters<typeof useSessionRealtime>[0], "controllerFactory"> & {
+    /** Native WebRTC, for example `createReactNativeWebRtcAdapter()` from `./webrtc`. */
+    webrtc: NativeWebRtcAdapter;
+    storage?: NativeRealtimeControllerFactoryOptions["storage"];
+};
+/**
+ * The web's `useSessionRealtime`, driven by native WebRTC. Same controller,
+ * same admission rules, same lifecycle recovery; only media is injected.
+ */
+export declare function useNativeSessionRealtime(options: UseNativeSessionRealtimeOptions): {
+    snapshot: import("@opengeni/sdk").CodexRealtimeControllerSnapshot;
+    lifecycleActive: boolean;
+    canStart: boolean;
+    admissionBlocker: string | null;
+    codexConnected: boolean;
+    audioRef: import("react").RefObject<HTMLAudioElement | null>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    retry: () => Promise<void>;
+    retryAudibleOutput: () => Promise<void>;
+    setInputMuted: (muted: boolean) => void;
+    setOutputMuted: (muted: boolean) => void;
+};

package/dist/session-view.d.ts

@@ -0,0 +1,87 @@
+import { type ReactNode } from "react";
+import { type StyleProp, type ViewStyle } from "react-native";
+import type { ActivityItem, TimelineGroup, ToolCallItem } from "@opengeni/react/session";
+import type { OpenGeniNativeSessionController } from "./use-native-session.js";
+import type { NativeFileAttachmentsResult } from "./attachments.js";
+import { type OpenGeniNativeLabels, type OpenGeniNativeTheme } from "./presentation.js";
+export type NativeToolRenderer = (item: ToolCallItem, context: {
+    theme: OpenGeniNativeTheme;
+    labels: OpenGeniNativeLabels;
+    compact: boolean;
+}) => ReactNode;
+export type NativeMessageRenderer = (text: string, role: "user" | "assistant" | "reasoning", context: {
+    theme: OpenGeniNativeTheme;
+}) => ReactNode;
+export interface NativeTurnSummaryContext {
+    items: readonly ActivityItem[];
+    toolCalls: readonly ToolCallItem[];
+    outcome: Extract<TimelineGroup, {
+        kind: "turn";
+    }>["outcome"];
+    failureText: string | undefined;
+    durationMs: number | undefined;
+    settled: boolean;
+    contextCompactionCount: number;
+}
+export interface NativeTurnSummaryResult {
+    content: string;
+    accessibilityLabel?: string | undefined;
+    duration?: string | null;
+}
+export type NativeTurnSummaryRenderer = (context: NativeTurnSummaryContext) => NativeTurnSummaryResult | null;
+export interface NativeComposerActionContext {
+    accessory?: ReactNode | undefined;
+    labels: OpenGeniNativeLabels;
+    theme: OpenGeniNativeTheme;
+    busy: boolean;
+    paused: boolean;
+    runActive: boolean;
+    canSubmit: boolean;
+    draftSaving: boolean;
+    submitLabel: string;
+    onAttachDocument(): void;
+    onAttachImage(): void;
+    onTogglePause(): void;
+    onSubmit(): void;
+}
+export type NativeComposerActionRenderer = (context: NativeComposerActionContext) => ReactNode;
+export interface NativeComposerRenderContext extends NativeComposerActionContext {
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder: string;
+}
+export type NativeComposerRenderer = (context: NativeComposerRenderContext) => ReactNode;
+export interface NativeComposerSurfaceContext {
+    children: ReactNode;
+    style: StyleProp<ViewStyle>;
+}
+export type NativeComposerSurfaceRenderer = (context: NativeComposerSurfaceContext) => ReactNode;
+export interface OpenGeniNativeSessionViewProps {
+    controller: OpenGeniNativeSessionController;
+    theme?: OpenGeniNativeTheme | undefined;
+    labels?: Partial<OpenGeniNativeLabels> | undefined;
+    header?: ReactNode | undefined;
+    composerAccessory?: ReactNode | undefined;
+    composerSafeAreaInsets?: {
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    renderComposer?: NativeComposerRenderer | undefined;
+    renderComposerActions?: NativeComposerActionRenderer | undefined;
+    renderComposerSurface?: NativeComposerSurfaceRenderer | undefined;
+    renderTool?: NativeToolRenderer | undefined;
+    renderMessage?: NativeMessageRenderer | undefined;
+    summarizeTurn?: NativeTurnSummaryRenderer | undefined;
+    formatError?: ((error: Error) => string) | undefined;
+    keyboardVerticalOffset?: number | undefined;
+    testID?: string | undefined;
+}
+export declare function OpenGeniNativeSessionView({ controller, theme, labels: labelOverrides, header, composerAccessory, composerSafeAreaInsets, renderComposer, renderComposerActions, renderComposerSurface, renderTool, renderMessage, summarizeTurn, formatError, keyboardVerticalOffset, testID, }: OpenGeniNativeSessionViewProps): import("react").JSX.Element;
+export declare function OpenGeniNativeAttachmentStrip({ attachments, labels, onRemoveRestoredResource, restoredResources, theme, }: {
+    attachments: NativeFileAttachmentsResult;
+    labels: OpenGeniNativeLabels;
+    onRemoveRestoredResource?: ((index: number) => void) | undefined;
+    restoredResources?: readonly unknown[] | undefined;
+    theme: OpenGeniNativeTheme;
+}): import("react").JSX.Element | null;

package/dist/timeline/activity.d.ts

@@ -0,0 +1,34 @@
+import type { ActivityItem, ToolCallItem } from "@opengeni/react/session";
+import { type ToolRowPresentation } from "@opengeni/react/timeline-model";
+import { type ReactNode } from "react";
+export type NativeToolRendererProps = {
+    item: ToolCallItem;
+    presentation: ToolRowPresentation;
+    compact: boolean;
+};
+/** Return null to fall back to the shared row. */
+export type NativeToolRenderer = (props: NativeToolRendererProps) => ReactNode | null;
+export interface NativeActivityOptions {
+    /** Per-tool overrides keyed by exact tool name or MCP leaf. */
+    toolRenderers?: Record<string, NativeToolRenderer> | undefined;
+    /** Host renderer consulted for every tool call (return null for the shared row). */
+    renderTool?: NativeToolRenderer | undefined;
+    /** Active compute label for exec previews ("on <label> · …"). */
+    computeLabel?: string | null | undefined;
+    renderMarkdown?: ((text: string, options: {
+        tone: "body" | "muted";
+        streaming?: boolean;
+    }) => ReactNode) | undefined;
+    onOpenSession?: ((sessionId: string) => void) | undefined;
+}
+export declare const NativeActivityOptionsProvider: import("react").Provider<NativeActivityOptions>;
+export declare function useNativeActivityOptions(): NativeActivityOptions;
+export declare function PresentedToolRow({ presentation: p, compact, }: {
+    presentation: ToolRowPresentation;
+    compact?: boolean;
+}): import("react").JSX.Element;
+/** Renders one activity item — the native `renderActivity`. */
+export declare function ActivityRow({ item, compact }: {
+    item: ActivityItem;
+    compact?: boolean;
+}): import("react").JSX.Element | null;