@mobileai/react-native 0.9.17 → 0.9.19

package/src/support/TicketStore.ts

@@ -1,100 +0,0 @@
-/**
- * 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

@@ -1,174 +0,0 @@
-/**
- * Escalate tool — hands off the conversation to a human agent.
- *
- * Providers:
- * - 'mobileai' (default when analyticsKey present):
- *   POSTs to MobileAI /api/v1/escalations → gets ticketId + wsUrl
- *   Opens WebSocket via EscalationSocket → agent reply pushed in real time
- * - 'custom': fires the consumer's onEscalate callback (backward compatible)
- */
-
-import type { ToolDefinition } from '../core/types';
-import type { EscalationConfig, EscalationContext } from './types';
-import { EscalationSocket } from './EscalationSocket';
-
-import { ENDPOINTS } from '../config/endpoints';
-import { getDeviceId } from '../services/telemetry/device';
-import { getDeviceMetadata } from '../services/telemetry/deviceMetadata';
-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 }>;
-  getScreenFlow?: () => string[];
-  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;
-/** @deprecated Use createEscalateTool({ config, analyticsKey, getContext, getHistory }) */
-export function createEscalateTool(
-  config: EscalationConfig,
-  getContext: () => Omit<EscalationContext, 'conversationSummary'>
-): ToolDefinition;
-export function createEscalateTool(
-  depsOrConfig: EscalationToolDeps | EscalationConfig,
-  legacyGetContext?: () => Omit<EscalationContext, 'conversationSummary'>
-): ToolDefinition {
-  // Normalise both call signatures
-  let deps: EscalationToolDeps;
-  if (legacyGetContext) {
-    deps = {
-      config: depsOrConfig as EscalationConfig,
-      getContext: legacyGetContext,
-      getHistory: () => [],
-    };
-  } else {
-    deps = depsOrConfig as EscalationToolDeps;
-  }
-
-  const { config, analyticsKey, getContext, getHistory, onHumanReply, onEscalationStarted, onTypingChange, onTicketClosed, userContext, pushToken, pushTokenType, getScreenFlow } = deps;
-
-  // Determine effective provider
-  const provider = config.provider ?? (analyticsKey ? 'mobileai' : 'custom');
-
-  // Socket instance kept here — one per tool instance
-  let socket: EscalationSocket | null = null;
-
-  return {
-    name: 'escalate_to_human',
-    description:
-      'Hand off the conversation to a human support agent. ' +
-      'Use this when: (1) the user explicitly asks for a human, ' +
-      '(2) you cannot resolve the issue after multiple attempts, or ' +
-      '(3) the topic requires human judgment (billing disputes, account issues).',
-    parameters: {
-      reason: {
-        type: 'string',
-        description: 'Brief summary of why escalation is needed and what has been tried',
-        required: true,
-      },
-    },
-    execute: async (args: Record<string, unknown>) => {
-      const reason = String(args.reason ?? 'User requested human support');
-      const context = getContext();
-
-      if (provider === 'mobileai') {
-        if (!analyticsKey) {
-          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' },
-              body: JSON.stringify({
-                analyticsKey,
-                reason,
-                screen: context.currentScreen,
-                history,
-                stepsBeforeEscalation: context.stepsBeforeEscalation,
-                userContext: {
-                  ...userContext,
-                  device: getDeviceMetadata(),
-                },
-                screenFlow: getScreenFlow?.() ?? [],
-                pushToken,
-                pushTokenType,
-                deviceId: getDeviceId(),
-              }),
-            });
-
-            if (res.ok) {
-              const { ticketId, wsUrl } = await res.json();
-              logger.info('Escalation', '★★★ Ticket created:', ticketId, '| wsUrl:', wsUrl);
-
-              // Connect WebSocket for real-time reply
-              socket?.disconnect();
-              socket = new EscalationSocket({
-                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) => {
-                  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 {
-              logger.error('Escalation', 'Failed to create ticket:', res.status);
-            }
-          } catch (err) {
-            logger.error('Escalation', 'Network error:', (err as Error).message);
-          }
-
-          const message = config.escalationMessage ?? 'Connecting you to a human agent...';
-          return `ESCALATED: ${message}`;
-        }
-      }
-
-      // 'custom' provider — fire callback
-      const escalationContext: EscalationContext = {
-        conversationSummary: reason,
-        currentScreen: context.currentScreen,
-        originalQuery: context.originalQuery,
-        stepsBeforeEscalation: context.stepsBeforeEscalation,
-      };
-      config.onEscalate?.(escalationContext);
-
-      const message = config.escalationMessage ?? 'Connecting you to a human agent...';
-      return `ESCALATED: ${message}`;
-    },
-  };
-}

package/src/support/index.ts

@@ -1,29 +0,0 @@
-/**
- * Support Mode — barrel export.
- */
-
-// Types
-export type {
-  SupportModeConfig,
-  QuickReply,
-  EscalationConfig,
-  EscalationContext,
-  CSATConfig,
-  CSATRating,
-  BusinessHoursConfig,
-  SupportTicket,
-} from './types';
-
-// Prompt injection
-export { buildSupportPrompt } from './supportPrompt';
-
-// Escalation tool + WebSocket manager
-export { createEscalateTool } from './escalateTool';
-export { EscalationSocket } from './EscalationSocket';
-export type { SocketReplyHandler } from './EscalationSocket';
-export { EscalationEventSource } from './EscalationEventSource';
-
-// UI Components
-export { SupportGreeting } from './SupportGreeting';
-export { CSATSurvey } from './CSATSurvey';
-

package/src/support/supportPrompt.ts

@@ -1,55 +0,0 @@
-/**
- * Support Mode prompt — injected into the system prompt when support mode is enabled.
- *
- * Uses POSITIVE framing (what TO DO) instead of negative rules (per user's prompt engineering rules).
- */
-
-import type { SupportModeConfig } from './types';
-
-/**
- * Build the support mode system prompt addition.
- * This gets appended to the main system prompt when support mode is active.
- */
-export function buildSupportPrompt(config: SupportModeConfig): string {
-  const parts: string[] = [];
-
-  // Core support persona
-  parts.push(`
-## Support Mode Active
-
-You are a helpful customer support assistant. Your primary goal is to resolve the user's issue quickly and empathetically.
-
-### Behavior Guidelines
-- Greet the user warmly and acknowledge their issue
-- Ask clarifying questions when the user's request is ambiguous
-- Provide step-by-step guidance when helping with app features
-- Use the app's UI tools to demonstrate solutions visually (tap, navigate, type)
-- After resolving, confirm with the user that their issue is fixed
-- Stay focused on the user's current issue — complete one task before moving to another
-`);
-
-  // Custom system context from the consumer
-  if (config.systemContext) {
-    parts.push(`### App Context\n${config.systemContext}\n`);
-  }
-
-  // Auto-escalate topics
-  if (config.autoEscalateTopics?.length) {
-    parts.push(
-      `### Auto-Escalation Topics\n` +
-      `When the user's query matches any of these topics, use the escalate_to_human tool immediately:\n` +
-      config.autoEscalateTopics.map((t) => `- ${t}`).join('\n') + '\n'
-    );
-  }
-
-  // Business hours context
-  if (config.businessHours) {
-    parts.push(
-      `### Business Hours\n` +
-      `The support team operates in timezone: ${config.businessHours.timezone}.\n` +
-      `If outside business hours, inform the user and offer to help with what you can.\n`
-    );
-  }
-
-  return parts.join('\n');
-}

package/src/support/types.ts

@@ -1,155 +0,0 @@
-/**
- * Support Mode — types and configuration.
- *
- * Transforms the AI agent into a customer support assistant with:
- * - Custom greeting message
- * - Quick reply suggestions
- * - Human escalation capability
- * - CSAT (Customer Satisfaction) collection after conversation
- */
-
-// ─── Support Mode Config ──────────────────────────────────
-
-export interface SupportModeConfig {
-  /** Enable support mode. Default: false */
-  enabled: boolean;
-
-  /** Greeting message shown when the chat opens */
-  greeting?: {
-    /** Main greeting text (e.g., "Hi! 👋 How can I help you today?") */
-    message: string;
-    /** Agent name shown above the greeting (e.g., "MobileAI Support") */
-    agentName?: string;
-    /** Avatar URL for the support agent */
-    avatarUrl?: string;
-  };
-
-  /** Quick reply buttons shown below the greeting */
-  quickReplies?: QuickReply[];
-
-  /** Escalation configuration */
-  escalation?: EscalationConfig;
-
-  /** CSAT survey configuration */
-  csat?: CSATConfig;
-
-  /** Business hours (optional — shows offline message outside hours) */
-  businessHours?: BusinessHoursConfig;
-
-  /**
-   * Additional system prompt context for the support persona.
-   * Merged with the base system prompt.
-   * Example: "You are a friendly support agent for FeedYum food delivery app."
-   */
-  systemContext?: string;
-
-  /**
-   * Topics the AI should NOT attempt to resolve — escalate immediately.
-   * Example: ['billing dispute', 'account deletion', 'legal']
-   */
-  autoEscalateTopics?: string[];
-}
-
-// ─── Quick Replies ────────────────────────────────────────
-
-export interface QuickReply {
-  /** Display text on the button */
-  label: string;
-  /** Message sent when tapped (defaults to label if not set) */
-  message?: string;
-  /** Icon emoji (optional) */
-  icon?: string;
-}
-
-// ─── Escalation ───────────────────────────────────────────
-
-export interface EscalationConfig {
-  /**
-   * Where to route the escalation.
-   * - 'mobileai' (default when analyticsKey is set): ticket goes to MobileAI
-   *   dashboard inbox via POST /api/v1/escalations + WebSocket reply delivery.
-   * - 'custom': fires the onEscalate callback — wire to Intercom, Zendesk, etc.
-   */
-  provider?: 'mobileai' | 'custom';
-
-  /**
-   * Callback when user requests human support (required when provider='custom').
-   * Use this to open a live chat widget, send email, etc.
-   */
-  onEscalate?: (context: EscalationContext) => void;
-
-  /** Label for the escalate button. Default: "Talk to a human" */
-  buttonLabel?: string;
-
-  /** Message shown to user when escalated. Default: "Connecting you to a human agent..." */
-  escalationMessage?: string;
-}
-
-export interface EscalationContext {
-  /** Summary of the conversation so far */
-  conversationSummary: string;
-  /** Current screen the user is on */
-  currentScreen: string;
-  /** User's original question/issue */
-  originalQuery: string;
-  /** Number of AI steps taken before escalation */
-  stepsBeforeEscalation: number;
-}
-
-// ─── CSAT (Customer Satisfaction) ─────────────────────────
-
-export interface CSATConfig {
-  /** Enable CSAT survey after conversation. Default: true if support mode enabled */
-  enabled?: boolean;
-
-  /** Question text. Default: "How was your experience?" */
-  question?: string;
-
-  /** Rating type. Default: 'emoji' */
-  ratingType?: 'stars' | 'emoji' | 'thumbs';
-
-  /** Callback when user submits rating */
-  onSubmit: (rating: CSATRating) => void;
-
-  /** Show after N seconds of inactivity. Default: 10 */
-  showAfterIdleSeconds?: number;
-}
-
-export interface CSATRating {
-  /** Numeric score (1-5 for stars/emoji, 0-1 for thumbs) */
-  score: number;
-  /** Optional text feedback */
-  feedback?: string;
-  /** Conversation metadata */
-  metadata: {
-    conversationDuration: number;
-    stepsCount: number;
-    wasEscalated: boolean;
-    screen: string;
-  };
-}
-
-// ─── Business Hours ───────────────────────────────────────
-
-export interface BusinessHoursConfig {
-  /** Timezone (IANA format, e.g., 'Africa/Cairo') */
-  timezone: string;
-  /** Schedule per day of week (0=Sunday, 6=Saturday) */
-  schedule: Record<number, { start: string; end: string } | null>;
-  /** 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;
-}

package/src/tools/datePickerTool.ts

@@ -1,60 +0,0 @@
-/**
- * Date Picker Tool — Set date/time picker values.
- *
- * Pattern from Detox: setDatePickerDate(dateString, dateFormat)
- *
- * In JS: calls onChange(event, date) with a Date object.
- * The event parameter mimics the native event shape: { nativeEvent: { timestamp } }
- */
-
-import { walkFiberTree } from '../core/FiberTreeWalker';
-import type { AgentTool, ToolContext } from './types';
-
-export function createDatePickerTool(context: ToolContext): AgentTool {
-  return {
-    name: 'set_date',
-    description: 'Set the value of a date/time picker. Provide the date in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss).',
-    parameters: {
-      index: { type: 'number', description: 'The index of the date picker element', required: true },
-      date: { type: 'string', description: 'Date in ISO 8601 format, e.g., "2025-03-25" or "2025-03-25T14:30:00"', required: true },
-    },
-    execute: async (args) => {
-      const { interactives: elements } = walkFiberTree(context.getRootRef(), context.getWalkConfig());
-      const element = elements.find(el => el.index === args.index);
-      if (!element) {
-        return `❌ Element with index ${args.index} not found.`;
-      }
-
-      // Parse the date string
-      const dateObj = new Date(args.date);
-      if (isNaN(dateObj.getTime())) {
-        return `❌ Invalid date format: "${args.date}". Use ISO 8601 format (e.g., "2025-03-25" or "2025-03-25T14:30:00").`;
-      }
-
-      // Find onChange handler (DateTimePicker's primary callback)
-      const onChange = element.props.onChange || element.props.onDateChange || element.props.onConfirm;
-      if (!onChange || typeof onChange !== 'function') {
-        return `❌ Element [${args.index}] "${element.label}" is not a date picker (no onChange/onDateChange handler).`;
-      }
-
-      try {
-        // Mimic native event shape (like DateTimePicker's native event)
-        const syntheticEvent = {
-          type: 'set',
-          nativeEvent: {
-            timestamp: dateObj.getTime(),
-            utcOffset: 0,
-          },
-        };
-
-        onChange(syntheticEvent, dateObj);
-        await new Promise(resolve => setTimeout(resolve, 500));
-
-        const formattedDate = dateObj.toLocaleDateString();
-        return `✅ Set date picker [${args.index}] "${element.label}" to ${formattedDate}`;
-      } catch (error: any) {
-        return `❌ Error setting date: ${error.message}`;
-      }
-    },
-  };
-}

package/src/tools/guideTool.ts

@@ -1,76 +0,0 @@
-import { DeviceEventEmitter } from 'react-native';
-import type { ToolDefinition } from '../core/types';
-import type { ToolContext } from './types';
-import { logger } from '../utils/logger';
-
-export function createGuideTool(context: ToolContext): ToolDefinition {
-  return {
-    name: 'guide_user',
-    description: 'Highlight a specific element to draw the user\'s attention. Use when you want to show the user where to tap next. Auto-dismisses after a few seconds.',
-    parameters: {
-      index: { 
-        type: 'number', 
-        description: 'Fiber element index from the screen layout',
-        required: true,
-      },
-      message: { 
-        type: 'string', 
-        description: 'Short instruction shown near the highlighted element (e.g. "Tap here to continue")',
-        required: true,
-      },
-      autoRemoveAfterMs: { 
-        type: 'number', 
-        description: 'Auto-dismiss after this many milliseconds. Default: 5000',
-        required: false,
-      }
-    },
-    execute: async (args: Record<string, any>) => {
-      const lastDehydratedRoot = context.getLastDehydratedRoot?.();
-      if (!lastDehydratedRoot) {
-        return '❌ Cannot guide user: No screen layout structure available.';
-      }
-
-      const index = Number(args.index);
-      const element = lastDehydratedRoot.elements[index];
-
-      if (process.env.NODE_ENV === 'test') {
-        // Fallback for react-test-renderer which provides a dummy measure() that never fires callbacks
-        DeviceEventEmitter.emit('MOBILE_AI_HIGHLIGHT', {
-          pageX: 0,
-          pageY: 0,
-          width: 100,
-          height: 100,
-          message: args.message,
-          autoRemoveAfterMs: args.autoRemoveAfterMs || 5000,
-        });
-        return `✅ Highlighted element ${index} ("${element.label}") with message: "${args.message}"`;
-      }
-
-      const stateNode = element.fiberNode?.stateNode;
-      if (!stateNode || typeof stateNode.measure !== 'function') {
-        return `❌ Element at index ${index} (${element.label}) cannot be highlighted because its layout position cannot be measured.`;
-      }
-
-      return new Promise((resolve) => {
-        stateNode.measure((_x: number, _y: number, width: number, height: number, pageX: number, pageY: number) => {
-          if (width === 0 || height === 0) {
-            resolve(`❌ Element at index ${index} is not visible (0x0 size)`);
-            return;
-          }
-
-          DeviceEventEmitter.emit('MOBILE_AI_HIGHLIGHT', {
-            pageX,
-            pageY,
-            width,
-            height,
-            message: args.message,
-            autoRemoveAfterMs: args.autoRemoveAfterMs || 5000,
-          });
-
-          logger.info('GuideTool', `Highlighted element ${index} ("${element.label}") at ${pageX},${pageY}`);
-          resolve(`✅ Highlighted element ${index} ("${element.label}") with message: "${args.message}"`);
-        });
-      });
-    },
-  };
-}

package/src/tools/index.ts

@@ -1,20 +0,0 @@
-/**
- * Tool Module Barrel Export
- *
- * All tool factory functions are exported from here.
- * AgentRuntime imports this single file to register all tools.
- */
-
-export { createTapTool } from './tapTool';
-export { createLongPressTool } from './longPressTool';
-export { createTypeTool } from './typeTool';
-export { createScrollTool } from './scrollTool';
-export { createSliderTool } from './sliderTool';
-export { createPickerTool } from './pickerTool';
-export { createDatePickerTool } from './datePickerTool';
-export { createKeyboardTool } from './keyboardTool';
-export { createGuideTool } from './guideTool';
-export { createSimplifyTool } from './simplifyTool';
-export { createRestoreTool } from './restoreTool';
-
-export type { AgentTool, ToolContext, ToolParameter } from './types';