@mobileai/react-native 0.9.18 → 0.9.20

package/lib/module/providers/GeminiProvider.js

@@ -12,18 +12,41 @@
  * with OpenAIProvider, AnthropicProvider, etc.
  */
 
-import { GoogleGenAI, FunctionCallingConfigMode, Type } from '@google/genai';
 import { logger } from "../utils/logger.js";
+
+/**
+ * Lazy-loads @google/genai on first call.
+ * Using require() instead of a static import allows:
+ *  1. Older Metro bundlers (RN 0.72-0.73) to bundle the library without
+ *     choking on the SDK's ESM sub-path exports.
+ *  2. Users who pick OpenAI to never pay the SDK startup cost.
+ *
+ * NOTE: We do NOT cache the result in module-scope variables because that
+ * would break Jest's mock isolation — jest.mock() replaces the module in the
+ * require registry, so every call to require() in a test sees the mock.
+ * Node's own require() cache handles de-duplication in production.
+ */
+function loadGenAI() {
+  try {
+    const mod = require('@google/genai');
+    return {
+      GoogleGenAI: mod.GoogleGenAI,
+      FunctionCallingConfigMode: mod.FunctionCallingConfigMode,
+      Type: mod.Type
+    };
+  } catch (e) {
+    throw new Error('[mobileai] @google/genai is required for the Gemini provider. ' + 'Install it: npm install @google/genai');
+  }
+}
 // ─── Constants ─────────────────────────────────────────────────
 
 const AGENT_STEP_FN = 'agent_step';
 
-// Reasoning fields always present in the agent_step schema
-const REASONING_FIELDS = ['previous_goal_eval', 'memory', 'plan'];
-
 // ─── Provider ──────────────────────────────────────────────────
 
 export class GeminiProvider {
+  // GoogleGenAI instance, loaded lazily
+
   constructor(apiKey, model = 'gemini-2.5-flash', proxyUrl, proxyHeaders) {
     const config = {};
     if (proxyUrl) {
@@ -37,6 +60,9 @@ export class GeminiProvider {
     } else {
       throw new Error('[mobileai] You must provide either "apiKey" or "proxyUrl" to AIAgent.');
     }
+    const {
+      GoogleGenAI
+    } = loadGenAI();
     this.ai = new GoogleGenAI(config);
     this.model = model;
   }
@@ -60,7 +86,7 @@ export class GeminiProvider {
           }],
           toolConfig: {
             functionCallingConfig: {
-              mode: FunctionCallingConfigMode.ANY,
+              mode: loadGenAI().FunctionCallingConfigMode.ANY,
               allowedFunctionNames: [AGENT_STEP_FN]
             }
           },
@@ -91,36 +117,27 @@ export class GeminiProvider {
   // ─── Build agent_step Declaration ──────────────────────────
 
   /**
-   * Builds a single `agent_step` function declaration that combines:
-   * - Structured reasoning fields (previous_goal_eval, memory, plan)
+   * Builds a single `agent_step` function declaration that keeps Gemini's
+   * served schema intentionally narrow:
+   * - Structured reasoning fields
    * - action_name (enum of all available tool names)
-   * - All tool parameter fields as flat top-level properties
+   * - action_input as a JSON object string
    *
-   * Flat schema avoids Gemini's "deeply nested schema" rejection in ANY mode.
+   * Flattening every tool parameter into top-level properties can trigger
+   * Gemini's "too much branching for serving" error once the toolset grows.
    */
   buildAgentStepDeclaration(tools) {
     const toolNames = tools.map(t => t.name);
 
-    // Collect all unique parameter fields across all tools
-    const actionProperties = {};
-    for (const tool of tools) {
-      for (const [paramName, param] of Object.entries(tool.parameters)) {
-        if (actionProperties[paramName]) continue;
-        actionProperties[paramName] = {
-          type: this.mapParamType(param.type),
-          description: param.description,
-          ...(param.enum ? {
-            enum: param.enum
-          } : {})
-        };
-      }
-    }
-
     // Build tool descriptions for the action_name enum
     const toolDescriptions = tools.map(t => {
-      const params = Object.keys(t.parameters).join(', ');
-      return `- ${t.name}(${params}): ${t.description}`;
+      const params = Object.keys(t.parameters);
+      const inputGuide = params.length === 0 ? 'Use {} for action_input.' : `Provide action_input as a JSON object string with keys: ${params.join(', ')}.`;
+      return `- ${t.name}: ${t.description} ${inputGuide}`;
     }).join('\n');
+    const {
+      Type
+    } = loadGenAI();
     return {
       name: AGENT_STEP_FN,
       description: `Execute one agent step. Choose an action and provide reasoning.\n\nAvailable actions:\n${toolDescriptions}`,
@@ -144,25 +161,15 @@ export class GeminiProvider {
             description: 'Which action to execute.',
             enum: toolNames
           },
-          ...actionProperties
+          action_input: {
+            type: Type.STRING,
+            description: 'JSON object string containing only the arguments for action_name. Use "{}" when the action takes no parameters.'
+          }
         },
         required: ['plan', 'action_name']
       }
     };
   }
-  mapParamType(type) {
-    switch (type) {
-      case 'number':
-        return Type.NUMBER;
-      case 'integer':
-        return Type.INTEGER;
-      case 'boolean':
-        return Type.BOOLEAN;
-      case 'string':
-      default:
-        return Type.STRING;
-    }
-  }
 
   // ─── Build Contents ────────────────────────────────────────
 
@@ -265,23 +272,23 @@ export class GeminiProvider {
         text: textPart?.text
       };
     }
-
-    // Build action args: extract only the params that belong to the matched tool
-    const actionArgs = {};
-    const reservedKeys = new Set([...REASONING_FIELDS, 'action_name']);
     const matchedTool = tools.find(t => t.name === actionName);
-    if (matchedTool) {
-      for (const paramName of Object.keys(matchedTool.parameters)) {
-        if (args[paramName] !== undefined) {
-          actionArgs[paramName] = args[paramName];
+    let actionArgs = {};
+    const rawActionInput = args.action_input;
+    if (typeof rawActionInput === 'string' && rawActionInput.trim().length > 0) {
+      try {
+        const parsed = JSON.parse(rawActionInput);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+          actionArgs = parsed;
         }
+      } catch (error) {
+        logger.warn('GeminiProvider', `Invalid action_input JSON for ${actionName}: ${error.message}`);
       }
+    }
+    if (matchedTool) {
+      actionArgs = Object.fromEntries(Object.entries(actionArgs).filter(([key]) => key in matchedTool.parameters));
     } else {
-      for (const [key, value] of Object.entries(args)) {
-        if (!reservedKeys.has(key)) {
-          actionArgs[key] = value;
-        }
-      }
+      actionArgs = {};
     }
     logger.info('GeminiProvider', `Parsed: action=${actionName}, plan="${reasoning.plan}"`);
     return {
@@ -311,8 +318,8 @@ export class GeminiProvider {
     const totalTokens = meta.totalTokenCount ?? promptTokens + completionTokens;
 
     // Cost estimation based on Gemini 2.5 Flash pricing
-    const INPUT_COST_PER_M = 0.30;
-    const OUTPUT_COST_PER_M = 2.50;
+    const INPUT_COST_PER_M = 0.3;
+    const OUTPUT_COST_PER_M = 2.5;
     const estimatedCostUSD = promptTokens / 1_000_000 * INPUT_COST_PER_M + completionTokens / 1_000_000 * OUTPUT_COST_PER_M;
     return {
       promptTokens,
@@ -331,9 +338,11 @@ export class GeminiProvider {
   formatProviderError(status, rawMessage) {
     // Try to extract the human-readable message from JSON body
     let humanMessage = '';
+    let errorCode = '';
     try {
       const parsed = JSON.parse(rawMessage);
       humanMessage = parsed?.error?.message || parsed?.message || '';
+      errorCode = parsed?.error?.code || parsed?.code || '';
     } catch {
       // rawMessage may contain JSON embedded in a string like "503: {json}"
       const jsonMatch = rawMessage.match(/\{[\s\S]*\}/);
@@ -341,9 +350,16 @@ export class GeminiProvider {
         try {
           const parsed = JSON.parse(jsonMatch[0]);
           humanMessage = parsed?.error?.message || parsed?.message || '';
-        } catch {/* ignore */}
+          errorCode = parsed?.error?.code || parsed?.code || '';
+        } catch {
+          /* ignore */
+        }
       }
     }
+    if (errorCode === 'proxy_blocked') {
+      logger.error('GeminiProvider', 'Proxy blocked: Credit limit reached or budget exhausted.');
+      return 'The AI assistant is temporarily unavailable. Please try again later.';
+    }
 
     // Map status codes to friendly descriptions
     switch (status) {

package/lib/module/providers/ProviderFactory.js

@@ -7,7 +7,6 @@
  * know about individual provider implementations.
  */
 
-import { GeminiProvider } from "./GeminiProvider.js";
 import { OpenAIProvider } from "./OpenAIProvider.js";
 export function createProvider(provider = 'gemini', apiKey, model, proxyUrl, proxyHeaders) {
   switch (provider) {
@@ -15,7 +14,12 @@ export function createProvider(provider = 'gemini', apiKey, model, proxyUrl, pro
       return new OpenAIProvider(apiKey, model || 'gpt-4.1-mini', proxyUrl, proxyHeaders);
     case 'gemini':
     default:
-      return new GeminiProvider(apiKey, model || 'gemini-2.5-flash', proxyUrl, proxyHeaders);
+      {
+        const {
+          GeminiProvider
+        } = require('./GeminiProvider');
+        return new GeminiProvider(apiKey, model || 'gemini-2.5-flash', proxyUrl, proxyHeaders);
+      }
   }
 }
 //# sourceMappingURL=ProviderFactory.js.map

package/lib/module/services/AudioInputService.js

@@ -42,20 +42,11 @@ export class AudioInputService {
       // Lazy-load react-native-audio-api (optional peer dependency)
       let audioApi;
       try {
-        const {
-          NativeModules
-        } = require('react-native');
-        if (!NativeModules.AudioApiModule) {
-          const msg = '[mobileai] react-native-audio-api native module not found. ' + 'Voice mode requires a development build (not Expo Go).';
-          logger.warn('AudioInput', msg);
-          this.config.onError?.(msg);
-          return false;
-        }
         // Static require — Metro needs a literal string for bundling.
         audioApi = require('react-native-audio-api');
       } catch {
         const msg = 'Voice mode requires react-native-audio-api. Install with: npm install react-native-audio-api';
-        logger.error('AudioInput', msg);
+        logger.warn('AudioInput', msg);
         this.config.onError?.(msg);
         return false;
       }
@@ -63,8 +54,8 @@ export class AudioInputService {
       // Request mic permission (Android)
       try {
         const {
-          PermissionsAndroid,
-          Platform
+          Platform,
+          PermissionsAndroid
         } = require('react-native');
         if (Platform.OS === 'android') {
           const result = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.RECORD_AUDIO);

package/lib/module/services/AudioOutputService.js

@@ -12,8 +12,6 @@
 
 import { logger } from "../utils/logger.js";
 import { base64ToFloat32 } from "../utils/audioUtils.js";
-import { NativeModules } from 'react-native';
-
 // ─── Types ─────────────────────────────────────────────────────
 
 /** Gemini Live API outputs 24kHz 16-bit mono PCM */
@@ -37,21 +35,11 @@ export class AudioOutputService {
     try {
       let audioApi;
       try {
-        // Guard: NativeModules.AudioApiModule is only present in dev/prod builds.
-        // In Expo Go it is undefined, and require() throws a native bridge error
-        // that cannot be caught by a standard try/catch.
-        if (!NativeModules.AudioApiModule) {
-          const msg = '[mobileai] react-native-audio-api native module not found. ' + 'Voice audio output requires a development build (not Expo Go). ' + 'Run: npx expo run:ios';
-          logger.warn('AudioOutput', msg);
-          this.config.onError?.(msg);
-          return false;
-        }
         // Static require — Metro needs a literal string.
-        // The NativeModules guard above already prevents this from running in Expo Go.
         audioApi = require('react-native-audio-api');
       } catch {
         const msg = 'react-native-audio-api is required for audio output. Install with: npm install react-native-audio-api';
-        logger.error('AudioOutput', msg);
+        logger.warn('AudioOutput', msg);
         this.config.onError?.(msg);
         return false;
       }

package/lib/module/services/ConversationService.js

@@ -0,0 +1,166 @@
+"use strict";
+
+/**
+ * ConversationService — backend-persisted AI conversation history.
+ *
+ * Saves and retrieves AI chat sessions from the MobileAI backend so users
+ * can browse and continue previous conversations across app launches.
+ *
+ * All methods are no-ops when analyticsKey is absent (graceful degradation).
+ * All network errors are silently swallowed — history is best-effort and must
+ * never break the core agent flow.
+ */
+
+import { ENDPOINTS } from "../config/endpoints.js";
+import { logger } from "../utils/logger.js";
+
+// ─── Types ───────────────────────────────────────────────────────
+
+// ─── Serialization ───────────────────────────────────────────────
+
+function toPayload(msgs) {
+  return msgs.filter(m => m.role === 'user' || m.role === 'assistant').filter(m => typeof m.content === 'string' && m.content.trim().length > 0).map(m => ({
+    role: m.role,
+    content: typeof m.content === 'string' ? m.content : String(m.content),
+    timestamp: m.timestamp
+  }));
+}
+
+// ─── Service ─────────────────────────────────────────────────────
+
+/**
+ * Start a new conversation on the backend.
+ * Call this when the first AI response arrives in a new session.
+ * Returns the backend conversationId, or null on failure.
+ */
+export async function startConversation({
+  analyticsKey,
+  userId,
+  deviceId,
+  messages
+}) {
+  if (!analyticsKey) return null;
+  const payload = toPayload(messages);
+  if (!payload.length) return null;
+  try {
+    const res = await fetch(ENDPOINTS.conversations, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        analyticsKey,
+        userId: userId || undefined,
+        deviceId: deviceId || undefined,
+        messages: payload
+      })
+    });
+    if (!res.ok) {
+      logger.warn('ConversationService', `startConversation failed: ${res.status}`);
+      return null;
+    }
+    const data = await res.json();
+    logger.info('ConversationService', `Started conversation: ${data.conversationId}`);
+    return data.conversationId;
+  } catch (err) {
+    logger.warn('ConversationService', `startConversation error: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Append new messages to an existing conversation.
+ * Fire-and-forget — call after each exchange (debounce in caller).
+ */
+export async function appendMessages({
+  conversationId,
+  analyticsKey,
+  messages
+}) {
+  if (!analyticsKey || !conversationId) return;
+  const payload = toPayload(messages);
+  if (!payload.length) return;
+  try {
+    const res = await fetch(ENDPOINTS.conversations, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        analyticsKey,
+        conversationId,
+        messages: payload
+      })
+    });
+    if (!res.ok) {
+      logger.warn('ConversationService', `appendMessages failed: ${res.status}`);
+    }
+  } catch (err) {
+    logger.warn('ConversationService', `appendMessages error: ${err}`);
+  }
+}
+
+/**
+ * Fetch the user's conversation list (most-recent-first).
+ * Returns empty array on failure — never throws.
+ */
+export async function fetchConversations({
+  analyticsKey,
+  userId,
+  deviceId,
+  limit = 20
+}) {
+  if (!analyticsKey) return [];
+  if (!userId && !deviceId) return [];
+  try {
+    const params = new URLSearchParams({
+      analyticsKey,
+      limit: String(limit)
+    });
+    if (userId) params.set('userId', userId);
+    if (deviceId) params.set('deviceId', deviceId);
+    const res = await fetch(`${ENDPOINTS.conversations}?${params.toString()}`);
+    if (!res.ok) {
+      logger.warn('ConversationService', `fetchConversations failed: ${res.status}`);
+      return [];
+    }
+    const data = await res.json();
+    return data.conversations ?? [];
+  } catch (err) {
+    logger.warn('ConversationService', `fetchConversations error: ${err}`);
+    return [];
+  }
+}
+
+/**
+ * Fetch the full message history of a single conversation.
+ * Returns null on failure.
+ */
+export async function fetchConversation({
+  conversationId,
+  analyticsKey
+}) {
+  if (!analyticsKey || !conversationId) return null;
+  try {
+    const params = new URLSearchParams({
+      analyticsKey
+    });
+    const res = await fetch(`${ENDPOINTS.conversations}/${conversationId}?${params.toString()}`);
+    if (!res.ok) {
+      logger.warn('ConversationService', `fetchConversation failed: ${res.status}`);
+      return null;
+    }
+    const data = await res.json();
+    const msgs = (data.messages ?? []).map(m => ({
+      id: m.id,
+      role: m.role,
+      content: m.content,
+      timestamp: m.timestamp
+    }));
+    return msgs;
+  } catch (err) {
+    logger.warn('ConversationService', `fetchConversation error: ${err}`);
+    return null;
+  }
+}
+//# sourceMappingURL=ConversationService.js.map

package/lib/module/services/MobileAIKnowledgeRetriever.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { logger } from "../utils/logger.js";
+function normalizeBaseUrl(baseUrl) {
+  if (!baseUrl) return 'http://localhost:3001';
+  const trimmed = baseUrl.replace(/\/$/, '');
+  return trimmed.endsWith('/api/v1/analytics') ? trimmed.replace(/\/api\/v1\/analytics$/, '') : trimmed;
+}
+export function createMobileAIKnowledgeRetriever(options) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl);
+  const url = `${baseUrl}/api/v1/knowledge/query`;
+  return {
+    async retrieve(query, screenName) {
+      try {
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${options.publishableKey}`,
+            ...(options.headers ?? {})
+          },
+          body: JSON.stringify({
+            query,
+            screenName,
+            limit: options.limit
+          })
+        });
+        if (!response.ok) {
+          logger.warn('MobileAIKnowledge', `Knowledge query failed: HTTP ${response.status}`);
+          return [];
+        }
+        const payload = await response.json();
+        return Array.isArray(payload?.entries) ? payload.entries : [];
+      } catch (error) {
+        logger.error('MobileAIKnowledge', `Knowledge query failed: ${error?.message ?? 'unknown error'}`);
+        return [];
+      }
+    }
+  };
+}
+//# sourceMappingURL=MobileAIKnowledgeRetriever.js.map

package/lib/module/services/VoiceService.js

@@ -15,14 +15,21 @@
  * - Sends screen context (DOM text) for live mode
  */
 
+// @ts-ignore — TS can't find declarations for the deep path at build time
 // Platform-specific import: Metro can't resolve '@google/genai/web' sub-path
-// export, so we use the full path to the web bundle. This is what the SDK
-// recommends ('use a platform specific import') — RN's WebSocket API is
-// browser-compatible so the web bundle works correctly.
-// @ts-ignore — TS can't find declarations for the deep path
-import { GoogleGenAI, Modality } from '@google/genai/dist/web/index.mjs';
-// @ts-ignore
-
+// so we use the full path to the web bundle (works because RN's WebSocket = browser API).
+
+function loadVoiceGenAI() {
+  try {
+    const mod = require('@google/genai/dist/web/index.mjs');
+    return {
+      GoogleGenAI: mod.GoogleGenAI,
+      Modality: mod.Modality
+    };
+  } catch (e) {
+    throw new Error('[mobileai] @google/genai is required for Voice Mode. ' + 'Install it: npm install @google/genai');
+  }
+}
 import { logger } from "../utils/logger.js";
 
 // ─── Types ─────────────────────────────────────────────────────
@@ -64,7 +71,17 @@ export class VoiceService {
     try {
       const genAiConfig = {};
       if (this.config.proxyUrl) {
-        genAiConfig.apiKey = 'proxy-key';
+        // The @google/genai SDK sends apiKey as ?key=<value> in the WebSocket URL.
+        // For HTTP text proxy, the Authorization header carries the secret key.
+        // For WebSocket voice proxy, browser WS APIs don't support custom headers —
+        // the only way to pass auth is via the URL query string.
+        // So we extract the real secret key from proxyHeaders and use it as apiKey,
+        // which the SDK will append as ?key=<secret> in the WS URL.
+        // Our proxy reads it there, validates it, then replaces it with the real
+        // Gemini API key before forwarding upstream.
+        const authHeader = this.config.proxyHeaders?.['Authorization'] ?? this.config.proxyHeaders?.['authorization'];
+        const secretKey = authHeader?.startsWith('Bearer ') ? authHeader.replace('Bearer ', '').trim() : authHeader ?? 'proxy-key';
+        genAiConfig.apiKey = secretKey;
         genAiConfig.httpOptions = {
           baseUrl: this.config.proxyUrl,
           headers: this.config.proxyHeaders || {}
@@ -74,6 +91,10 @@ export class VoiceService {
       } else {
         throw new Error('[mobileai] Must provide apiKey or proxyUrl');
       }
+      const {
+        GoogleGenAI,
+        Modality
+      } = loadVoiceGenAI();
       const ai = new GoogleGenAI(genAiConfig);
       const toolDeclarations = this.buildToolDeclarations();
 

package/lib/module/services/telemetry/MobileAI.js

@@ -12,6 +12,8 @@
  */
 
 import { logger } from "../../utils/logger.js";
+import { getDeviceId } from "./device.js";
+import { ENDPOINTS } from "../../config/endpoints.js";
 const LOG_TAG = 'MobileAI';
 let service = null;
 export const MobileAI = {
@@ -53,6 +55,48 @@ export const MobileAI = {
       return defaultValue ?? '';
     }
     return service.flags.getFlag(key, defaultValue);
+  },
+  /**
+   * Helper function to securely consume a global WOW action limit (like a discount)
+   * natively on the MobileAI Server to prevent prompt injection bypasses.
+   * @param actionName - The exact registered name of the WOW action
+   * @returns true if allowed, false if rejected or error
+   */
+  async consumeWowAction(actionName) {
+    if (!service || !service.config.analyticsKey) {
+      logger.warn(LOG_TAG, 'consumeWowAction failed: SDK not initialized with analyticsKey or publishableKey in AIAgent');
+      return false;
+    }
+    try {
+      const baseUrl = (service.config.analyticsProxyUrl ?? ENDPOINTS.escalation).replace(/\/$/, '').replace(/\/api\/v1\/analytics$/, '');
+      const url = `${baseUrl}/api/v1/wow-actions/consume`;
+      const deviceId = getDeviceId() ?? 'unknown';
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${service.config.analyticsKey}`,
+          ...(service.config.analyticsProxyHeaders ?? {})
+        },
+        body: JSON.stringify({
+          actionName,
+          deviceId
+        })
+      });
+      if (!res.ok) {
+        if (res.status === 429) {
+          logger.info(LOG_TAG, `consumeWowAction denied: Global limit reached for '${actionName}'`);
+        } else {
+          logger.warn(LOG_TAG, `consumeWowAction failed: HTTP ${res.status}`);
+        }
+        return false;
+      }
+      const data = await res.json();
+      return data.allowed === true;
+    } catch (e) {
+      logger.error(LOG_TAG, `consumeWowAction network error: ${e.message}`);
+      return false;
+    }
   }
 };
 

package/lib/module/services/telemetry/TelemetryService.js

@@ -184,6 +184,9 @@ export class TelemetryService {
       sessionId: this.sessionId
     };
     this.queue.push(event);
+    if (this.config.onEvent) {
+      this.config.onEvent(event);
+    }
     if (this.config.debug) {
       logger.debug(LOG_TAG, `→ ${type}`, data);
     }
@@ -212,7 +215,16 @@ export class TelemetryService {
 
   /** Send queued events to the cloud API */
   async flush() {
-    if (!this.isEnabled() || this.queue.length === 0 || this.isFlushing) return;
+    if (!this.isEnabled() || this.isFlushing) return;
+
+    // Extract any pending SDK debug logs to sink them natively to the backend
+    const unflushedLogs = logger.extractUnflushedLines();
+    if (unflushedLogs.length > 0) {
+      this.track('sdk_trace_dump', {
+        logs: unflushedLogs.join('\n')
+      });
+    }
+    if (this.queue.length === 0) return;
     this.isFlushing = true;
     const eventsToSend = [...this.queue];
     this.queue = [];