createNavaiMobileAgentRuntime

import { createNavaiMobileAgentRuntime } from '@navai/voice-mobile';

import { createNavaiMobileAgentRuntime } from '@navai/voice-mobile';

const agentRuntime = createNavaiMobileAgentRuntime({
  navigate: (path) => navigation.navigate(path),
  routes: [
    { name: 'home', path: '/home', description: 'Home screen' },
    { name: 'profile', path: '/profile', description: 'User profile' }
  ],
  functionsRegistry,
  backendFunctions: [
    { name: 'get_weather', description: 'Get current weather' }
  ],
  executeBackendFunction: async (input) => {
    return await backendClient.executeFunction(input);
  }
});

// Use in realtime session
await session.sendRealtimeEvent({
  type: 'session.update',
  session: {
    instructions: agentRuntime.session.instructions,
    tools: agentRuntime.session.tools,
    tool_choice: 'auto'
  }
});

// Execute tool calls
const result = await agentRuntime.executeToolCall({
  name: 'navigate_to',
  payload: { target: 'profile' }
});

function createNavaiMobileAgentRuntime(
  options: CreateNavaiMobileAgentRuntimeOptions
): NavaiMobileAgentRuntime

{
  "type": "function",
  "name": "navigate_to",
  "description": "Navigate to an allowed route in the current app.",
  "parameters": {
    "type": "object",
    "properties": {
      "target": {
        "type": "string",
        "description": "Route name or route path. Example: perfil, ajustes, /profile, /settings"
      }
    },
    "required": ["target"]
  }
}

{
  "type": "function",
  "name": "execute_app_function",
  "description": "Execute an allowed internal app function by name.",
  "parameters": {
    "type": "object",
    "properties": {
      "function_name": {
        "type": "string",
        "description": "Allowed function name from the list."
      },
      "payload": {
        "anyOf": [
          { "type": "object" },
          { "type": "null" }
        ],
        "description": "Payload object or null. Use payload.args for function arguments."
      }
    },
    "required": ["function_name"]
  }
}

You are a voice assistant embedded in a mobile app.

Allowed routes:
- home (/home)
- profile (/profile, aliases: perfil, usuario)

Allowed app functions:
- get_user_data: Get current user information
- update_settings: Update user settings
- get_weather: Get current weather

Rules:
- The only valid tool names are navigate_to and execute_app_function.
- If user asks to go/open a section, always call navigate_to.
- If user asks to run an internal action, always call execute_app_function.
- Always call a tool before claiming that navigation/action was completed.
- Do not repeat greetings or the same sentence multiple times.
...

// Input
{
  name: 'navigate_to',
  payload: { target: 'profile' }
}

// Behavior
1. Resolve route path from name/path/synonym
2. Call navigate(resolvedPath)
3. Return { ok: true, path: '/profile' }

// If route not found
{ ok: false, error: 'Unknown or disallowed route.' }

// Input
{
  name: 'execute_app_function',
  payload: {
    function_name: 'get_user_data',
    payload: { userId: '123' }
  }
}

// Behavior
1. Look up function in mobile registry
2. Execute function with payload and context
3. Return result:
{
  ok: true,
  function_name: 'get_user_data',
  source: 'mobile',
  result: { name: 'John', email: '[email protected]' }
}

// On error
{
  ok: false,
  function_name: 'get_user_data',
  error: 'Function execution failed.',
  details: 'Error message'
}

import { createNavaiMobileAgentRuntime, loadNavaiFunctions } from '@navai/voice-mobile';

const functionsRegistry = await loadNavaiFunctions({
  'src/ai/functions/weather.ts': () => import('./functions/weather'),
  'src/ai/functions/user.ts': () => import('./functions/user')
});

const agentRuntime = createNavaiMobileAgentRuntime({
  navigate: (path) => navigation.navigate(path),
  routes: APP_ROUTES,
  functionsRegistry,
  baseInstructions: 'You are a helpful assistant in our mobile app.'
});

const agentRuntime = createNavaiMobileAgentRuntime({
  navigate: (path) => navigation.navigate(path),
  routes,
  functionsRegistry,
  backendFunctions: [
    { name: 'get_weather', description: 'Get weather for a location' },
    { name: 'send_email', description: 'Send an email' }
  ],
  executeBackendFunction: async ({ functionName, payload }) => {
    const response = await fetch('/api/functions/execute', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ function_name: functionName, payload })
    });
    return response.json();
  }
});

const agentRuntime = createNavaiMobileAgentRuntime(options);

if (agentRuntime.warnings.length > 0) {
  console.warn('Agent runtime warnings:');
  agentRuntime.warnings.forEach(warning => {
    console.warn(warning);
  });
}

import { extractNavaiRealtimeToolCalls } from '@navai/voice-mobile';

const toolCalls = extractNavaiRealtimeToolCalls(realtimeEvent);
// Returns: NavaiRealtimeToolCall[]

import { buildNavaiRealtimeToolResultEvents } from '@navai/voice-mobile';

const events = buildNavaiRealtimeToolResultEvents({
  callId: 'call_123',
  output: { ok: true, result: 'Success' }
});

for (const event of events) {
  await session.sendRealtimeEvent(event);
}