@ansight/react-native 1.3.0-preview.10 → 1.3.0-preview.11

package/README.md

@@ -77,8 +77,8 @@ bundle; its API requires the native Ansight module.
 
 This package version expects matching native SDK packages:
 
-- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.10`
-- Maven: `ai.ansight:ansight-android:1.3.0-preview.10`
+- CocoaPods: `Ansight`, `AnsightObjC` version `1.3.0-preview.11`
+- Maven: `ai.ansight:ansight-android:1.3.0-preview.11`
 
 ## Quickstart
 
@@ -151,6 +151,7 @@ The TypeScript `AnsightOptions` surface mirrors Android `AnsightOptions`, iOS
 | `secureStorage` | Compatibility alias for native secure-storage allow-list settings. |
 | `remoteTools` | Native visual tree, file, database, preferences, reflection, and secure-storage tool options. |
 | `lifecycle` | JS AppState tracking toggle. Defaults to true. |
+| `networkCapture` | Opt-in `fetch` and `XMLHttpRequest` metadata capture. Accepts `true` or sanitization/capture options. |
 
 Use `withOpenFileHandleTracking()` and `withJniReferenceCountTracking()` to
 opt in through the builder. Matching `without...` methods disable the channels
@@ -201,13 +202,49 @@ await Ansight.initializeAndActivate({
 ```
 
 The touch mode captures native visual trees only on touch down and touch up.
-Move and cancel events do not trigger capture. Native touch capture and
+Move and cancel events do not trigger capture. Rapid boundaries are coalesced
+and rate-limited to protect screenshot cadence. Native touch capture and
 visual-tree tools/providers must remain enabled.
 
 On iOS, `captureGpuBackedSurfaces` defaults to `true` so Metal, SceneKit, and
 similar GPU-backed views are included. Set it to `false` to use a lower-overhead
 capture path when those surfaces are not needed.
 
+## Network capture
+
+Network capture is explicitly enabled by the React Native layer, which
+instruments `fetch` and `XMLHttpRequest`, then sends a typed metadata record
+through the native bridge. It is opt-in:
+
+```ts
+await Ansight.initializeAndActivate(
+  Ansight.createOptionsBuilder()
+    .withAnsightDefaults()
+    .withNetworkCapture({
+      maximumBodyBytes: 64 * 1024,
+      additionalSensitiveHeaderNames: ["x-tenant-secret"],
+      additionalSensitiveQueryParameterNames: ["session"],
+      requestSanitizer: request =>
+        request.url.includes("/health") ? null : request,
+    })
+    .withoutNetworkRequestBodies() // optional, independent opt-out
+    .build(),
+);
+```
+
+Text request and response bodies are included by default after network capture
+is explicitly enabled, with a 64 KiB default per-body limit. Set a larger
+`maximumBodyBytes` when needed; use the request/response body builder methods to
+opt either side out or back in, and `captureBinaryBodies` to explicitly allow
+Base64 binary content. Standard credentials, cloud signed-URL fields, cookies,
+URL user information, and sensitive text-body assignments are redacted before
+the bridge. Capture hooks detach whenever the native host is disconnected.
+
+Use `installNetworkCapture(...)` and `uninstallNetworkCapture()` when capture
+must be controlled independently of initialization. `recordNetworkRequest(...)`
+supports custom HTTP stacks, and `sanitizeNetworkRequest(...)` exposes the same
+app-side policy for inspection or testing.
+
 ## Native Tool Options
 
 `remoteTools` configures the native tool suites registered by the bridge. `useNativeAllInOneDefaults: true` enables visual tree tools by default so Studio can pair `ui.get_visual_tree` data with `ui.get_screenshot` frames. Apps that do not use all-in-one defaults can opt in explicitly:
@@ -389,6 +426,19 @@ await Ansight.clearSessionProperties();
 When connected, property mutations are sent immediately. When disconnected, the
 latest values are included in the next `session.open`.
 
+The bridge automatically adds these property groups:
+
+| Group | Properties |
+| --- | --- |
+| `reactNative` | Ansight SDK, React Native and React versions; platform and runtime language; JavaScript engine and available Hermes version/bytecode details; legacy/new architecture; bridgeless state; development mode. |
+| `localization` | Canonical locale, language, optional region, IANA time zone when exposed by `Intl`, and UTC offset in minutes. |
+
+App-provided values override an automatic value with the same group and key.
+Clearing all properties, or removing one automatic property, restores the
+current bridge-owned value. `localization` reflects the JavaScript runtime
+locale; if the app selects a different language through an i18n library, set
+`localization.locale`, `language`, and `region` explicitly.
+
 ## Tool Guards
 
 | Value | Allowed scopes |

package/android/build.gradle

@@ -67,6 +67,6 @@ repositories {
 dependencies {
   implementation("com.facebook.react:react-android")
   def ansightAndroidVersion =
-      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.10"
-  implementation("ai.ansight:ansight-android:1.3.0-preview.10")
+      findProperty("ansightAndroidVersion") ?: "1.3.0-preview.11"
+  implementation("ai.ansight:ansight-android:1.3.0-preview.11")
 }

package/android/src/main/kotlin/ai/ansight/reactnative/AnsightReactNativeModule.kt

@@ -12,6 +12,7 @@ import ai.ansight.runtime.AnsightHostConnectionOptions
 import ai.ansight.runtime.AnsightLogCallback
 import ai.ansight.runtime.AnsightLogLevel
 import ai.ansight.runtime.AnsightLogger
+import ai.ansight.runtime.AnsightNetworkRequest
 import ai.ansight.runtime.AnsightOptions
 import ai.ansight.runtime.AnsightOptionsBuilder
 import ai.ansight.runtime.AnsightRuntime
@@ -28,6 +29,7 @@ import ai.ansight.runtime.HostConnectionRequestKind
 import ai.ansight.runtime.HostConnectionCapabilities
 import ai.ansight.runtime.HostConnectionResult
 import ai.ansight.runtime.HostConnectionStatus
+import ai.ansight.runtime.HostConnectionStatusSubscription
 import ai.ansight.runtime.OperationResult
 import ai.ansight.runtime.OpenSessionResult
 import ai.ansight.runtime.PairingOpenOptions
@@ -104,16 +106,21 @@ class AnsightReactNativeModule(
     private val logCallback = AnsightLogCallback { level, message, throwable ->
         emitLogEvent(level, message, throwable)
     }
+    private val hostConnectionStatusSubscription: HostConnectionStatusSubscription
 
     init {
         reactContext.addLifecycleEventListener(this)
         AnsightLogger.registerCallback(logCallback)
+        hostConnectionStatusSubscription = AnsightRuntime.addHostConnectionStatusListener(
+            listener = { status, _ -> emitHostConnectionStatusEvent(status) },
+        )
     }
 
     override fun getName(): String = "AnsightReactNative"
 
     override fun invalidate() {
         AnsightLogger.removeCallback(logCallback)
+        hostConnectionStatusSubscription.remove()
         reactContext.removeLifecycleEventListener(this)
         super.invalidate()
     }
@@ -226,6 +233,17 @@ class AnsightReactNativeModule(
         }.resolve(promise)
     }
 
+    @ReactMethod
+    fun recordNetworkRequest(input: ReadableMap, promise: Promise) {
+        runCatching {
+            val request = AnsightNetworkRequest.fromJson(JSONObject(input.toHashMap()))
+                ?: return@runCatching operationResultMap(
+                    OperationResult.failure("Network request must use the ansight.network-request.v1 schema."),
+                )
+            operationResultMap(AnsightRuntime.recordNetworkRequest(request))
+        }.resolve(promise)
+    }
+
     @ReactMethod
     fun recordCrashCandidate(input: ReadableMap, promise: Promise) {
         runCatching {
@@ -677,6 +695,16 @@ class AnsightReactNativeModule(
         }
     }
 
+    private fun emitHostConnectionStatusEvent(status: HostConnectionStatus) {
+        if (listenerCount.get() <= 0) return
+        val event = hostConnectionStatusMap(status)
+        UiThreadUtil.runOnUiThread {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("AnsightHostConnectionStatus", event)
+        }
+    }
+
     private fun configureReactNativeMemoryProfiling(map: ReadableMap?) {
         val options = reactNativeMemoryProfilingOptions(map)
         currentReactNativeMemoryOptions = options

package/index.d.ts

@@ -48,6 +48,75 @@ export interface AnsightTouchCaptureOptions {
   moveCaptureFramesPerSecond?: number;
 }
 
+export interface AnsightNetworkHeader {
+  name: string;
+  value: string;
+}
+
+export interface AnsightNetworkBody {
+  contentType?: string;
+  encoding: "utf8" | "base64";
+  data: string;
+  capturedBytes: number;
+  totalBytes?: number;
+  truncated: boolean;
+}
+
+/** V1 network metadata with optional, bounded bodies. */
+export interface AnsightNetworkRequest {
+  schema: "ansight.network-request.v1";
+  id: string;
+  source: string;
+  startedAtUtc: string;
+  completedAtUtc: string;
+  durationMilliseconds: number;
+  method: string;
+  url: string;
+  protocol?: string;
+  requestHeaders: AnsightNetworkHeader[];
+  requestBodySizeBytes?: number;
+  requestBody?: AnsightNetworkBody;
+  statusCode?: number;
+  reasonPhrase?: string;
+  responseHeaders: AnsightNetworkHeader[];
+  responseBodySizeBytes?: number;
+  responseBody?: AnsightNetworkBody;
+  errorType?: string;
+  errorMessage?: string;
+}
+
+export type AnsightNetworkRequestInput = Partial<AnsightNetworkRequest> & {
+  method: string;
+  url: string;
+};
+
+export interface AnsightNetworkSanitizationOptions {
+  includeRequestHeaders?: boolean;
+  includeResponseHeaders?: boolean;
+  includeQueryString?: boolean;
+  includeBodySizes?: boolean;
+  /** Defaults to true. */
+  captureRequestBody?: boolean;
+  /** Defaults to true. */
+  captureResponseBody?: boolean;
+  /** Decoded bytes retained per body. Defaults to 64 KiB; larger explicit limits are honored. */
+  maximumBodyBytes?: number;
+  captureBinaryBodies?: boolean;
+  additionalSensitiveHeaderNames?: string[];
+  additionalSensitiveQueryParameterNames?: string[];
+  urlSanitizer?: (url: string) => string;
+  /** Return a replacement request, or null to suppress capture. */
+  requestSanitizer?: (
+    request: AnsightNetworkRequest,
+  ) => AnsightNetworkRequest | null;
+}
+
+export interface AnsightNetworkCaptureOptions
+  extends AnsightNetworkSanitizationOptions {
+  captureFetch?: boolean;
+  captureXmlHttpRequest?: boolean;
+}
+
 export interface AnsightNativeToolRoot {
   alias: string;
   path: string;
@@ -155,6 +224,8 @@ export interface AnsightOptions {
   remoteTools?: AnsightRemoteToolsOptions;
   additionalChannels?: AnsightChannel[];
   lifecycle?: boolean;
+  /** Explicitly opt in to fetch/XMLHttpRequest instrumentation. */
+  networkCapture?: boolean | AnsightNetworkCaptureOptions;
 }
 
 export interface AnsightCrashCaptureOptions {
@@ -300,6 +371,12 @@ export class AnsightOptionsBuilder {
   withCrashCapture(crashCapture?: AnsightCrashCaptureOptions): this;
   withoutCrashCapture(): this;
   withLifecycleCapture(lifecycleCapture?: NonNullable<AnsightOptions["lifecycleCapture"]>): this;
+  withNetworkCapture(networkCapture?: AnsightNetworkCaptureOptions): this;
+  withNetworkRequestBodies(maximumBodyBytes?: number): this;
+  withoutNetworkRequestBodies(): this;
+  withNetworkResponseBodies(maximumBodyBytes?: number): this;
+  withoutNetworkResponseBodies(): this;
+  withoutNetworkCapture(): this;
   withToolGuard(toolGuard: NonNullable<AnsightOptions["toolGuard"]>): this;
   withToolsDisabled(): this;
   withReadOnlyToolAccess(): this;
@@ -543,6 +620,18 @@ export function recordMetric(value: number, channel?: number): Promise<AnsightDe
 export function event(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
 export function recordEvent(input: string | { label: string; type?: string; details?: string; channel?: number }): Promise<AnsightDebugSnapshot>;
 export function recordCrashCandidate(input?: AnsightCrashCandidate): Promise<{ candidateId?: string }>;
+export function recordNetworkRequest(
+  input: AnsightNetworkRequestInput,
+  sanitizationOptions?: AnsightNetworkSanitizationOptions,
+): Promise<AnsightOperationResult>;
+export function sanitizeNetworkRequest(
+  input: AnsightNetworkRequestInput,
+  sanitizationOptions?: AnsightNetworkSanitizationOptions,
+): AnsightNetworkRequest | null;
+export function installNetworkCapture(
+  options?: AnsightNetworkCaptureOptions,
+): AnsightSubscription;
+export function uninstallNetworkCapture(): void;
 export function screenViewed(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function trackRoute(name: string, details?: Record<string, string>): Promise<AnsightDebugSnapshot>;
 export function setAppLifecycleState(state: AnsightLifecycleState): Promise<AnsightDebugSnapshot>;
@@ -617,6 +706,7 @@ declare const Ansight: {
   event: typeof event;
   recordEvent: typeof recordEvent;
   recordCrashCandidate: typeof recordCrashCandidate;
+  recordNetworkRequest: typeof recordNetworkRequest;
   screenViewed: typeof screenViewed;
   trackRoute: typeof trackRoute;
   setAppLifecycleState: typeof setAppLifecycleState;
@@ -671,6 +761,9 @@ declare const Ansight: {
   installReactTools: typeof installReactTools;
   uninstallReactTools: typeof uninstallReactTools;
   installErrorHandlers: typeof installErrorHandlers;
+  installNetworkCapture: typeof installNetworkCapture;
+  uninstallNetworkCapture: typeof uninstallNetworkCapture;
+  sanitizeNetworkRequest: typeof sanitizeNetworkRequest;
   createReactNavigationTracker: typeof createReactNavigationTracker;
   platform: "ios" | "android" | string;
 };

package/index.js

@@ -10,6 +10,15 @@ const {
   findNodeHandle,
   processColor,
 } = require("react-native");
+const { version: reactVersion } = require("react");
+const {
+  createAutomaticSessionProperties,
+  mergeSessionProperties,
+} = require("./session-properties");
+const {
+  installNetworkCapture: installNetworkCaptureCore,
+  sanitizeNetworkRequest,
+} = require("./network");
 
 const nativeModule = NativeModules.AnsightReactNative;
 
@@ -33,6 +42,9 @@ const hostConnectionStatusListeners = new Set();
 let lastHostConnectionStatusKey = null;
 const logListeners = new Set();
 let logEventSubscription = null;
+let networkCaptureSubscription = null;
+let networkCaptureRegistration = null;
+let networkConnectionEventSubscription = null;
 const REACT_COMPONENT_TREE_TOOL_ID = "react.get_component_tree";
 const REACT_SHADOW_TREE_TOOL_ID = "react.get_shadow_tree";
 
@@ -44,7 +56,28 @@ function normalizePairingPayload(payload) {
 }
 
 function normalizeOptions(options = {}) {
-  return { ...options };
+  const normalized = {
+    ...options,
+    customProperties: mergeSessionProperties(
+      automaticSessionProperties(),
+      options.customProperties
+    ),
+  };
+  delete normalized.networkCapture;
+  return normalized;
+}
+
+function automaticSessionProperties() {
+  return createAutomaticSessionProperties({
+    platform: Platform,
+    reactVersion,
+    runtimeGlobal: global,
+    developmentMode: typeof __DEV__ !== "undefined" && __DEV__,
+  });
+}
+
+function automaticSessionPropertyValue(group, key) {
+  return automaticSessionProperties()[group]?.[key];
 }
 
 function cloneOptions(options = {}) {
@@ -73,6 +106,17 @@ function cloneOptions(options = {}) {
   if (options.hostConnection) {
     clone.hostConnection = { ...options.hostConnection };
   }
+  if (options.networkCapture && typeof options.networkCapture === "object") {
+    clone.networkCapture = {
+      ...options.networkCapture,
+      additionalSensitiveHeaderNames: options.networkCapture.additionalSensitiveHeaderNames
+        ? [...options.networkCapture.additionalSensitiveHeaderNames]
+        : undefined,
+      additionalSensitiveQueryParameterNames: options.networkCapture.additionalSensitiveQueryParameterNames
+        ? [...options.networkCapture.additionalSensitiveQueryParameterNames]
+        : undefined,
+    };
+  }
   if (options.secureStorage) {
     clone.secureStorage = {
       ...options.secureStorage,
@@ -339,6 +383,52 @@ class AnsightOptionsBuilder {
     return this;
   }
 
+  withNetworkCapture(networkCapture = {}) {
+    this._options.networkCapture = { ...networkCapture };
+    return this;
+  }
+
+  withNetworkRequestBodies(maximumBodyBytes) {
+    if (!this._options.networkCapture || typeof this._options.networkCapture !== "object") return this;
+    const current = this._options.networkCapture;
+    this._options.networkCapture = {
+      ...current,
+      captureRequestBody: true,
+      ...(maximumBodyBytes == null ? {} : { maximumBodyBytes }),
+    };
+    return this;
+  }
+
+  withoutNetworkRequestBodies() {
+    if (!this._options.networkCapture || typeof this._options.networkCapture !== "object") return this;
+    const current = this._options.networkCapture;
+    this._options.networkCapture = { ...current, captureRequestBody: false };
+    return this;
+  }
+
+  withNetworkResponseBodies(maximumBodyBytes) {
+    if (!this._options.networkCapture || typeof this._options.networkCapture !== "object") return this;
+    const current = this._options.networkCapture;
+    this._options.networkCapture = {
+      ...current,
+      captureResponseBody: true,
+      ...(maximumBodyBytes == null ? {} : { maximumBodyBytes }),
+    };
+    return this;
+  }
+
+  withoutNetworkResponseBodies() {
+    if (!this._options.networkCapture || typeof this._options.networkCapture !== "object") return this;
+    const current = this._options.networkCapture;
+    this._options.networkCapture = { ...current, captureResponseBody: false };
+    return this;
+  }
+
+  withoutNetworkCapture() {
+    this._options.networkCapture = false;
+    return this;
+  }
+
   withToolGuard(toolGuard) {
     this._options.toolGuard = toolGuard;
     return this;
@@ -581,6 +671,7 @@ function addHostConnectionStatusListener(listener, options = {}) {
 
 async function notifyAfterHostConnectionChange(operation) {
   const result = await operation();
+  await refreshNetworkCaptureConnection();
   await emitHostConnectionStatusChangedIfNeeded();
   return result;
 }
@@ -2313,6 +2404,7 @@ function installErrorHandlers(options = {}) {
 
 async function initialize(options = {}) {
   const result = await nativeModule.initialize(normalizeOptions(options));
+  await configureNetworkCapture(options.networkCapture);
   if (options.lifecycle !== false) {
     startAppStateTracking();
   }
@@ -2322,6 +2414,7 @@ async function initialize(options = {}) {
 
 async function initializeAndActivate(options = {}) {
   const result = await nativeModule.initializeAndActivate(normalizeOptions(options));
+  await configureNetworkCapture(options.networkCapture);
   if (options.lifecycle !== false) {
     startAppStateTracking();
   }
@@ -2396,6 +2489,93 @@ function recordCrashCandidate(input = {}) {
   });
 }
 
+function recordNetworkRequest(input, sanitizationOptions = {}) {
+  const sanitized = sanitizeNetworkRequest(input, sanitizationOptions, global);
+  if (!sanitized) {
+    return Promise.resolve({ success: false, message: "Network request capture was suppressed by the sanitizer." });
+  }
+  return nativeModule.recordNetworkRequest(sanitized);
+}
+
+function installNetworkCapture(options = {}) {
+  uninstallNetworkCapture();
+  const registration = { options };
+  networkCaptureRegistration = registration;
+  ensureNetworkConnectionEventSubscription();
+  void refreshNetworkCaptureConnection();
+  return {
+    remove() {
+      if (networkCaptureRegistration === registration) {
+        uninstallNetworkCapture();
+      }
+    },
+  };
+}
+
+function uninstallNetworkCapture() {
+  networkCaptureRegistration = null;
+  if (networkConnectionEventSubscription) {
+    networkConnectionEventSubscription.remove();
+    networkConnectionEventSubscription = null;
+  }
+  detachNetworkCapture();
+}
+
+function detachNetworkCapture() {
+  if (!networkCaptureSubscription) return;
+  networkCaptureSubscription.remove();
+  networkCaptureSubscription = null;
+}
+
+async function refreshNetworkCaptureConnection() {
+  const registration = networkCaptureRegistration;
+  if (!registration) {
+    detachNetworkCapture();
+    return;
+  }
+  try {
+    const status = await nativeModule.hostConnectionStatus();
+    if (networkCaptureRegistration !== registration) return;
+    applyNetworkConnectionStatus(status);
+  } catch {
+    if (networkCaptureRegistration === registration) detachNetworkCapture();
+  }
+}
+
+function ensureNetworkConnectionEventSubscription() {
+  if (networkConnectionEventSubscription) return;
+  const emitter = new NativeEventEmitter(nativeModule);
+  networkConnectionEventSubscription = emitter.addListener(
+    "AnsightHostConnectionStatus",
+    applyNetworkConnectionStatus,
+  );
+}
+
+function applyNetworkConnectionStatus(status) {
+  const registration = networkCaptureRegistration;
+  if (!registration || !status || status.isConnected !== true) {
+    detachNetworkCapture();
+    return;
+  }
+  if (!networkCaptureSubscription) {
+    networkCaptureSubscription = installNetworkCaptureCore({
+      globalObject: global,
+      options: registration.options,
+      sourcePrefix: "react-native",
+      capture: (request) => nativeModule.recordNetworkRequest(request),
+    });
+  }
+}
+
+async function configureNetworkCapture(value) {
+  uninstallNetworkCapture();
+  if (!value) return;
+  const registration = { options: typeof value === "object" ? value : {} };
+  networkCaptureRegistration = registration;
+  ensureNetworkConnectionEventSubscription();
+  await refreshNetworkCaptureConnection();
+}
+
 function screenViewed(name, details) {
   return nativeModule.screenViewed(name, details || {});
 }
@@ -2439,6 +2619,7 @@ const Ansight = {
   event: recordEvent,
   recordEvent,
   recordCrashCandidate,
+  recordNetworkRequest,
   screenViewed,
   trackRoute,
   setAppLifecycleState: (state) => nativeModule.setAppLifecycleState(state),
@@ -2473,12 +2654,21 @@ const Ansight = {
   captureScreenFrame: (options = {}) => nativeModule.captureScreenFrame(options || {}),
   enableTouchCapture: () => nativeModule.enableTouchCapture(),
   disableTouchCapture: () => nativeModule.disableTouchCapture(),
-  updateSessionProperties: (properties) => nativeModule.updateSessionProperties(properties || {}),
-  clearSessionProperties: () => nativeModule.clearSessionProperties(),
-  updateCustomProperties: (properties) => nativeModule.updateSessionProperties(properties || {}),
+  updateSessionProperties: (properties) => nativeModule.updateSessionProperties(
+    mergeSessionProperties(automaticSessionProperties(), properties || {})
+  ),
+  clearSessionProperties: () => nativeModule.updateSessionProperties(automaticSessionProperties()),
+  updateCustomProperties: (properties) => nativeModule.updateSessionProperties(
+    mergeSessionProperties(automaticSessionProperties(), properties || {})
+  ),
   registerCustomProperty: (group, key, value) => nativeModule.registerCustomProperty(group, key, value),
-  removeCustomProperty: (group, key) => nativeModule.removeCustomProperty(group, key),
-  clearCustomProperties: () => nativeModule.clearSessionProperties(),
+  removeCustomProperty: (group, key) => {
+    const automaticValue = automaticSessionPropertyValue(group, key);
+    return automaticValue == null
+      ? nativeModule.removeCustomProperty(group, key)
+      : nativeModule.registerCustomProperty(group, key, automaticValue);
+  },
+  clearCustomProperties: () => nativeModule.updateSessionProperties(automaticSessionProperties()),
   registerTool,
   unregisterTool,
   registerArtifactProvider,
@@ -2500,6 +2690,9 @@ const Ansight = {
   installReactTools,
   uninstallReactTools,
   installErrorHandlers,
+  installNetworkCapture,
+  uninstallNetworkCapture,
+  sanitizeNetworkRequest,
   createReactNavigationTracker,
   platform: Platform.OS,
 };
@@ -2518,3 +2711,7 @@ module.exports.registerArtifactProviders = registerArtifactProviders;
 module.exports.unregisterArtifactProvider = unregisterArtifactProvider;
 module.exports.listRegisteredArtifactProviders = listRegisteredArtifactProviders;
 module.exports.clearArtifactProviders = clearArtifactProviders;
+module.exports.recordNetworkRequest = recordNetworkRequest;
+module.exports.installNetworkCapture = installNetworkCapture;
+module.exports.uninstallNetworkCapture = uninstallNetworkCapture;
+module.exports.sanitizeNetworkRequest = sanitizeNetworkRequest;

package/ios/AnsightReactNative.swift

@@ -139,6 +139,7 @@ final class AnsightReactNative: RCTEventEmitter {
 
     private let lock = NSLock()
     private var hasListeners = false
+    private var hostConnectionStatusSubscription: HostConnectionStatusSubscription?
     private var activeCustomToolIds: Set<String> = []
     private var pendingToolCalls: [String: PendingToolCall] = [:]
     private var reactNativeMemorySampler: ReactNativeMemorySamplerBox?
@@ -150,10 +151,14 @@ final class AnsightReactNative: RCTEventEmitter {
     override init() {
         super.init()
         AnsightLogger.registerCallback(logCallback)
+        hostConnectionStatusSubscription = AnsightRuntime.shared.addHostConnectionStatusListener { [weak self] status, _ in
+            self?.emitHostConnectionStatusEvent(status)
+        }
     }
 
     deinit {
         AnsightLogger.removeCallback(logCallback)
+        hostConnectionStatusSubscription?.remove()
     }
 
     override static func requiresMainQueueSetup() -> Bool {
@@ -161,7 +166,7 @@ final class AnsightReactNative: RCTEventEmitter {
     }
 
     override func supportedEvents() -> [String]! {
-        ["AnsightToolCall", "AnsightLog"]
+        ["AnsightToolCall", "AnsightLog", "AnsightHostConnectionStatus"]
     }
 
     override func startObserving() {
@@ -292,6 +297,27 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    @objc(recordNetworkRequest:resolver:rejecter:)
+    func recordNetworkRequest(
+        _ input: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: RCTPromiseRejectBlock
+    ) {
+        guard JSONSerialization.isValidJSONObject(input),
+              let data = try? JSONSerialization.data(withJSONObject: input),
+              let request = try? JSONDecoder().decode(AnsightNetworkRequest.self, from: data),
+              request.schema == AnsightNetworkRequest.schemaName
+        else {
+            resolve(operationResultDictionary(
+                .failure("Network request must use the ansight.network-request.v1 schema.")
+            ))
+            return
+        }
+        Task {
+            resolve(operationResultDictionary(await AnsightRuntime.shared.recordNetworkRequest(request)))
+        }
+    }
+
     @objc(recordCrashCandidate:resolver:rejecter:)
     func recordCrashCandidate(
         _ input: NSDictionary,
@@ -859,6 +885,17 @@ final class AnsightReactNative: RCTEventEmitter {
         }
     }
 
+    private func emitHostConnectionStatusEvent(_ status: HostConnectionStatus) {
+        let shouldEmit = lock.withLock { hasListeners }
+        guard shouldEmit else { return }
+        DispatchQueue.main.async {
+            self.sendEvent(
+                withName: "AnsightHostConnectionStatus",
+                body: self.hostConnectionStatusDictionary(status)
+            )
+        }
+    }
+
     private func configureReactNativeMemoryProfiling(_ dictionary: NSDictionary?) throws {
         let options = ReactNativeMemoryProfilingOptions(dictionary: dictionary)
         currentReactNativeMemoryOptions = options

package/ios/AnsightReactNativeModule.m

@@ -33,6 +33,10 @@ RCT_EXTERN_METHOD(recordEvent:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(recordNetworkRequest:(NSDictionary *)input
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(recordCrashCandidate:(NSDictionary *)input
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)