@mobileai/react-native 0.9.10 → 0.9.11

package/src/support/TicketStore.ts

@@ -0,0 +1,100 @@
+/**
+ * TicketStore — persists the active support ticket across app restarts.
+ *
+ * Uses @react-native-async-storage/async-storage as an optional peer dependency.
+ * If AsyncStorage is not installed, all methods silently no-op and the feature
+ * degrades gracefully (tickets are still shown while the app is open, just not
+ * restored after a restart).
+ *
+ * Usage:
+ *   await TicketStore.save(ticketId, analyticsKey);   // on escalation start
+ *   const pending = await TicketStore.get();           // on AIAgent mount
+ *   await TicketStore.clear();                         // on modal close / ticket closed
+ */
+
+const STORAGE_KEY = '@mobileai_pending_ticket';
+
+interface PendingTicket {
+  ticketId: string;
+  analyticsKey: string;
+}
+
+/** Try to load AsyncStorage at runtime. Optional peer dep — not bundled. */
+function getAsyncStorage(): any | null {
+  try {
+    // Suppress the RN red box that AsyncStorage triggers when its native module
+    // isn't linked ("NativeModule: AsyncStorage is null").
+    const origError = console.error;
+    console.error = (...args: unknown[]) => {
+      const msg = args[0];
+      if (typeof msg === 'string' && msg.includes('AsyncStorage')) return;
+      origError.apply(console, args);
+    };
+    try {
+      const mod = require('@react-native-async-storage/async-storage');
+      const candidate = mod?.default ?? mod?.AsyncStorage ?? null;
+      if (candidate && typeof candidate.getItem === 'function') {
+        return candidate;
+      }
+      return null;
+    } finally {
+      console.error = origError;
+    }
+  } catch {
+    return null;
+  }
+}
+
+export const TicketStore = {
+  /**
+   * Persist the active ticket so it survives an app restart.
+   */
+  async save(ticketId: string, analyticsKey: string): Promise<void> {
+    const AS = getAsyncStorage();
+    if (!AS) {
+      console.warn(
+        '[TicketStore] @react-native-async-storage/async-storage is not installed — ' +
+        'ticket will not persist across app restarts. ' +
+        'Run: npx expo install @react-native-async-storage/async-storage'
+      );
+      return;
+    }
+    try {
+      await AS.setItem(STORAGE_KEY, JSON.stringify({ ticketId, analyticsKey }));
+      console.log('[TicketStore] Ticket saved:', ticketId);
+    } catch (err) {
+      console.error('[TicketStore] Failed to save ticket:', err);
+    }
+  },
+
+  /**
+   * Retrieve the persisted pending ticket, if any.
+   * Returns null if nothing is stored or AsyncStorage is unavailable.
+   */
+  async get(): Promise<PendingTicket | null> {
+    const AS = getAsyncStorage();
+    if (!AS) return null;
+    try {
+      const raw = await AS.getItem(STORAGE_KEY);
+      if (!raw) return null;
+      return JSON.parse(raw) as PendingTicket;
+    } catch (err) {
+      console.error('[TicketStore] Failed to read ticket:', err);
+      return null;
+    }
+  },
+
+  /**
+   * Remove the stored ticket (ticket closed or user dismissed modal).
+   */
+  async clear(): Promise<void> {
+    const AS = getAsyncStorage();
+    if (!AS) return;
+    try {
+      await AS.removeItem(STORAGE_KEY);
+      console.log('[TicketStore] Pending ticket cleared');
+    } catch (err) {
+      console.error('[TicketStore] Failed to clear ticket:', err);
+    }
+  },
+};

package/src/support/escalateTool.ts

@@ -12,14 +12,31 @@ import type { ToolDefinition } from '../core/types';
 import type { EscalationConfig, EscalationContext } from './types';
 import { EscalationSocket } from './EscalationSocket';
 
-const MOBILEAI_HOST = 'https://api.mobileai.dev';
+import { ENDPOINTS } from '../config/endpoints';
+import { getDeviceId } from '../services/telemetry/device';
+import { logger } from '../utils/logger';
+
+const MOBILEAI_HOST = ENDPOINTS.escalation;
 
 export interface EscalationToolDeps {
   config: EscalationConfig;
   analyticsKey?: string;
   getContext: () => Omit<EscalationContext, 'conversationSummary'>;
   getHistory: () => Array<{ role: string; content: string }>;
-  onHumanReply?: (reply: string) => void;
+  onHumanReply?: (reply: string, ticketId?: string) => void;
+  onEscalationStarted?: (ticketId: string, socket: EscalationSocket) => void;
+  onTypingChange?: (isTyping: boolean) => void;
+  onTicketClosed?: (ticketId?: string) => void;
+  userContext?: {
+    userId?: string;
+    name?: string;
+    email?: string;
+    phone?: string;
+    plan?: string;
+    custom?: Record<string, string | number | boolean>;
+  };
+  pushToken?: string;
+  pushTokenType?: 'fcm' | 'expo' | 'apns';
 }
 
 export function createEscalateTool(deps: EscalationToolDeps): ToolDefinition;
@@ -44,7 +61,7 @@ export function createEscalateTool(
     deps = depsOrConfig as EscalationToolDeps;
   }
 
-  const { config, analyticsKey, getContext, getHistory, onHumanReply } = deps;
+  const { config, analyticsKey, getContext, getHistory, onHumanReply, onEscalationStarted, onTypingChange, onTicketClosed, userContext, pushToken, pushTokenType } = deps;
 
   // Determine effective provider
   const provider = config.provider ?? (analyticsKey ? 'mobileai' : 'custom');
@@ -72,10 +89,11 @@ export function createEscalateTool(
 
       if (provider === 'mobileai') {
         if (!analyticsKey) {
-          console.warn('[Escalation] provider=mobileai but no analyticsKey — falling back to custom');
+          logger.warn('Escalation', 'provider=mobileai but no analyticsKey — falling back to custom');
         } else {
           try {
             const history = getHistory().slice(-20); // last 20 messages for context
+            logger.info('Escalation', '★★★ Creating ticket — reason:', reason, '| deviceId:', getDeviceId());
             const res = await fetch(`${MOBILEAI_HOST}/api/v1/escalations`, {
               method: 'POST',
               headers: { 'Content-Type': 'application/json' },
@@ -85,32 +103,48 @@ export function createEscalateTool(
                 screen: context.currentScreen,
                 history,
                 stepsBeforeEscalation: context.stepsBeforeEscalation,
+                userContext,
+                pushToken,
+                pushTokenType,
+                deviceId: getDeviceId(),
               }),
             });
 
             if (res.ok) {
               const { ticketId, wsUrl } = await res.json();
-              console.log(`[Escalation] Ticket created: ${ticketId}`);
+              logger.info('Escalation', '★★★ Ticket created:', ticketId, '| wsUrl:', wsUrl);
 
               // Connect WebSocket for real-time reply
               socket?.disconnect();
               socket = new EscalationSocket({
-                onReply: (reply) => {
-                  console.log(`[Escalation] Human reply received for ticket ${ticketId}`);
-                  onHumanReply?.(reply);
-                  socket?.disconnect();
-                  socket = null;
+                onReply: (reply, replyTicketId) => {
+                  logger.info('Escalation', '★★★ Human reply for ticket', ticketId, ':', reply.substring(0, 80));
+                  onHumanReply?.(reply, replyTicketId || ticketId);
+                },
+                onTypingChange: (v) => {
+                  logger.info('Escalation', '★★★ Agent typing:', v);
+                  onTypingChange?.(v);
+                },
+                onTicketClosed: (closedTicketId) => {
+                  logger.info('Escalation', '★★★ Ticket closed:', ticketId);
+                  onTicketClosed?.(closedTicketId || ticketId);
                 },
                 onError: (err) => {
-                  console.error('[Escalation] WebSocket error:', err);
+                  logger.error('Escalation', '★★★ WebSocket error:', err);
                 },
               });
               socket.connect(wsUrl);
+              logger.info('Escalation', '★★★ WebSocket connecting...');
+
+              // Pass the socket to UI
+              logger.info('Escalation', '★★★ Calling onEscalationStarted for ticket:', ticketId);
+              onEscalationStarted?.(ticketId, socket);
+              logger.info('Escalation', '★★★ onEscalationStarted DONE');
             } else {
-              console.error('[Escalation] Failed to create ticket:', res.status);
+              logger.error('Escalation', 'Failed to create ticket:', res.status);
             }
           } catch (err) {
-            console.error('[Escalation] Network error:', (err as Error).message);
+            logger.error('Escalation', 'Network error:', (err as Error).message);
           }
 
           const message = config.escalationMessage ?? 'Connecting you to a human agent...';

package/src/support/index.ts

@@ -11,6 +11,7 @@ export type {
   CSATConfig,
   CSATRating,
   BusinessHoursConfig,
+  SupportTicket,
 } from './types';
 
 // Prompt injection

package/src/support/types.ts

@@ -139,3 +139,17 @@ export interface BusinessHoursConfig {
   /** Message shown outside business hours */
   offlineMessage?: string;
 }
+
+// ─── Support Ticket ───────────────────────────────────────
+
+export interface SupportTicket {
+  id: string;
+  reason: string;
+  screen: string;
+  status: string;
+  history: Array<{ role: string; content: string; timestamp?: string }>;
+  createdAt: string;
+  wsUrl: string;
+  /** Number of unread messages (computed by backend = history.length - readMessageCount) */
+  unreadCount?: number;
+}