@mobileai/react-native 0.9.26 → 0.9.28

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

@@ -61,7 +61,9 @@ export function checkRageClick(label, telemetry) {
   const matching = recentTaps.filter(t => t.label === label && t.screen === currentScreen && now - t.ts < RAGE_WINDOW_MS);
   if (matching.length >= RAGE_THRESHOLD) {
     telemetry.track('rage_click', {
+      canonical_type: 'rage_click_detected',
       label,
+      element_label: label,
       count: matching.length,
       screen: currentScreen
     });
@@ -77,55 +79,63 @@ export function checkRageClick(label, telemetry) {
  * @returns A descriptive label string for the tapped element
  */
 export function extractTouchLabel(event) {
-  // Try accessible properties first (most reliable)
   const target = event?.nativeEvent?.target;
   if (!target) return 'Unknown Element';
-
-  // React Native internal: _targetInst (synthetic event Fiber ref)
-  // We can walk the Fiber tree from the target to find text
   try {
-    // Strategy 1: Fiber from the SyntheticEvent (works in dev and production RN >= 0.60)
-    // Strategy 2: Walk up the Fiber tree from the touched element via DevTools hook
     let fiber = event?._targetInst || getFiberFromNativeTag(target);
     if (fiber) {
-      // Walk up looking for text content or accessibility labels
       let current = fiber;
       let depth = 0;
-      const MAX_DEPTH = 10;
+      const MAX_DEPTH = 12;
+      let bestLabel = null;
+      let detectedRole = null;
       while (current && depth < MAX_DEPTH) {
-        // Check for accessibilityLabel
-        if (current.memoizedProps?.accessibilityLabel) {
-          return current.memoizedProps.accessibilityLabel;
-        }
-
-        // Check for testID
-        if (current.memoizedProps?.testID) {
-          return current.memoizedProps.testID;
+        // 1. Detect Component Type Context
+        if (!detectedRole) {
+          if (current.memoizedProps?.accessibilityRole) {
+            detectedRole = current.memoizedProps.accessibilityRole;
+          } else if (current.memoizedProps?.onValueChange && typeof current.memoizedProps?.value === 'boolean') {
+            detectedRole = 'Toggle/Switch';
+          } else if (current.memoizedProps?.onChangeText) {
+            detectedRole = 'TextInput';
+          } else if (current.memoizedProps?.onPress) {
+            detectedRole = 'Button';
+          } else if (current.type?.name || current.type?.displayName) {
+            const name = current.type.name || current.type.displayName;
+            if (typeof name === 'string' && name.length > 2 && !name.toLowerCase().includes('wrapper') && !name.startsWith('RCT')) {
+              detectedRole = name;
+            }
+          }
         }
 
-        // Check for title (Button component)
-        if (current.memoizedProps?.title) {
-          return current.memoizedProps.title;
-        }
-
-        // Check for placeholder (TextInput)
-        if (current.memoizedProps?.placeholder) {
-          return `Input: ${current.memoizedProps.placeholder}`;
-        }
-
-        // Check if this is a Text node with children string
-        if (typeof current.memoizedProps?.children === 'string' && current.memoizedProps.children.trim()) {
-          return current.memoizedProps.children.trim();
-        }
-
-        // Check for nested text in children array
-        if (Array.isArray(current.memoizedProps?.children)) {
-          const textChild = findTextInChildren(current.memoizedProps.children);
-          if (textChild) return textChild;
+        // 2. Detect String Label Output
+        if (!bestLabel) {
+          if (current.memoizedProps?.accessibilityLabel) {
+            bestLabel = current.memoizedProps.accessibilityLabel;
+          } else if (current.memoizedProps?.testID) {
+            bestLabel = current.memoizedProps.testID;
+          } else if (current.memoizedProps?.title) {
+            bestLabel = current.memoizedProps.title;
+          } else if (current.memoizedProps?.placeholder) {
+            bestLabel = current.memoizedProps.placeholder;
+          } else if (typeof current.memoizedProps?.children === 'string' && current.memoizedProps.children.trim()) {
+            bestLabel = current.memoizedProps.children.trim();
+          } else if (Array.isArray(current.memoizedProps?.children)) {
+            bestLabel = findTextInChildren(current.memoizedProps.children);
+          } else if (current.memoizedProps?.children && typeof current.memoizedProps.children === 'object') {
+            bestLabel = findTextInChildren([current.memoizedProps.children]);
+          }
         }
         current = current.return;
         depth++;
       }
+      if (bestLabel) {
+        if (detectedRole && detectedRole.toLowerCase() !== 'text' && detectedRole.toLowerCase() !== 'view') {
+          const formattedRole = detectedRole.charAt(0).toUpperCase() + detectedRole.slice(1);
+          return `[${formattedRole}] ${bestLabel}`;
+        }
+        return bestLabel;
+      }
     }
   } catch {
     // Fiber access failed — fall back gracefully

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/tapTool.js

@@ -5,8 +5,9 @@
  *
  * Strategies (in priority order):
  * 1. Switch → onValueChange (toggle)
- * 2. Direct onPress on element
- * 3. Bubble up fiber tree to find parent onPress (max 5 levels)
+ * 2. Radio → onPress / onValueChange / parent radio-group handler
+ * 3. Direct onPress on element
+ * 4. Bubble up fiber tree to find parent onPress (max 5 levels)
  *
  * Includes Maestro-style tap verification:
  * - Captures element count + screen name before tap
@@ -16,10 +17,43 @@
 import { walkFiberTree } from "../core/FiberTreeWalker.js";
 import { getParent, getProps } from "../core/FiberAdapter.js";
 import { dismissAlert } from "../core/NativeAlertInterceptor.js";
+function isScalarSelectionValue(value) {
+  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function getRadioSelectionPayload(props) {
+  return isScalarSelectionValue(props.value) ? props.value : true;
+}
+function getRadioSelectionHandler(props) {
+  if (typeof props.onValueChange === 'function') {
+    return {
+      channel: 'onValueChange',
+      handler: props.onValueChange
+    };
+  }
+  if (typeof props.onCheckedChange === 'function') {
+    return {
+      channel: 'onCheckedChange',
+      handler: props.onCheckedChange
+    };
+  }
+  if (typeof props.onChange === 'function') {
+    return {
+      channel: 'onChange',
+      handler: props.onChange
+    };
+  }
+  if (typeof props.onSelect === 'function') {
+    return {
+      channel: 'onSelect',
+      handler: props.onSelect
+    };
+  }
+  return null;
+}
 export function createTapTool(context) {
   return {
     name: 'tap',
-    description: 'Tap an interactive element by its index. Works universally on buttons, switches, and custom components.',
+    description: 'Tap an interactive element by its index. Works universally on buttons, radios, switches, and custom components.',
     parameters: {
       index: {
         type: 'number',
@@ -57,7 +91,31 @@ export function createTapTool(context) {
         }
       }
 
-      // Strategy 2: Direct onPress
+      // Strategy 2: Radio → own selection handler
+      if (element.type === 'radio') {
+        const radioPayload = getRadioSelectionPayload(element.props);
+        const ownSelectionHandler = getRadioSelectionHandler(element.props);
+        if (element.props.onPress) {
+          try {
+            element.props.onPress();
+            await new Promise(resolve => setTimeout(resolve, 500));
+            return `✅ Selected [${args.index}] "${element.label}"`;
+          } catch (error) {
+            return `❌ Error selecting [${args.index}]: ${error.message}`;
+          }
+        }
+        if (ownSelectionHandler) {
+          try {
+            ownSelectionHandler.handler(radioPayload);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            return `✅ Selected [${args.index}] "${element.label}"`;
+          } catch (error) {
+            return `❌ Error selecting [${args.index}]: ${error.message}`;
+          }
+        }
+      }
+
+      // Strategy 3: Direct onPress
       if (element.props.onPress) {
         try {
           element.props.onPress();
@@ -81,9 +139,10 @@ export function createTapTool(context) {
         }
       }
 
-      // Strategy 3: Bubble up fiber tree (like RNTL's findEventHandler)
+      // Strategy 4: Bubble up fiber tree (like RNTL's findEventHandler)
       let fiber = getParent(element.fiberNode);
       let bubbleDepth = 0;
+      const radioPayload = element.type === 'radio' ? getRadioSelectionPayload(element.props) : undefined;
       while (fiber && bubbleDepth < 5) {
         const parentProps = getProps(fiber);
         if (parentProps.onPress && typeof parentProps.onPress === 'function') {
@@ -95,10 +154,22 @@ export function createTapTool(context) {
             return `❌ Error tapping parent of [${args.index}]: ${error.message}`;
           }
         }
+        if (element.type === 'radio') {
+          const parentSelectionHandler = getRadioSelectionHandler(parentProps);
+          if (parentSelectionHandler) {
+            try {
+              parentSelectionHandler.handler(radioPayload);
+              await new Promise(resolve => setTimeout(resolve, 500));
+              return `✅ Selected [${args.index}] "${element.label}" via parent group`;
+            } catch (error) {
+              return `❌ Error selecting [${args.index}] via parent group: ${error.message}`;
+            }
+          }
+        }
         fiber = getParent(fiber);
         bubbleDepth++;
       }
-      return `❌ Element [${args.index}] "${element.label}" has no tap handler (no onPress or onValueChange found).`;
+      return `❌ Element [${args.index}] "${element.label}" has no tap handler (no onPress, onValueChange, or radio selection handler found).`;
     }
   };
 }

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,14 +23,30 @@ export declare class AgentRuntime {
     private uiControlOverride?;
     private lastDehydratedRoot;
     private currentTraceId;
+    private currentUserGoal;
+    private verifierProvider;
+    private outcomeVerifier;
+    private pendingCriticalVerification;
     private originalErrorHandler;
     private lastSuppressedError;
     private graceTimer;
     private originalReportErrorsAsExceptions;
-    private appActionApproved;
+    private appActionApprovalScope;
+    private appActionApprovalSource;
     private static readonly APP_ACTION_TOOLS;
     getConfig(): AgentConfig;
+    private resetAppActionApproval;
+    private grantWorkflowApproval;
+    private hasWorkflowApproval;
+    private debugLogChunked;
+    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).