@opengeni/react-native 1.4.5-canary.37615713321001

package/dist/view-model.d.ts

@@ -0,0 +1,52 @@
+import type { HumanInputAnswer, HumanInputQuestion, SessionStatus } from "@opengeni/sdk";
+import type { ActivityItem, TimelineItem } from "@opengeni/react/session";
+import { type OpenGeniNativeLabels } from "./presentation.js";
+export declare function nativeKnowledgeOutcomeLabel(item: Extract<TimelineItem, {
+    kind: "knowledge";
+}>, labels: OpenGeniNativeLabels): string;
+export type NativeSessionStatusTone = "neutral" | "working" | "attention" | "failed" | "complete";
+export interface NativeActivityPresentation {
+    title: string;
+    preview: string;
+    status: string | null;
+    detail: string | null;
+    expandedByDefault: boolean;
+    tone: "neutral" | "running" | "failed";
+}
+export declare function nativeSessionStatusTone(status: SessionStatus | null): NativeSessionStatusTone;
+export declare function boundedJson(value: unknown, maximum?: number): string;
+export declare function inspectableValuePreview(value: unknown): string;
+export declare function nativeToolDisplayName(name: string): string;
+export declare function nativeActivityPresentation(item: ActivityItem, labels: OpenGeniNativeLabels): NativeActivityPresentation;
+export declare function formatNativeRelativeTime(iso: string, labels: Pick<OpenGeniNativeLabels, "relativeNow" | "relativeSeconds" | "relativeMinutes" | "relativeHours" | "relativeDays">, now?: Date): string;
+export declare function nativeTimelineStatusLabel(status: "running" | "complete" | "failed" | "cancelled", labels: OpenGeniNativeLabels): string;
+export declare function nativeGoalActionLabel(action: Extract<TimelineItem, {
+    kind: "goal";
+}>["action"], labels: OpenGeniNativeLabels): string;
+export declare function nativeHumanInputRequestPreview(requests: readonly {
+    questions: readonly Pick<HumanInputQuestion, "label" | "prompt">[];
+}[]): string;
+export declare function nativeHumanInputSummary(item: Extract<TimelineItem, {
+    kind: "human-input";
+}>, labels: OpenGeniNativeLabels): string;
+export declare function nativeContextCompactionPhaseLabel(phase: Extract<TimelineItem, {
+    kind: "context-compaction";
+}>["phase"], labels: OpenGeniNativeLabels): string;
+export declare function nativeMemoryActionLabel(item: Extract<TimelineItem, {
+    kind: "memory";
+}>, labels: OpenGeniNativeLabels): string;
+export declare function nativeFleetDecisionSummary(item: Extract<TimelineItem, {
+    kind: "fleet-decision";
+}>, labels: OpenGeniNativeLabels): string;
+export declare function timelineAccessibilityLabel(item: TimelineItem, labels: OpenGeniNativeLabels): string;
+export declare function nativeSessionStatusLabel(status: SessionStatus, labels: OpenGeniNativeLabels): string;
+export declare function validateHumanInputAnswers(questions: readonly HumanInputQuestion[], drafts: Readonly<Record<string, NativeHumanInputDraft>>): {
+    answers: HumanInputAnswer[];
+    valid: boolean;
+};
+export interface NativeHumanInputDraft {
+    values: string[];
+    other: string;
+    otherSelected: boolean;
+}
+export declare function emptyHumanInputDraft(): NativeHumanInputDraft;

package/dist/voice-input.d.ts

@@ -0,0 +1,102 @@
+/** A finished recording on the device. */
+export interface NativeVoiceRecording {
+    uri: string;
+    mimeType: string;
+    durationSeconds: number;
+}
+/**
+ * The platform recorder behind dictation. The Expo implementation lives in
+ * `@opengeni/react-native/expo` (`useExpoVoiceRecorder`).
+ */
+export interface NativeVoiceRecorder {
+    /** Ask for microphone access; resolves false when the person declines. */
+    requestPermission(): Promise<boolean>;
+    start(): Promise<void>;
+    /**
+     * Stop and keep the recording; null when nothing was captured. The file must
+     * survive a following `start()`: dictation keeps it until its text is in the
+     * draft, then calls `discard`.
+     */
+    stop(): Promise<NativeVoiceRecording | null>;
+    /** Stop and throw the current recording away. */
+    cancel(): Promise<void>;
+    /** Delete a kept recording file once it is no longer needed. */
+    discard?(recording: NativeVoiceRecording): void;
+    /** Seconds captured so far while recording. */
+    durationSeconds(): number;
+    /** The current input level from 0 to 1 while recording, when the platform meters it. */
+    level(): number | null;
+}
+export type NativeVoiceInputStatus = "idle" | "requesting-permission" | "recording" | "transcribing" | "error";
+export interface NativeVoiceInput {
+    /** Dictation is offered: a recorder exists and the deployment can transcribe. */
+    available: boolean;
+    status: NativeVoiceInputStatus;
+    error: string | null;
+    /** Total seconds captured in this dictation, across segments. */
+    durationSeconds: number;
+    /** Input level from 0 to 1 while recording (null when not metered). */
+    level: number | null;
+    /**
+     * Always null: long dictation rolls over into segments under the server's
+     * per-request limit, so there is no recording cap to count down to.
+     */
+    maxDurationSeconds: number | null;
+    /** A finished recording is kept on the device after a failed transcription. */
+    hasSavedRecording: boolean;
+    start(): void;
+    /** Stop, transcribe and append the text to the draft. */
+    stop(): void;
+    /** Throw the current dictation away (recording or saved). */
+    cancel(): void;
+    /** Transcribe a saved recording again. */
+    retry(): void;
+    /** Hide the error message; a saved recording stays available to retry. */
+    clearError(): void;
+}
+/** Append dictated text to the draft, as the web composer does. */
+export declare function appendDictation(draft: string, transcript: string): string;
+/** An error from the transcription request, with the HTTP status when there was one. */
+export declare class NativeTranscriptionError extends Error {
+    readonly status: number | null;
+    constructor(message: string, status: number | null);
+}
+/**
+ * Whether trying the same audio again can succeed: network failures, timeouts,
+ * rate limits and server errors. Rejections of the audio itself (bad request,
+ * too large, unsupported, forbidden) do not change on retry.
+ */
+export declare function isRetryableTranscriptionError(cause: unknown): boolean;
+/** Delays between automatic attempts; the recording is kept whatever happens. */
+export declare const TRANSCRIPTION_RETRY_DELAYS_MS: readonly [1000, 3000, 8000];
+/**
+ * Where a long recording rolls over into a new segment: a little under the
+ * server's per-request limit, so a segment is never rejected as too long.
+ */
+export declare function dictationSegmentSeconds(maxDurationSeconds: number | null): number | null;
+/**
+ * Dictation for a native composer: record on the device, send the audio to the
+ * deployment's transcription API, and append the text to the draft. The draft
+ * is read at completion, so typing while transcribing is preserved.
+ *
+ * Nothing said is lost: a long recording rolls over into segments under the
+ * per-request limit (transcribed in the background while recording goes on),
+ * failed requests are retried, and a recording whose text could not be fetched
+ * stays on the device until it is transcribed or the person discards it.
+ */
+export declare function useNativeVoiceInput(input: {
+    recorder: NativeVoiceRecorder | null;
+    /** Whether the deployment offers transcription in this workspace. */
+    available: boolean;
+    /** The server's per-request duration limit; long dictation is segmented under it. */
+    maxDurationSeconds?: number | null | undefined;
+    transcribe: (recording: NativeVoiceRecording) => Promise<string>;
+    getValue: () => string;
+    setValue: (value: string) => void;
+    /** Host feedback (haptics) when recording starts and stops. */
+    onFeedback?: ((event: "start" | "stop" | "cancel") => void) | undefined;
+    /** Scope key; changing it cancels a running capture (another session or workspace). */
+    scope?: string | undefined;
+    /** Test seam for the retry delays. */
+    retryDelaysMs?: readonly number[] | undefined;
+}): NativeVoiceInput;

package/dist/webrtc.d.ts

@@ -0,0 +1,9 @@
+import type { NativeCallAdapter } from "./realtime/native-call.js";
+import type { NativeWebRtcAdapter } from "./realtime/native-realtime.js";
+export declare function createReactNativeWebRtcAdapter(configuration?: RTCConfiguration): NativeWebRtcAdapter;
+/**
+ * Hand the system call's audio session to WebRTC: CallKit activates it (so
+ * audio keeps running with the phone locked and follows AirPods or CarPlay),
+ * and WebRTC starts and stops its voice-processing audio on those signals.
+ */
+export declare function connectCallAudioToWebRtc(call: NativeCallAdapter): () => void;

package/dist/webrtc.js

@@ -0,0 +1,19 @@
+import { RTCPeerConnection, mediaDevices, RTCAudioSession } from 'react-native-webrtc';
+
+// src/webrtc.ts
+function createReactNativeWebRtcAdapter(configuration = {}) {
+  return {
+    createPeerConnection: () => new RTCPeerConnection(configuration),
+    getUserMedia: async (constraints) => await mediaDevices.getUserMedia(constraints)
+  };
+}
+function connectCallAudioToWebRtc(call) {
+  return call.subscribe((event) => {
+    if (event.type === "audioSessionActivated") RTCAudioSession.audioSessionDidActivate();
+    else if (event.type === "audioSessionDeactivated") RTCAudioSession.audioSessionDidDeactivate();
+  });
+}
+
+export { connectCallAudioToWebRtc, createReactNativeWebRtcAdapter };
+//# sourceMappingURL=webrtc.js.map
+//# sourceMappingURL=webrtc.js.map

package/dist/webrtc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/webrtc.ts"],"names":[],"mappings":";;;AAQO,SAAS,8BAAA,CACd,aAAA,GAAkC,EAAC,EACd;AACrB,EAAA,OAAO;AAAA,IACL,oBAAA,EAAsB,MACpB,IAAI,iBAAA,CAAkB,aAAsB,CAAA;AAAA,IAC9C,cAAc,OAAO,WAAA,KAClB,MAAM,YAAA,CAAa,aAAa,WAAoB;AAAA,GACzD;AACF;AAOO,SAAS,yBAAyB,IAAA,EAAqC;AAC5E,EAAA,OAAO,IAAA,CAAK,SAAA,CAAU,CAAC,KAAA,KAAU;AAC/B,IAAA,IAAI,KAAA,CAAM,IAAA,KAAS,uBAAA,EAAyB,eAAA,CAAgB,uBAAA,EAAwB;AAAA,SAAA,IAC3E,KAAA,CAAM,IAAA,KAAS,yBAAA,EAA2B,eAAA,CAAgB,yBAAA,EAA0B;AAAA,EAC/F,CAAC,CAAA;AACH","file":"webrtc.js","sourcesContent":["// @opengeni/react-native/webrtc: the ready-made native WebRTC adapter.\n//\n// A separate entry point so hosts without voice never load the native WebRTC\n// module. Requires the optional peer dependency `react-native-webrtc`.\nimport { mediaDevices, RTCAudioSession, RTCPeerConnection } from \"react-native-webrtc\";\nimport type { NativeCallAdapter } from \"./realtime/native-call\";\nimport type { NativeWebRtcAdapter } from \"./realtime/native-realtime\";\n\nexport function createReactNativeWebRtcAdapter(\n  configuration: RTCConfiguration = {},\n): NativeWebRtcAdapter {\n  return {\n    createPeerConnection: () =>\n      new RTCPeerConnection(configuration as never) as unknown as globalThis.RTCPeerConnection,\n    getUserMedia: async (constraints) =>\n      (await mediaDevices.getUserMedia(constraints as never)) as unknown as MediaStream,\n  };\n}\n\n/**\n * Hand the system call's audio session to WebRTC: CallKit activates it (so\n * audio keeps running with the phone locked and follows AirPods or CarPlay),\n * and WebRTC starts and stops its voice-processing audio on those signals.\n */\nexport function connectCallAudioToWebRtc(call: NativeCallAdapter): () => void {\n  return call.subscribe((event) => {\n    if (event.type === \"audioSessionActivated\") RTCAudioSession.audioSessionDidActivate();\n    else if (event.type === \"audioSessionDeactivated\") RTCAudioSession.audioSessionDidDeactivate();\n  });\n}\n"]}

package/expo-module.config.json

@@ -0,0 +1,7 @@
+{
+  "platforms": ["apple"],
+  "apple": {
+    "modules": ["OpenGeniCallModule"],
+    "appDelegateSubscribers": ["OpenGeniCallAppDelegateSubscriber"]
+  }
+}

package/ios/OpenGeniCall.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'OpenGeniCall'
+  s.version        = package['version']
+  s.summary        = 'System voice calls (CallKit) for OpenGeni agents'
+  s.description    = 'Reports OpenGeni realtime voice sessions as CallKit calls and forwards call, audio-session and launch events to JavaScript.'
+  s.license        = 'Apache-2.0'
+  s.author         = 'OpenGeni'
+  s.homepage       = 'https://github.com/Cloudgeni-ai/opengeni'
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/Cloudgeni-ai/opengeni.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.frameworks = 'AVFoundation', 'CallKit', 'Intents'
+
+  s.source_files = '**/*.swift'
+end

package/ios/OpenGeniCallAppDelegateSubscriber.swift

@@ -0,0 +1,29 @@
+import ExpoModulesCore
+import Intents
+import UIKit
+
+/// Turns system call launches into start requests: a call from the Phone
+/// app's recents or Siri (INStartCallIntent), and the home-screen quick action
+/// whose type ends in ".call".
+public class OpenGeniCallAppDelegateSubscriber: ExpoAppDelegateSubscriber {
+  public func application(
+    _ application: UIApplication,
+    continue userActivity: NSUserActivity,
+    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
+  ) -> Bool {
+    guard let intent = userActivity.interaction?.intent as? INStartCallIntent else { return false }
+    let target = intent.contacts?.first?.personHandle?.value
+    OpenGeniCallCenter.shared.requestStart(target: target == "opengeni" ? nil : target)
+    return true
+  }
+
+  public func application(
+    _ application: UIApplication,
+    performActionFor shortcutItem: UIApplicationShortcutItem,
+    completionHandler: @escaping (Bool) -> Void
+  ) {
+    guard shortcutItem.type.hasSuffix(".call") else { return completionHandler(false) }
+    OpenGeniCallCenter.shared.requestStart(target: shortcutItem.userInfo?["target"] as? String)
+    completionHandler(true)
+  }
+}

package/ios/OpenGeniCallCenter.swift

@@ -0,0 +1,189 @@
+import AVFoundation
+import CallKit
+import Foundation
+
+/// One CallKit provider for the process. The app delegate subscriber can receive
+/// a start request (Siri, Phone recents, a home-screen action) before the module
+/// or JavaScript exists, so requests wait here until JavaScript observes them.
+final class OpenGeniCallCenter: NSObject, CXProviderDelegate {
+  static let shared = OpenGeniCallCenter()
+
+  private let controller = CXCallController()
+  private var provider: CXProvider?
+  private var activeCalls = Set<UUID>()
+  private var pendingStart: [String: Any]?
+  private var routeObserver: NSObjectProtocol?
+  private var speaker = true
+
+  /// Set while JavaScript observes events; nil otherwise.
+  var emit: (([String: Any]) -> Void)? {
+    didSet {
+      if emit != nil, let pending = pendingStart {
+        pendingStart = nil
+        emit?(pending)
+      }
+    }
+  }
+
+  func configure(includeInRecents: Bool) {
+    let configuration = CXProviderConfiguration()
+    configuration.supportsVideo = false
+    configuration.maximumCallGroups = 1
+    configuration.maximumCallsPerCallGroup = 1
+    configuration.supportedHandleTypes = [.generic]
+    configuration.includesCallsInRecents = includeInRecents
+    if let provider {
+      provider.configuration = configuration
+      return
+    }
+    let created = CXProvider(configuration: configuration)
+    created.setDelegate(self, queue: nil)
+    provider = created
+    routeObserver = NotificationCenter.default.addObserver(
+      forName: AVAudioSession.routeChangeNotification, object: nil, queue: .main
+    ) { [weak self] _ in
+      self?.send(["type": "routeChanged", "route": Self.currentRoute()])
+    }
+  }
+
+  // MARK: Requests from JavaScript
+
+  func startCall(id: UUID, title: String, target: String?, completion: @escaping (Error?) -> Void) {
+    if provider == nil { configure(includeInRecents: true) }
+    let handle = CXHandle(type: .generic, value: target ?? "opengeni")
+    let action = CXStartCallAction(call: id, handle: handle)
+    action.contactIdentifier = title
+    controller.request(CXTransaction(action: action)) { [weak self] error in
+      DispatchQueue.main.async {
+        if error == nil {
+          self?.activeCalls.insert(id)
+          let update = CXCallUpdate()
+          update.remoteHandle = handle
+          update.localizedCallerName = title
+          update.hasVideo = false
+          update.supportsHolding = false
+          update.supportsGrouping = false
+          update.supportsUngrouping = false
+          update.supportsDTMF = false
+          self?.provider?.reportCall(with: id, updated: update)
+        }
+        completion(error)
+      }
+    }
+  }
+
+  func reportConnected(id: UUID) {
+    provider?.reportOutgoingCall(with: id, connectedAt: Date())
+  }
+
+  func endCall(id: UUID, failed: Bool, completion: @escaping () -> Void) {
+    guard activeCalls.contains(id) else { return completion() }
+    if failed {
+      activeCalls.remove(id)
+      provider?.reportCall(with: id, endedAt: Date(), reason: .failed)
+      return completion()
+    }
+    controller.request(CXTransaction(action: CXEndCallAction(call: id))) { [weak self] error in
+      DispatchQueue.main.async {
+        if error != nil {
+          self?.activeCalls.remove(id)
+          self?.provider?.reportCall(with: id, endedAt: Date(), reason: .remoteEnded)
+        }
+        completion()
+      }
+    }
+  }
+
+  func setMuted(id: UUID, muted: Bool, completion: @escaping () -> Void) {
+    guard activeCalls.contains(id) else { return completion() }
+    controller.request(CXTransaction(action: CXSetMutedCallAction(call: id, muted: muted))) { _ in
+      DispatchQueue.main.async { completion() }
+    }
+  }
+
+  func setSpeaker(_ on: Bool) throws {
+    speaker = on
+    let session = AVAudioSession.sharedInstance()
+    try session.setCategory(.playAndRecord, mode: .voiceChat, options: Self.options(speaker: on))
+    try session.overrideOutputAudioPort(on ? .speaker : .none)
+  }
+
+  // MARK: Start requests from outside the app
+
+  func requestStart(target: String?) {
+    let event: [String: Any] = ["type": "startRequested", "target": target ?? NSNull()]
+    if let emit {
+      emit(event)
+    } else {
+      pendingStart = event
+    }
+  }
+
+  func takePendingStart() -> [String: Any]? {
+    defer { pendingStart = nil }
+    guard let pending = pendingStart else { return nil }
+    return ["target": pending["target"] ?? NSNull()]
+  }
+
+  // MARK: CXProviderDelegate
+
+  func providerDidReset(_ provider: CXProvider) {
+    for id in activeCalls { send(["type": "ended", "callId": id.uuidString.lowercased()]) }
+    activeCalls.removeAll()
+  }
+
+  func provider(_ provider: CXProvider, perform action: CXStartCallAction) {
+    // CallKit activates this configuration; WebRTC's voice processing then
+    // provides echo cancellation for hands-free use.
+    let session = AVAudioSession.sharedInstance()
+    try? session.setCategory(.playAndRecord, mode: .voiceChat, options: Self.options(speaker: speaker))
+    provider.reportOutgoingCall(with: action.callUUID, startedConnectingAt: Date())
+    action.fulfill()
+  }
+
+  func provider(_ provider: CXProvider, perform action: CXEndCallAction) {
+    activeCalls.remove(action.callUUID)
+    send(["type": "ended", "callId": action.callUUID.uuidString.lowercased()])
+    action.fulfill()
+  }
+
+  func provider(_ provider: CXProvider, perform action: CXSetMutedCallAction) {
+    send([
+      "type": "muteChanged", "callId": action.callUUID.uuidString.lowercased(),
+      "muted": action.isMuted,
+    ])
+    action.fulfill()
+  }
+
+  func provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession) {
+    send(["type": "audioSessionActivated"])
+    send(["type": "routeChanged", "route": Self.currentRoute()])
+  }
+
+  func provider(_ provider: CXProvider, didDeactivate audioSession: AVAudioSession) {
+    send(["type": "audioSessionDeactivated"])
+  }
+
+  // MARK: Helpers
+
+  private func send(_ event: [String: Any]) {
+    DispatchQueue.main.async { [weak self] in self?.emit?(event) }
+  }
+
+  private static func options(speaker: Bool) -> AVAudioSession.CategoryOptions {
+    speaker ? [.allowBluetooth, .defaultToSpeaker] : [.allowBluetooth]
+  }
+
+  static func currentRoute() -> String {
+    guard let output = AVAudioSession.sharedInstance().currentRoute.outputs.first else {
+      return "other"
+    }
+    switch output.portType {
+    case .builtInSpeaker: return "speaker"
+    case .builtInReceiver: return "receiver"
+    case .bluetoothHFP, .bluetoothA2DP, .bluetoothLE, .carAudio: return "bluetooth"
+    case .headphones, .usbAudio: return "headphones"
+    default: return "other"
+    }
+  }
+}

package/ios/OpenGeniCallModule.swift

@@ -0,0 +1,64 @@
+import ExpoModulesCore
+
+public class OpenGeniCallModule: Module {
+  private let center = OpenGeniCallCenter.shared
+
+  public func definition() -> ModuleDefinition {
+    Name("OpenGeniCall")
+
+    Events("onCallEvent")
+
+    OnStartObserving {
+      self.center.emit = { [weak self] event in self?.sendEvent("onCallEvent", event) }
+    }
+
+    OnStopObserving {
+      self.center.emit = nil
+    }
+
+    Function("configure") { (includeInRecents: Bool) in
+      DispatchQueue.main.async { self.center.configure(includeInRecents: includeInRecents) }
+    }
+
+    AsyncFunction("startCall") { (callId: String, title: String, target: String?, promise: Promise) in
+      guard let id = UUID(uuidString: callId) else {
+        return promise.reject("ERR_CALL_ID", "Call id must be a UUID")
+      }
+      self.center.startCall(id: id, title: title, target: target) { error in
+        if let error {
+          promise.reject("ERR_CALL_START", error.localizedDescription)
+        } else {
+          promise.resolve(nil)
+        }
+      }
+    }
+    .runOnQueue(.main)
+
+    Function("reportConnected") { (callId: String) in
+      guard let id = UUID(uuidString: callId) else { return }
+      DispatchQueue.main.async { self.center.reportConnected(id: id) }
+    }
+
+    AsyncFunction("endCall") { (callId: String, failed: Bool, promise: Promise) in
+      guard let id = UUID(uuidString: callId) else { return promise.resolve(nil) }
+      self.center.endCall(id: id, failed: failed) { promise.resolve(nil) }
+    }
+    .runOnQueue(.main)
+
+    AsyncFunction("setMuted") { (callId: String, muted: Bool, promise: Promise) in
+      guard let id = UUID(uuidString: callId) else { return promise.resolve(nil) }
+      self.center.setMuted(id: id, muted: muted) { promise.resolve(nil) }
+    }
+    .runOnQueue(.main)
+
+    AsyncFunction("setSpeaker") { (on: Bool) in
+      try self.center.setSpeaker(on)
+    }
+    .runOnQueue(.main)
+
+    AsyncFunction("takePendingStartRequest") { () -> [String: Any]? in
+      self.center.takePendingStart()
+    }
+    .runOnQueue(.main)
+  }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@opengeni/react-native",
+  "version": "1.4.5-canary.37615713321001",
+  "description": "React Native and Expo kit for OpenGeni agents: the native session timeline, composer adapters, voice dictation, and realtime voice calls (CallKit) on the same SDK controllers as the web.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cloudgeni-ai/opengeni.git",
+    "directory": "packages/react-native"
+  },
+  "files": [
+    "dist",
+    "src",
+    "ios",
+    "expo-module.config.json",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters.d.ts",
+      "import": "./dist/adapters.js"
+    },
+    "./expo": {
+      "types": "./dist/expo.d.ts",
+      "import": "./dist/expo.js"
+    },
+    "./ui": {
+      "types": "./dist/ui/index.d.ts",
+      "import": "./dist/ui/index.js"
+    },
+    "./timeline": {
+      "types": "./dist/timeline/index.d.ts",
+      "import": "./dist/timeline/index.js"
+    },
+    "./timeline/markdown": {
+      "types": "./dist/timeline/markdown.d.ts",
+      "import": "./dist/timeline/markdown.js"
+    },
+    "./webrtc": {
+      "types": "./dist/webrtc.d.ts",
+      "import": "./dist/webrtc.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "bun ../../scripts/build-typescript-package.ts",
+    "prepublishOnly": "bash ../../scripts/prepublish-guard"
+  },
+  "dependencies": {
+    "@opengeni/contracts": "1.4.5-canary.37615713321001",
+    "@opengeni/react": "1.4.5-canary.37615713321001",
+    "@opengeni/sdk": "1.4.5-canary.37615713321001",
+    "thinking-orbs": "^0.3.1"
+  },
+  "peerDependencies": {
+    "expo": ">=57",
+    "expo-audio": "*",
+    "expo-crypto": "*",
+    "expo-document-picker": "*",
+    "expo-file-system": "*",
+    "expo-glass-effect": "*",
+    "expo-image-picker": "*",
+    "expo-modules-core": "*",
+    "react": ">=19",
+    "react-native": ">=0.80",
+    "react-native-markdown-display": ">=7",
+    "react-native-reanimated": ">=4",
+    "react-native-safe-area-context": ">=5",
+    "react-native-svg": ">=15",
+    "react-native-webrtc": ">=124"
+  },
+  "peerDependenciesMeta": {
+    "react-native-markdown-display": {
+      "optional": true
+    },
+    "react-native-webrtc": {
+      "optional": true
+    }
+  }
+}