@mobileai/react-native 0.9.27 → 0.9.29

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

@@ -0,0 +1,187 @@
+"use strict";
+
+const GENERIC_LABELS = new Set(['button', 'buttons', 'component', 'components', 'container', 'containers', 'content', 'cta', 'item', 'items', 'label', 'labels', 'root', 'row', 'rows', 'screen', 'screens', 'text', 'texts', 'title', 'titles', 'unknown', 'value', 'values', 'view', 'views', 'wrapper', 'wrappers']);
+const GENERIC_IDENTIFIER_TOKENS = new Set(['btn', 'button', 'card', 'cell', 'component', 'container', 'content', 'cta', 'icon', 'input', 'item', 'label', 'node', 'pressable', 'root', 'row', 'screen', 'target', 'text', 'tile', 'toggle', 'view', 'wrapper']);
+const INTERNAL_NAME_PATTERNS = [/^RCT[A-Z]/, /^React/, /^TextImpl/i, /^Android/i, /^UI[A-Z]/, /^RN[A-Z]/, /^Virtualized/i, /^ScrollResponder$/i, /^Animated(Component|.*Wrapper)?$/i, /^Touchable[A-Z]/, /^Pressable$/i, /^View$/i, /^Text$/i, /^Modal$/i, /Legacy/i, /Wrapper/i, /Context$/i, /Provider$/i];
+function normalizeWhitespace(value) {
+  if (!value) return '';
+  return String(value).replace(/\s+/g, ' ').trim();
+}
+function toTitleCase(value) {
+  return value.split(/\s+/).filter(Boolean).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
+}
+function humanizeIdentifier(value) {
+  const humanized = value.replace(/^icon:/i, '').replace(/[_./-]+/g, ' ').replace(/([a-z])([A-Z])/g, '$1 $2').replace(/\b\d+\b/g, ' ').replace(/\s+/g, ' ').trim();
+  return toTitleCase(humanized);
+}
+function stripDecorators(value) {
+  return value.replace(/^\[[^\]]+\]\s*/g, '').replace(/^["'`]+|["'`]+$/g, '').trim();
+}
+function looksInternal(value) {
+  return INTERNAL_NAME_PATTERNS.some(pattern => pattern.test(value));
+}
+function isLowSignalValue(value) {
+  const lowered = value.toLowerCase();
+  return GENERIC_LABELS.has(lowered);
+}
+function sanitizeLabelValue(rawValue, source) {
+  let normalized = normalizeWhitespace(rawValue);
+  if (!normalized) return null;
+  normalized = stripDecorators(normalized);
+  if (!normalized) return null;
+  if (source === 'test-id' || source === 'icon' || source === 'context') {
+    normalized = humanizeIdentifier(normalized);
+  }
+  if (!normalized) return null;
+  if (normalized.length > 80) return null;
+  if (looksInternal(normalized)) return null;
+  const words = normalized.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return null;
+  if (words.length === 1) {
+    const token = words[0].toLowerCase();
+    if (GENERIC_IDENTIFIER_TOKENS.has(token) || GENERIC_LABELS.has(token)) {
+      return null;
+    }
+  }
+  if (isLowSignalValue(normalized)) return null;
+  return normalized;
+}
+function scoreAnalyticsLabel(label, source, isInteractiveContext = false) {
+  let score = 0;
+  const words = label.split(/\s+/).filter(Boolean);
+  if (source === 'accessibility') score += 95;
+  if (source === 'deep-text') score += 78;
+  if (source === 'sibling-text') score += 64;
+  if (source === 'title') score += 56;
+  if (source === 'placeholder') score += 42;
+  if (source === 'context') score += 12;
+  if (source === 'icon') score -= 8;
+  if (source === 'test-id') score -= 14;
+  if (isInteractiveContext) score += 18;
+  if (words.length >= 2 && words.length <= 6) score += 20;else if (words.length === 1) score += 4;
+  if (label.length >= 4 && label.length <= 36) score += 18;else if (label.length > 56) score -= 20;
+  if (/^[A-Z]/.test(label)) score += 8;
+  if (/[A-Za-z]/.test(label) && !/[_./]/.test(label)) score += 10;
+  return score;
+}
+export function getFallbackAnalyticsLabel(elementKind) {
+  switch (elementKind) {
+    case 'button':
+      return 'Primary action';
+    case 'text_input':
+      return 'Text input';
+    case 'toggle':
+      return 'Toggle';
+    case 'picker':
+      return 'Picker';
+    case 'slider':
+      return 'Slider';
+    case 'link':
+      return 'Link';
+    case 'tab':
+      return 'Tab';
+    case 'list_item':
+      return 'List item';
+    case 'image':
+      return 'Image';
+    case 'icon':
+      return 'Icon';
+    case 'text':
+      return 'Text';
+    case 'card':
+      return 'Card';
+    case 'modal':
+      return 'Modal';
+    case 'sheet':
+      return 'Bottom sheet';
+    case 'scroll_area':
+      return 'Scrollable area';
+    default:
+      return null;
+  }
+}
+export function getAnalyticsElementKind(elementType) {
+  switch (elementType) {
+    case 'pressable':
+    case 'radio':
+    case 'button':
+    case 'checkbox':
+      return 'button';
+    case 'link':
+      return 'link';
+    case 'tab':
+    case 'tabbar':
+      return 'tab';
+    case 'listitem':
+    case 'list-item':
+    case 'menuitem':
+      return 'list_item';
+    case 'text-input':
+    case 'text_input':
+    case 'textinput':
+      return 'text_input';
+    case 'switch':
+    case 'toggle':
+      return 'toggle';
+    case 'slider':
+      return 'slider';
+    case 'picker':
+      return 'picker';
+    case 'date-picker':
+    case 'select':
+    case 'dropdown':
+      return 'picker';
+    case 'image':
+    case 'imagebutton':
+      return 'image';
+    case 'icon':
+      return 'icon';
+    case 'text':
+    case 'label':
+    case 'header':
+      return 'text';
+    case 'card':
+      return 'card';
+    case 'modal':
+      return 'modal';
+    case 'sheet':
+    case 'bottomsheet':
+      return 'sheet';
+    case 'scrollable':
+    case 'scrollview':
+    case 'flatlist':
+    case 'sectionlist':
+    case 'adjustable':
+      return 'scroll_area';
+    default:
+      return 'unknown';
+  }
+}
+export function chooseBestAnalyticsTarget(candidates, elementKind) {
+  let best;
+  for (const candidate of candidates) {
+    const label = sanitizeLabelValue(candidate.text, candidate.source);
+    if (!label) continue;
+    const score = scoreAnalyticsLabel(label, candidate.source, candidate.isInteractiveContext === true);
+    if (!best || score > best.score) {
+      best = {
+        label,
+        score
+      };
+    }
+  }
+  if (best) {
+    const labelConfidence = best.score >= 100 ? 'high' : 'low';
+    return {
+      label: best.label,
+      elementKind,
+      labelConfidence
+    };
+  }
+  return {
+    label: getFallbackAnalyticsLabel(elementKind),
+    elementKind,
+    labelConfidence: 'low'
+  };
+}
+//# sourceMappingURL=analyticsLabeling.js.map

package/lib/module/specs/FloatingOverlayNativeComponent.ts

@@ -11,9 +11,15 @@
  */
 
 import type { ViewProps } from 'react-native';
+import type { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
 
-export interface NativeProps extends ViewProps {}
+export interface NativeProps extends ViewProps {
+  windowX?: Int32;
+  windowY?: Int32;
+  windowWidth?: Int32;
+  windowHeight?: Int32;
+}
 
 // Codegen reads this export to generate the native component interfaces.
 export default codegenNativeComponent<NativeProps>('MobileAIFloatingOverlay');

package/lib/module/support/supportPrompt.js

@@ -6,12 +6,16 @@
  * Uses POSITIVE framing (what TO DO) instead of negative rules (per user's prompt engineering rules).
  */
 
+import { buildSupportStylePrompt, resolveSupportStyle } from "./supportStyle.js";
+
 /**
  * Build the support mode system prompt addition.
  * This gets appended to the main system prompt when support mode is active.
  */
 export function buildSupportPrompt(config) {
   const parts = [];
+  const supportStyle = config.persona?.preset ?? 'warm-concise';
+  const stylePreset = resolveSupportStyle(supportStyle);
 
   // Core support persona
   parts.push(`
@@ -20,18 +24,26 @@ export function buildSupportPrompt(config) {
 You are a helpful customer support assistant representing the company. Your primary goal is to RESOLVE the user's issue through empathetic conversation. App navigation is a tool you USE when needed, not the first thing you propose.
 
 ### Identity & Context
-Adopt the persona of a dedicated human customer support team member. Speak on behalf of the company as an organization with human operational timelines.
+Speak like a calm, caring human teammate. Sound emotionally safe, patient, and kind in every reply.
+
+Treat any question about "you" or "when you will reply" as referring to the company's real support process, but explain that in warm, human language rather than corporate language. Reassure the user naturally, and make them feel cared for while you work on the issue.
 
-Base all discussions regarding processing, reviews, resolutions, and response expectations on standard operational business timelines. Treat the conversational context holistically—assume any user questions about "you" or "when you will reply" refer to the company's human support staff processing their real-world request. Express empathy naturally, and assure the user that the operational team is handling their ticket promptly.
+### Gentle Customer Care
+- Lead with warmth before action.
+- Make the user feel supported, not processed.
+- Even when you need details or need to say no, keep your wording soft and respectful.
+- Avoid cold, legalistic, commanding, or overly procedural phrasing.
+- If something failed, acknowledge the frustration first, then guide the user gently toward the next step.
 
 ### Support Resolution Protocol (HEARD)
 Follow this sequence. Exhaust each level before moving to the next:
 
-1. HEAR: Listen actively. Paraphrase the problem back to confirm you understand. Ask specific
-   clarifying questions (which order? when? what happened exactly?).
+1. HEAR: Listen actively. Paraphrase the problem back to confirm you understand. Ask gentle,
+   specific clarifying questions (for example: which order, when it happened, and what went wrong).
 
 2. EMPATHIZE: Acknowledge the user's feelings with sincerity. Use their name if available.
-   Say "I understand how frustrating this must be" — not "I see you have an issue."
+   Use a genuine, varied phrase — for example: "I hear you", "That makes total sense", "I'm sorry about that".
+   Avoid scripted lines like "I understand how frustrating this must be" — they sound hollow.
    Take responsibility where appropriate.
 
 3. ANSWER: Search the knowledge base (query_knowledge) for relevant policies, FAQs, and procedures.
@@ -49,6 +61,7 @@ Follow this sequence. Exhaust each level before moving to the next:
 5. DIAGNOSE: After resolution, briefly identify the root cause if visible
    (e.g. "It looks like the delivery partner marked it as delivered prematurely").
    Ask the user if the issue is fully resolved before calling done().`);
+  parts.push(buildSupportStylePrompt(supportStyle));
   parts.push(`
 ### Consent and Liability Guard
 - Treat money movement, subscription cancellation, deletion, final submission, and account/security changes as high-risk actions.
@@ -68,7 +81,7 @@ Follow this sequence. Exhaust each level before moving to the next:
 ### Progress Communication
 When executing a multi-step resolution, you must communicate your progress to keep the user informed.
 - Do NOT execute more than 2 tools in silence.
-- Use the 'ask_user' tool to say phrases like "I am checking your account details now..." or "Just a moment while I pull up that information."
+- Use the 'ask_user' tool to say phrases like "Let me check that for you now." or "Just a moment while I pull that up."
 - Never leave the user waiting in silence during complex operations.`);
 
   // Agent Persona
@@ -80,9 +93,11 @@ When executing a multi-step resolution, you must communicate your progress to ke
     } = config.persona;
     let personaStr = `\n### AI Persona & Tone\n`;
     if (agentName) personaStr += `- Your name is ${agentName}. Introduce yourself if appropriate.\n`;
-    if (tone) personaStr += `- Maintain a ${tone} tone throughout the conversation.\n`;
+    personaStr += `- Maintain a ${tone || stylePreset.tone} tone throughout the conversation.\n`;
     if (signOff) personaStr += `- When resolving an issue, sign off with: "${signOff}".\n`;
     parts.push(personaStr);
+  } else {
+    parts.push(`\n### AI Persona & Tone\n- Maintain a ${stylePreset.tone} tone throughout the conversation.\n`);
   }
 
   // Custom system context from the consumer

package/lib/module/support/supportStyle.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const PRESETS = {
+  /**
+   * Default — calm, human, to the point.
+   * Sounds like a competent teammate who genuinely cares, not a scripted bot.
+   */
+  'warm-concise': {
+    tone: 'calm, warm, and direct',
+    prompt: `
+### Support Style: Warm Concise
+- Sound like a calm human who is good at their job and genuinely wants to help.
+- Acknowledge the situation once — then focus on solving it. Do not repeat the same empathy phrase twice in a conversation.
+- Keep each message short and scannable (1-3 sentences). Users are on mobile.
+- Use natural language: say "Got it" not "I understand your concern"; say "Let me check" not "I will certainly look into that for you".
+- When something went wrong, own it simply and move on: "That shouldn't have happened — let me fix it."
+- Sound confident and in control. Users trust agents who know what to do.
+- Vary your acknowledgment phrases naturally: "I hear you", "Got it", "That makes sense", "Let's sort this out", "On it" — never repeat the same one twice in a row.`
+  },
+  /**
+   * WOW Service — warm, proactive, surprise-and-delight energy.
+   * Best for consumer apps where the brand identity is warm and friendly.
+   */
+  'wow-service': {
+    tone: 'warm, proactive, and genuinely service-first',
+    prompt: `
+### Support Style: WOW Service
+- Deliver genuinely memorable service — through helpfulness and warmth, not adjectives.
+- Be human and real: a little personality is good, but stay grounded. Never be performatively cheerful.
+- Own mistakes fast and recover without excuses: "That's on us — here's what I'll do."
+- Look for small ways to go above and beyond after resolving the core issue.
+- Never joke through a serious problem. Match the user's energy — if they're frustrated, be calm and direct, not upbeat.`
+  },
+  /**
+   * Neutral Professional — composed, clear, efficient.
+   * Best for fintech, healthcare, or enterprise apps.
+   */
+  'neutral-professional': {
+    tone: 'clear, composed, and respectfully direct',
+    prompt: `
+### Support Style: Neutral Professional
+- Prioritize clarity and efficiency above all. Every sentence should move the conversation forward.
+- Stay warm but understated — acknowledge the issue, then get straight to the solution.
+- Use plain, jargon-free language. Short sentences. No exclamation marks.
+- Be transparent about what you know, what you're checking, and what the next step is.
+- Avoid casual phrases or emotional flourish — composed professionalism builds trust here.`
+  }
+};
+export function resolveSupportStyle(style) {
+  return PRESETS[style ?? 'warm-concise'];
+}
+export function buildSupportStylePrompt(style) {
+  return resolveSupportStyle(style).prompt;
+}
+//# sourceMappingURL=supportStyle.js.map

package/lib/module/support/types.js

@@ -1,2 +1,4 @@
 "use strict";
+
+export {};
 //# sourceMappingURL=types.js.map

package/lib/module/tools/typeTool.js

@@ -85,6 +85,21 @@ export function createTypeTool(context) {
         }
       }
 
+      // ── Strategy 1b: inner onChangeText (for wrapped 3rd-party inputs) ────
+      if (fiberNode) {
+        const innerTextInputFiber = findFiberNode(fiberNode, n => typeof getProps(n)?.onChangeText === 'function', 15);
+        if (innerTextInputFiber) {
+          const innerProps = getProps(innerTextInputFiber);
+          try {
+            innerProps.onChangeText(args.text);
+            await new Promise(resolve => setTimeout(resolve, 300));
+            return `✅ Typed "${args.text}" into wrapped component [${args.index}] "${label}"`;
+          } catch (err) {
+            console.warn(`[Agent] Inner onChangeText failed for element ${args.index}:`, err);
+          }
+        }
+      }
+
       // ── Strategy 2: uncontrolled — find native onChange + setNativeProps ──
       // For TextInputs with defaultValue only.
       // We need BOTH:
@@ -106,10 +121,12 @@ export function createTypeTool(context) {
         if (onChange || nativeInstance) {
           try {
             // Step 1: Update visual text in native view
+            let visualUpdated = false;
             if (nativeInstance && typeof nativeInstance.setNativeProps === 'function') {
               nativeInstance.setNativeProps({
                 text: args.text
               });
+              visualUpdated = true;
             }
 
             // Step 2: Notify React's internal onChange so lastNativeText stays in sync
@@ -122,6 +139,9 @@ export function createTypeTool(context) {
                 }
               });
             }
+            if (!visualUpdated) {
+              return `❌ Type failed: Cannot locate native host node to explicitly inject visual text into uncontrolled element [${args.index}].`;
+            }
             await new Promise(resolve => setTimeout(resolve, 300));
             return `✅ Typed "${args.text}" into [${args.index}] "${label}"`;
           } catch (err) {

package/lib/module/utils/humanizeScreenName.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/**
+ * Transforms raw navigation route names into human-readable labels.
+ * Designed to handle both Expo Router (file-based) and React Navigation conventions.
+ */
+export function humanizeScreenName(route) {
+  if (!route) return '';
+  let name = route;
+
+  // 1. Strip Expo Router groups: e.g., "(tabs)/index" -> "index"
+  // Keep replacing in case of nested groups like "(app)/(tabs)/home"
+  name = name.replace(/\([^)]+\)\//g, '');
+
+  // 2. Skip internal layout and catch-all routes
+  if (name.includes('_layout') || name.includes('[...')) {
+    return '';
+  }
+
+  // 3. Handle nested indexes: "settings/index" -> "settings"
+  if (name.endsWith('/index')) {
+    name = name.replace(/\/index$/, '');
+  }
+
+  // 4. Special case root index
+  if (name === 'index') {
+    return 'Home';
+  }
+
+  // 5. Strip dynamic brackets: "[id]" -> "id"
+  name = name.replace(/\[([^\]]+)\]/g, '$1');
+
+  // Strip leading/trailing slashes just in case
+  name = name.replace(/^\/|\/$/g, '');
+
+  // 6. Split on kebab-case, snake_case, slash, and camelCase boundaries
+  // e.g., "product-details" -> "product details"
+  // e.g., "order_history" -> "order history"
+  // e.g., "UserProfile" -> "User Profile"
+  // e.g., "settings/profile" -> "settings profile"
+  name = name.replace(/[-_/]/g, ' ')
+  // Insert a space before all caps (but not at the start) to separate camelCase/PascalCase
+  .replace(/([a-z])([A-Z])/g, '$1 $2');
+
+  // 7. Title-case each word and clean extra spaces
+  name = name.split(/\s+/).filter(Boolean).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
+  return name;
+}
+//# sourceMappingURL=humanizeScreenName.js.map

package/lib/typescript/src/components/AIAgent.d.ts

@@ -9,7 +9,7 @@
  */
 import React from 'react';
 import type { AIConsentConfig } from './AIConsentDialog';
-import type { ExecutionResult, ToolDefinition, AgentStep, TokenUsage, KnowledgeBaseConfig, ChatBarTheme, AIProviderName, ScreenMap, ProactiveHelpConfig, InteractionMode, CustomerSuccessConfig, OnboardingConfig } from '../core/types';
+import type { ExecutionResult, ToolDefinition, AgentStep, TokenUsage, KnowledgeBaseConfig, ChatBarTheme, AIProviderName, ScreenMap, ProactiveHelpConfig, InteractionMode, CustomerSuccessConfig, OnboardingConfig, VerifierConfig, SupportStyle } from '../core/types';
 interface AIAgentProps {
     /**
      * API key (for local prototyping only).
@@ -41,6 +41,10 @@ interface AIAgentProps {
     voiceProxyHeaders?: Record<string, string>;
     /** LLM model name (provider-specific) */
     model?: string;
+    /** Support personality preset. Default: 'warm-concise'. */
+    supportStyle?: SupportStyle;
+    /** Optional outcome verifier configuration for critical actions. */
+    verifier?: VerifierConfig;
     /** Navigation container ref (from useNavigationContainerRef) */
     navRef?: any;
     /** Max agent steps per request */
@@ -216,6 +220,6 @@ interface AIAgentProps {
      */
     consent?: AIConsentConfig;
 }
-export declare function AIAgent({ apiKey, proxyUrl, proxyHeaders, voiceProxyUrl, voiceProxyHeaders, provider: providerName, model, navRef, maxSteps, showChatBar, children, onResult, interactiveBlacklist, interactiveWhitelist, onBeforeStep, onAfterStep, onBeforeTask, onAfterTask, transformScreenContent, customTools, instructions, stepDelay, mcpServerUrl, router, pathname, enableVoice, onTokenUsage, debug, knowledgeBase, knowledgeMaxTokens, enableUIControl, accentColor, theme, screenMap, useScreenMap, maxTokenBudget, maxCostUSD, analyticsKey, analyticsProxyUrl, analyticsProxyHeaders, proactiveHelp, userContext, pushToken, pushTokenType, interactionMode, showDiscoveryTooltip: showDiscoveryTooltipProp, discoveryTooltipMessage, customerSuccess, onboarding, consent, }: AIAgentProps): import("react/jsx-runtime").JSX.Element;
+export declare function AIAgent({ apiKey, proxyUrl, proxyHeaders, voiceProxyUrl, voiceProxyHeaders, provider: providerName, model, supportStyle, verifier, navRef, maxSteps, showChatBar, children, onResult, interactiveBlacklist, interactiveWhitelist, onBeforeStep, onAfterStep, onBeforeTask, onAfterTask, transformScreenContent, customTools, instructions, stepDelay, mcpServerUrl, router, pathname, enableVoice, onTokenUsage, debug, knowledgeBase, knowledgeMaxTokens, enableUIControl, accentColor, theme, screenMap, useScreenMap, maxTokenBudget, maxCostUSD, analyticsKey, analyticsProxyUrl, analyticsProxyHeaders, proactiveHelp, userContext, pushToken, pushTokenType, interactionMode, showDiscoveryTooltip: showDiscoveryTooltipProp, discoveryTooltipMessage, customerSuccess, onboarding, consent, }: AIAgentProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=AIAgent.d.ts.map

package/lib/typescript/src/components/AgentChatBar.d.ts

@@ -7,6 +7,7 @@ import type { ExecutionResult, AgentMode, ChatBarTheme, AIMessage, ConversationS
 import type { SupportTicket } from '../support/types';
 interface AgentChatBarProps {
     onSend: (message: string) => void;
+    onCancel?: () => void;
     isThinking: boolean;
     statusText?: string;
     lastResult: ExecutionResult | null;
@@ -67,7 +68,20 @@ interface AgentChatBarProps {
     onNewConversation?: () => void;
     pendingApprovalQuestion?: string | null;
     onPendingApprovalAction?: (action: 'approve' | 'reject') => void;
+    renderMode?: 'default' | 'android-native-window';
+    onWindowMetricsChange?: (metrics: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
+    windowMetrics?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
 }
-export declare function AgentChatBar({ onSend, isThinking, statusText, lastResult, language, availableModes, mode, onModeChange, onMicToggle, onSpeakerToggle, isMicActive, isSpeakerMuted, isAISpeaking, isVoiceConnected, onStopSession, theme, tickets, selectedTicketId, onTicketSelect, autoExpandTrigger, unreadCounts, totalUnread, showDiscoveryTooltip, discoveryTooltipMessage, onTooltipDismiss, chatMessages, conversations, isLoadingHistory, onConversationSelect, onNewConversation, pendingApprovalQuestion, onPendingApprovalAction, }: AgentChatBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentChatBar({ onSend, onCancel, isThinking, statusText, lastResult, language, availableModes, mode, onModeChange, onMicToggle, onSpeakerToggle, isMicActive, isSpeakerMuted, isAISpeaking, isVoiceConnected, onStopSession, theme, tickets, selectedTicketId, onTicketSelect, autoExpandTrigger, unreadCounts, totalUnread, showDiscoveryTooltip, discoveryTooltipMessage, onTooltipDismiss, chatMessages, conversations, isLoadingHistory, onConversationSelect, onNewConversation, pendingApprovalQuestion, onPendingApprovalAction, renderMode, onWindowMetricsChange, windowMetrics, }: AgentChatBarProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=AgentChatBar.d.ts.map

package/lib/typescript/src/components/FloatingOverlayWrapper.d.ts

@@ -9,13 +9,10 @@
  *      Renders ABOVE all native Modals, system alerts, and navigation chrome.
  *   2. Falls back to plain View if react-native-screens is not installed.
  *
- * Android (both Old and New Architecture):
- *   1. Native `MobileAIFloatingOverlay` ViewManager (bundled in this library).
- *      Creates a Dialog window with TYPE_APPLICATION_PANEL (z=1000),
- *      above normal app Dialog windows (TYPE_APPLICATION, z=2).
- *      No SYSTEM_ALERT_WINDOW permission needed — scoped to app's own window.
- *   2. Falls back to plain View if the app hasn't been rebuilt after install
- *      (graceful degradation with DEV warning).
+ * Android:
+ *   1. Uses a native panel dialog window when explicit bounds are provided.
+ *      This keeps the floating agent compact and above native modal surfaces.
+ *   2. Falls back to a plain View otherwise.
  *
  * Usage:
  *   <FloatingOverlayWrapper fallbackStyle={styles.floatingLayer}>
@@ -28,24 +25,39 @@
  * Note: FullWindowOverlay on iOS does NOT officially accept style props in its TS definition,
  * but passing StyleSheet.absoluteFill is often necessary to prevent dimensions collapsing conditionally.
  */
+import React from 'react';
 /**
  * True when a native elevated overlay is available on the current platform.
  * Used by AIConsentDialog to decide whether to render as View vs Modal.
  *
  * iOS + react-native-screens installed → true
- * Android + native rebuild done        → true
  * Everything else (fallback)           → false
  */
 export declare const isNativeOverlayActive: boolean;
 interface FloatingOverlayWrapperProps {
     children: React.ReactNode;
+    androidWindowMetrics?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    onAndroidWindowDragEnd?: (metrics: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => void;
     /**
      * Style applied to the View wrapper when no native overlay is available.
      * Ignored on iOS (FullWindowOverlay creates its own UIWindow) and
-     * Android (native module creates its own Dialog window).
+     * Android (native module creates its own panel dialog window).
      */
     fallbackStyle?: any;
 }
-export declare function FloatingOverlayWrapper({ children, fallbackStyle, }: FloatingOverlayWrapperProps): React.ReactElement;
+export interface FloatingOverlayWrapperHandle {
+    setAndroidWindowMetrics: (metrics: NonNullable<FloatingOverlayWrapperProps['androidWindowMetrics']>) => void;
+}
+export declare const FloatingOverlayWrapper: React.ForwardRefExoticComponent<FloatingOverlayWrapperProps & React.RefAttributes<FloatingOverlayWrapperHandle>>;
 export {};
 //# sourceMappingURL=FloatingOverlayWrapper.d.ts.map

package/lib/typescript/src/config/endpoints.d.ts

@@ -8,6 +8,10 @@
  * to route telemetry through your own backend without touching this file.
  */
 export declare const ENDPOINTS: {
+    /** Hosted MobileAI text proxy — used by default when analyticsKey is set */
+    readonly hostedTextProxy: `${string}/api/v1/hosted-proxy/text`;
+    /** Hosted MobileAI voice proxy — used by default when analyticsKey is set */
+    readonly hostedVoiceProxy: `${string}/ws/hosted-proxy/voice`;
     /** Telemetry event ingest — receives batched SDK events */
     readonly telemetryIngest: `${string}/api/v1/events`;
     /** Feature flag sync — fetches remote flags for this analyticsKey */

package/lib/typescript/src/core/AgentRuntime.d.ts

@@ -23,6 +23,10 @@ export declare class AgentRuntime {
     private uiControlOverride?;
     private lastDehydratedRoot;
     private currentTraceId;
+    private currentUserGoal;
+    private verifierProvider;
+    private outcomeVerifier;
+    private pendingCriticalVerification;
     private originalErrorHandler;
     private lastSuppressedError;
     private graceTimer;
@@ -38,6 +42,11 @@ export declare class AgentRuntime {
     private formatInteractiveForDebug;
     private debugScreenSnapshot;
     constructor(provider: AIProvider, config: AgentConfig, rootRef: any, navRef: any);
+    private getVerifier;
+    private createCurrentVerificationSnapshot;
+    private updateCriticalVerification;
+    private maybeStartCriticalVerification;
+    private shouldBlockSuccessCompletion;
     private registerBuiltInTools;
     /**
      * Register only knowledge-assistant tools (no UI control).
@@ -73,9 +82,9 @@ export declare class AgentRuntime {
     /** Maps a tool call to a user-friendly status label for the loading overlay. */
     private getToolStatusLabel;
     /**
-     * Captures the current screen as a base64 JPEG for Gemini vision.
-     * Uses react-native-view-shot as an optional peer dependency.
-     * Returns null if the library is not installed (graceful fallback).
+     * Captures the root component as a base64 JPEG for vision tools.
+     * Uses react-native-view-shot as a required peer dependency.
+     * Returns null only when capture is temporarily unavailable.
      */
     private captureScreenshot;
     /**

package/lib/typescript/src/core/FiberTreeWalker.d.ts

@@ -6,7 +6,7 @@
  * interactive elements by their type and props (onPress, onChangeText, etc.).
  *
  */
-import type { InteractiveElement } from './types';
+import type { InteractiveElement, WireframeSnapshot } from './types';
 export interface WalkConfig {
     /** React refs of elements to exclude */
     interactiveBlacklist?: React.RefObject<any>[];
@@ -64,4 +64,15 @@ export interface ScrollableContainer {
  * For ScrollView: the stateNode IS the native scroll view directly.
  */
 export declare function findScrollableContainers(rootRef: any, screenName?: string): ScrollableContainer[];
+/**
+ * Capture a privacy-safe wireframe of the current screen.
+ *
+ * Performance guarantees:
+ * - Capped at WIREFRAME_MAX_ELEMENTS (50) — enough for wireframe context
+ * - Measures in batches of WIREFRAME_BATCH_SIZE (10), yielding a frame
+ *   between batches so the bridge stays free for user interactions
+ * - The caller (AIAgent) defers this via InteractionManager so it
+ *   never competes with screen transitions or gestures
+ */
+export declare function captureWireframe(rootRef: React.RefObject<any>, config?: WalkConfig): Promise<WireframeSnapshot | null>;
 //# sourceMappingURL=FiberTreeWalker.d.ts.map