@opengeni/react-native 1.4.5-canary.37615713321001

package/src/presentation.ts

@@ -0,0 +1,285 @@
+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 const DEFAULT_OPENGENI_NATIVE_LABELS = {
+  knowledgeOutcome: {
+    published: "Knowledge published",
+    pending: "Knowledge awaiting review",
+    rejected: "Knowledge rejected",
+    archived: "Knowledge archived",
+    failed: "Knowledge could not be saved",
+  },
+  emptyTitle: "Start a conversation",
+  emptyDescription: "Ask the agent to help with work in this session.",
+  loadEarlier: "Load earlier activity",
+  loadingEarlier: "Loading earlier activity…",
+  reconnecting: "Reconnecting…",
+  connecting: "Connecting…",
+  offlinePaused: "Live updates pause while the app is in the background.",
+  error: "Something went wrong. Try again.",
+  retry: "Retry",
+  dismiss: "Dismiss",
+  queueTitle: "Queued prompts",
+  queueEmpty: "No queued prompts",
+  edit: "Edit",
+  runNext: "Run next",
+  remove: "Remove",
+  moveEarlier: "Move earlier",
+  moveLater: "Move later",
+  approvalsTitle: "Approval required",
+  approve: "Approve",
+  deny: "Deny",
+  questionsTitle: "Your input is needed",
+  humanInputAsked: "Agent asked",
+  humanInputOutcome: {
+    answered: "You answered",
+    skipped: "Skipped",
+    expired: "Expired",
+    cancelled: "Cancelled",
+  },
+  submitAnswers: "Submit answers",
+  skip: "Skip",
+  other: "Other",
+  required: "Required",
+  attachDocument: "Attach document",
+  attachImage: "Attach image",
+  preparingAttachment: "Preparing…",
+  uploading: "Uploading…",
+  uploadFailed: "Upload failed",
+  attachmentError: "Could not open the file picker.",
+  removeAttachment: "Remove attachment",
+  retryUpload: "Retry upload",
+  restoredAttachment: "Attached file",
+  composerPlaceholder: "Message the agent…",
+  send: "Send",
+  steer: "Steer",
+  pause: "Pause",
+  resume: "Resume",
+  savingDraft: "Saving draft…",
+  draftConflict: "This draft changed elsewhere.",
+  keepMine: "Keep mine",
+  useRemote: "Use saved draft",
+  thinking: "Thinking",
+  thought: "Thought",
+  reasoning: "Reasoning",
+  tool: "Tool",
+  worker: "Worker",
+  user: "You",
+  assistant: "Assistant",
+  sandbox: "Sandbox",
+  goal: "Goal",
+  goalAction: {
+    set: "Goal set",
+    updated: "Goal updated",
+    completed: "Goal completed",
+    paused: "Goal paused",
+    resumed: "Goal resumed",
+    cleared: "Goal cleared",
+    held: "Goal held",
+    continuation: "Continuing toward the goal",
+  },
+  contextUpdated: "Context updated",
+  contextCompactionPhase: {
+    started: "Compacting conversation history",
+    compacted: "Conversation history compacted",
+    skipped: "Conversation history compaction skipped",
+  },
+  machineUpdates: "Machine updates: {value}",
+  connectionRequired: "Connection required for {provider}",
+  memory: "Memory",
+  memoryAction: {
+    saved: "Saved to memory",
+    corrected: "Updated memory",
+    updated: "Updated memory in place",
+    archived: "Archived memory",
+  },
+  fleetDecision: "Fleet decision",
+  fleetOutcome: {
+    selected: "Selected {candidate}",
+    waiting: "Waiting for capacity",
+    none: "No candidate selected",
+  },
+  fleetReason: {
+    leaseReused: "Reused the fenced lease",
+    pin: "Kept the session pin",
+    rotation: "Rotated for capacity",
+    active: "Used the active subscription",
+    allCapped: "All observed subscriptions were capped",
+    none: "No production candidate was selected",
+  },
+  turn: "Turn",
+  activity: "Activity",
+  statusQueued: "Queued",
+  statusRunning: "Running",
+  statusComplete: "Complete",
+  statusRecovering: "Recovering",
+  statusWaitingCapacity: "Waiting for capacity",
+  statusIdle: "Idle",
+  statusRequiresAction: "Waiting on you",
+  statusFailed: "Failed",
+  statusCancelled: "Cancelled",
+  relativeNow: "now",
+  relativeSeconds: "{value}s",
+  relativeMinutes: "{value}m",
+  relativeHours: "{value}h",
+  relativeDays: "{value}d",
+} satisfies OpenGeniNativeLabels;
+
+export const DEFAULT_OPENGENI_NATIVE_THEME: OpenGeniNativeTheme = {
+  dark: false,
+  colors: {
+    background: "#f7f7f5",
+    surface: "#ffffff",
+    elevated: "#f0f0ed",
+    border: "#dfdfda",
+    text: "#1b1b19",
+    secondaryText: "#5c5c57",
+    mutedText: "#83837b",
+    accent: "#2563eb",
+    accentForeground: "#ffffff",
+    userBubble: "#1f2937",
+    userBubbleText: "#ffffff",
+    danger: "#b42318",
+    dangerSurface: "#fef3f2",
+    warning: "#b54708",
+    warningSurface: "#fffaeb",
+    success: "#067647",
+  },
+};

package/src/read-acknowledgement.ts

@@ -0,0 +1,72 @@
+import { useEffect, useMemo, useRef } from "react";
+import type { SessionEvent } from "@opengeni/sdk";
+import { sessionAttentionReadThroughSequence } from "@opengeni/react/session-attention-model";
+
+/** 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 function readAcknowledgementFrontier(
+  session: { unread?: boolean; lastSequence?: number } | null,
+  attentionThrough: number,
+): { readThrough: number; unread: boolean } {
+  const lastSequence = session?.lastSequence ?? 0;
+  return {
+    readThrough: Math.max(lastSequence, attentionThrough),
+    unread: Boolean(session?.unread) || attentionThrough > lastSequence,
+  };
+}
+
+/**
+ * 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 function useNativeReadAcknowledgement(input: {
+  client: SessionAttentionClientLike;
+  workspaceId: string;
+  sessionId: string;
+  session: { unread?: boolean; lastSequence?: number } | null;
+  events: readonly SessionEvent[];
+  active: boolean;
+}) {
+  const { client, workspaceId, sessionId, session, events, active } = input;
+  const attentionThrough = useMemo(() => sessionAttentionReadThroughSequence(events), [events]);
+  const { readThrough, unread } = readAcknowledgementFrontier(session, attentionThrough);
+  const acknowledged = useRef<{ key: string; retried: boolean } | null>(null);
+
+  useEffect(() => {
+    if (!active || !session || !unread || readThrough <= 0) return;
+    if (!client.updateSessionAttention) return;
+    const key = `${workspaceId}:${sessionId}:${readThrough}`;
+    const previous = acknowledged.current;
+    if (previous?.key === key) return;
+    acknowledged.current = { key, retried: false };
+    const send = (): Promise<unknown> =>
+      client.updateSessionAttention!(workspaceId, sessionId, {
+        unread: false,
+        acknowledgedThroughSequence: readThrough,
+      });
+    send().catch(() => {
+      // Retry one transient failure for this exact frontier, then stop: a
+      // permanent rejection must not become a request loop.
+      const current = acknowledged.current;
+      if (current?.key !== key || current.retried) return;
+      current.retried = true;
+      void send().catch(() => undefined);
+    });
+  }, [active, client, readThrough, session, sessionId, unread, workspaceId]);
+}

package/src/realtime/call-events.ts

@@ -0,0 +1,41 @@
+import type { NativeCallAudioRoute, NativeCallEvent } from "./native-call";
+
+/** A call event as the native module sends it. */
+export type RawNativeCallEvent = {
+  type: string;
+  callId?: string;
+  muted?: boolean;
+  route?: string;
+  target?: string | null;
+};
+
+const ROUTES = new Set<NativeCallAudioRoute>([
+  "receiver",
+  "speaker",
+  "bluetooth",
+  "headphones",
+  "other",
+]);
+
+/** Map a raw native event onto the typed call event, dropping anything unknown. */
+export function parseNativeCallEvent(raw: RawNativeCallEvent): NativeCallEvent | null {
+  switch (raw.type) {
+    case "ended":
+      return raw.callId ? { type: "ended", callId: raw.callId } : null;
+    case "muteChanged":
+      return raw.callId
+        ? { type: "muteChanged", callId: raw.callId, muted: Boolean(raw.muted) }
+        : null;
+    case "routeChanged": {
+      const route = raw.route as NativeCallAudioRoute;
+      return { type: "routeChanged", route: ROUTES.has(route) ? route : "other" };
+    }
+    case "audioSessionActivated":
+    case "audioSessionDeactivated":
+      return { type: raw.type };
+    case "startRequested":
+      return { type: "startRequested", target: raw.target ?? null };
+    default:
+      return null;
+  }
+}

package/src/realtime/call-view.tsx

@@ -0,0 +1,220 @@
+import { useEffect, useState } from "react";
+import { Pressable, StyleSheet, Text, View } from "react-native";
+import { Icon, type NativeIconName } from "../timeline/icon";
+import { ThinkingOrb } from "../timeline/thinking-orb";
+import { fontStyle, useNativeTimelineTheme } from "../timeline/theme";
+import type { NativeRealtimeCall } from "./native-call";
+
+export type OpenGeniNativeCallLabels = {
+  connecting: string;
+  live: string;
+  reconnecting: string;
+  ending: string;
+  muted: string;
+  mute: string;
+  unmute: string;
+  speaker: string;
+  end: string;
+  minimize: string;
+};
+
+export const DEFAULT_OPENGENI_NATIVE_CALL_LABELS: OpenGeniNativeCallLabels = {
+  connecting: "Connecting…",
+  live: "Listening",
+  reconnecting: "Reconnecting…",
+  ending: "Ending…",
+  muted: "Muted",
+  mute: "Mute",
+  unmute: "Unmute",
+  speaker: "Speaker",
+  end: "End",
+  minimize: "Back to chat",
+};
+
+function formatDuration(seconds: number): string {
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return `${minutes}:${String(rest).padStart(2, "0")}`;
+}
+
+function useCallDuration(active: boolean): number | null {
+  const [since, setSince] = useState<number | null>(null);
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) return setSince(null);
+    setSince((current) => current ?? Date.now());
+    const timer = setInterval(() => setNow(Date.now()), 1000);
+    return () => clearInterval(timer);
+  }, [active]);
+  return since === null ? null : Math.max(0, Math.floor((now - since) / 1000));
+}
+
+function CallButton({
+  icon,
+  label,
+  onPress,
+  selected = false,
+  destructive = false,
+  disabled = false,
+}: {
+  icon: NativeIconName;
+  label: string;
+  onPress: () => void;
+  selected?: boolean;
+  destructive?: boolean;
+  disabled?: boolean;
+}) {
+  const theme = useNativeTimelineTheme();
+  const { colors } = theme;
+  // Hanging up is the system's solid red in either appearance, like the Phone app.
+  const hangUp = theme.scheme === "dark" ? "#FF453A" : "#FF3B30";
+  const background = destructive ? hangUp : selected ? colors.fg : colors["surface-2"];
+  const foreground = destructive ? "#FFFFFF" : selected ? colors.bg : colors.fg;
+  return (
+    <View style={styles.buttonColumn}>
+      <Pressable
+        accessibilityRole="button"
+        accessibilityLabel={label}
+        accessibilityState={{ selected, disabled }}
+        disabled={disabled}
+        onPress={onPress}
+        style={({ pressed }) => [
+          styles.button,
+          { backgroundColor: background, opacity: disabled ? 0.4 : pressed ? 0.75 : 1 },
+        ]}
+      >
+        <Icon name={icon} size={26} color={foreground} />
+      </Pressable>
+      <Text style={[styles.buttonLabel, fontStyle(theme, 500), { color: colors["fg-muted"] }]}>
+        {label}
+      </Text>
+    </View>
+  );
+}
+
+/**
+ * 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 function OpenGeniNativeCallView({
+  call,
+  title,
+  subtitle,
+  onMinimize,
+  labels: labelOverrides,
+}: {
+  call: NativeRealtimeCall;
+  title: string;
+  subtitle?: string | null | undefined;
+  onMinimize?: (() => void) | undefined;
+  labels?: Partial<OpenGeniNativeCallLabels> | undefined;
+}) {
+  const theme = useNativeTimelineTheme();
+  const { colors } = theme;
+  const labels = { ...DEFAULT_OPENGENI_NATIVE_CALL_LABELS, ...labelOverrides };
+  const duration = useCallDuration(call.phase === "active");
+  const status =
+    call.phase === "connecting" || call.phase === "idle"
+      ? labels.connecting
+      : call.phase === "reconnecting"
+        ? labels.reconnecting
+        : call.phase === "ending"
+          ? labels.ending
+          : call.muted
+            ? labels.muted
+            : labels.live;
+  const orbState =
+    call.phase === "active" ? (call.muted ? "breathing" : "listening") : "connecting";
+  const live = call.phase !== "idle" && call.phase !== "ending";
+  return (
+    <View style={[styles.screen, { backgroundColor: colors.canvas }]} testID="opengeni-call">
+      <View style={styles.header}>
+        {onMinimize ? (
+          <Pressable
+            accessibilityRole="button"
+            accessibilityLabel={labels.minimize}
+            hitSlop={12}
+            onPress={onMinimize}
+            style={({ pressed }) => [styles.minimize, { opacity: pressed ? 0.6 : 1 }]}
+          >
+            <Icon name="chevron-down" size={24} color={colors["fg-muted"]} />
+          </Pressable>
+        ) : null}
+      </View>
+      <View style={styles.center}>
+        <ThinkingOrb state={orbState} size={64} displaySize={176} speed={0.7} />
+        <Text
+          style={[styles.title, fontStyle(theme, 600), { color: colors.fg }]}
+          numberOfLines={2}
+          accessibilityRole="header"
+        >
+          {title}
+        </Text>
+        {subtitle ? (
+          <Text
+            style={[styles.subtitle, fontStyle(theme, 400), { color: colors["fg-muted"] }]}
+            numberOfLines={1}
+          >
+            {subtitle}
+          </Text>
+        ) : null}
+        <Text
+          style={[styles.status, fontStyle(theme, 500), { color: colors["fg-muted"] }]}
+          accessibilityLiveRegion="polite"
+        >
+          {duration !== null && !call.muted ? `${status} · ${formatDuration(duration)}` : status}
+        </Text>
+        {call.error ? (
+          <Text style={[styles.error, fontStyle(theme, 400), { color: colors.danger }]}>
+            {call.error}
+          </Text>
+        ) : null}
+      </View>
+      <View style={styles.controls}>
+        <CallButton
+          icon={call.muted ? "mic-off" : "mic"}
+          label={call.muted ? labels.unmute : labels.mute}
+          selected={call.muted}
+          disabled={!live}
+          onPress={() => call.setMuted(!call.muted)}
+        />
+        <CallButton
+          icon="volume-2"
+          label={labels.speaker}
+          selected={call.speaker}
+          disabled={!live}
+          onPress={() => call.setSpeaker(!call.speaker)}
+        />
+        <CallButton
+          icon="phone-off"
+          label={labels.end}
+          destructive
+          disabled={call.phase === "idle" || call.phase === "ending"}
+          onPress={() => void call.end()}
+        />
+      </View>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  screen: { flex: 1, paddingHorizontal: 24, paddingBottom: 32 },
+  header: { height: 52, flexDirection: "row", alignItems: "center" },
+  minimize: { width: 44, height: 44, alignItems: "center", justifyContent: "center" },
+  center: { flex: 1, alignItems: "center", justifyContent: "center", gap: 10 },
+  title: { fontSize: 26, lineHeight: 32, textAlign: "center", marginTop: 28 },
+  subtitle: { fontSize: 15, lineHeight: 20, textAlign: "center" },
+  status: { fontSize: 17, lineHeight: 22, marginTop: 4, fontVariant: ["tabular-nums"] },
+  error: { fontSize: 15, lineHeight: 20, textAlign: "center", marginTop: 8 },
+  controls: { flexDirection: "row", justifyContent: "space-evenly", alignItems: "flex-start" },
+  buttonColumn: { alignItems: "center", gap: 8, width: 88 },
+  button: {
+    width: 72,
+    height: 72,
+    borderRadius: 36,
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  buttonLabel: { fontSize: 13, lineHeight: 16 },
+});

package/src/realtime/expo-call.ts

@@ -0,0 +1,49 @@
+import { requireOptionalNativeModule } from "expo-modules-core";
+import { parseNativeCallEvent, type RawNativeCallEvent } from "./call-events";
+import type { NativeCallAdapter } from "./native-call";
+
+type OpenGeniCallNativeModule = {
+  configure(includeInRecents: boolean): void;
+  startCall(callId: string, title: string, target: string | null): Promise<void>;
+  reportConnected(callId: string): void;
+  endCall(callId: string, failed: boolean): Promise<void>;
+  setMuted(callId: string, muted: boolean): Promise<void>;
+  setSpeaker(on: boolean): Promise<void>;
+  takePendingStartRequest(): Promise<{ target: string | null } | null>;
+  addListener(
+    eventName: "onCallEvent",
+    listener: (event: RawNativeCallEvent) => void,
+  ): { remove(): void };
+};
+
+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 function createExpoCallAdapter(
+  options: { includeInRecents?: boolean } = {},
+): NativeCallAdapter | null {
+  const native = requireOptionalNativeModule<OpenGeniCallNativeModule>("OpenGeniCall");
+  if (!native) return null;
+  native.configure(options.includeInRecents ?? true);
+  // Call ids are UUIDs; CallKit reports them upper-case, the hook compares lower-case.
+  const id = (callId: string) => callId.toLowerCase();
+  return {
+    startCall: ({ callId, title, target }) => native.startCall(id(callId), title, target),
+    reportConnected: (callId) => native.reportConnected(id(callId)),
+    endCall: (callId, reason = "ended") => native.endCall(id(callId), reason === "failed"),
+    setMuted: (callId, muted) => native.setMuted(id(callId), muted),
+    setSpeaker: (on) => native.setSpeaker(on),
+    takePendingStartRequest: () => native.takePendingStartRequest(),
+    subscribe(listener) {
+      const subscription = native.addListener("onCallEvent", (raw) => {
+        const event = parseNativeCallEvent(raw);
+        if (event) listener(event);
+      });
+      return () => subscription.remove();
+    },
+  };
+}