Mobile Types Reference

type UseMobileVoiceAgentOptions = {
  runtime: ResolveNavaiMobileApplicationRuntimeConfigResult | null;
  runtimeLoading: boolean;
  runtimeError: string | null;
  navigate: (path: string) => void;
};

type UseMobileVoiceAgentResult = {
  status: 'idle' | 'connecting' | 'connected' | 'error';
  error: string | null;
  isConnecting: boolean;
  isConnected: boolean;
  start: () => Promise<void>;
  stop: () => Promise<void>;
};

type CreateNavaiMobileAgentRuntimeOptions = {
  navigate: (path: string) => void;
  routes: NavaiRoute[];
  functionsRegistry: NavaiFunctionsRegistry;
  backendFunctions?: NavaiBackendFunctionDefinition[];
  executeBackendFunction?: ExecuteNavaiMobileBackendFunction;
  baseInstructions?: string;
};

type NavaiMobileAgentRuntime = {
  session: NavaiMobileAgentRuntimeSession;
  warnings: string[];
  availableFunctionNames: string[];
  executeToolCall: (input: NavaiMobileToolCallInput) => Promise<unknown>;
};

type NavaiMobileAgentRuntimeSession = {
  instructions: string;
  tools: NavaiRealtimeToolDefinition[];
};

type NavaiRealtimeToolDefinition = {
  type: 'function';
  name: string;
  description: string;
  parameters: Record<string, unknown>;
};

type NavaiMobileToolCallInput = {
  name: string;
  payload: Record<string, unknown> | null;
};

type NavaiRealtimeToolCall = {
  callId: string;
  name?: string;
  payload: Record<string, unknown> | null;
};

type BuildNavaiRealtimeToolResultEventsInput = {
  callId: string;
  output: unknown;
};

type ExecuteNavaiMobileBackendFunction = (
  input: ExecuteNavaiBackendFunctionInput
) => Promise<unknown> | unknown;

type CreateNavaiMobileBackendClientOptions = {
  apiBaseUrl?: string;
  env?: NavaiMobileEnv;
  fetchImpl?: typeof fetch;
  clientSecretPath?: string;
  functionsListPath?: string;
  functionsExecutePath?: string;
};

type NavaiMobileBackendClient = {
  createClientSecret: (
    input?: CreateRealtimeClientSecretInput
  ) => Promise<CreateRealtimeClientSecretResult>;
  listFunctions: () => Promise<BackendFunctionsResult>;
  executeFunction: (
    input: ExecuteNavaiBackendFunctionInput
  ) => Promise<unknown>;
};

type CreateRealtimeClientSecretInput = {
  model?: string;
  voice?: string;
  instructions?: string;
  language?: string;
  voiceAccent?: string;
  voiceTone?: string;
  apiKey?: string;
};

type CreateRealtimeClientSecretResult = {
  value: string;
  expires_at?: number;
};

type NavaiBackendFunctionDefinition = {
  name: string;
  description?: string;
  source?: string;
};

type ExecuteNavaiBackendFunctionInput = {
  functionName: string;
  payload: Record<string, unknown> | null;
};

type BackendFunctionsResult = {
  functions: NavaiBackendFunctionDefinition[];
  warnings: string[];
};

type NavaiMobileEnv = Record<string, string | undefined>;

type CreateReactNativeWebRtcTransportOptions = {
  globals: NavaiReactNativeWebRtcGlobals;
  fetchImpl?: typeof fetch;
  model?: string;
  rtcConfiguration?: unknown;
  audioConstraints?: unknown;
  realtimeUrl?: string;
  remoteAudioTrackVolume?: number;
};

type NavaiReactNativeWebRtcGlobals = {
  RTCPeerConnection: new (...args: any[]) => NavaiPeerConnectionLike;
  mediaDevices: {
    getUserMedia: (...args: any[]) => Promise<NavaiMediaStreamLike>;
  };
};

type NavaiRealtimeTransport = {
  connect: (options: NavaiRealtimeTransportConnectOptions) => Promise<void>;
  disconnect: () => Promise<void> | void;
  sendEvent?: (event: unknown) => Promise<void> | void;
  getState?: () => NavaiRealtimeTransportState;
};

type NavaiRealtimeTransportConnectOptions = {
  clientSecret: string;
  model?: string;
  onEvent?: (event: unknown) => void;
  onError?: (error: unknown) => void;
};

type NavaiRealtimeTransportState = 
  | 'idle' 
  | 'connecting' 
  | 'connected' 
  | 'error' 
  | 'closed';

type NavaiPeerConnectionLike = {
  connectionState?: string;
  createDataChannel: (...args: any[]) => NavaiDataChannelLike;
  addTrack: (...args: any[]) => unknown;
  getReceivers?: () => NavaiRtpReceiverLike[];
  createOffer: (...args: any[]) => Promise<NavaiSessionDescriptionLike>;
  setLocalDescription: (...args: any[]) => Promise<void>;
  setRemoteDescription: (...args: any[]) => Promise<void>;
  close: (...args: any[]) => void;
  onconnectionstatechange?: (() => void) | null;
  oniceconnectionstatechange?: (() => void) | null;
  ontrack?: ((event: NavaiTrackEventLike) => void) | null;
};

type NavaiDataChannelLike = {
  readyState?: string;
  send: (data: string) => void;
  close?: () => void;
  onmessage?: ((event: { data?: unknown }) => void) | null;
  onerror?: ((error: unknown) => void) | null;
  onopen?: (() => void) | null;
  onclose?: (() => void) | null;
};

type NavaiMediaStreamLike = {
  getTracks?: () => NavaiMediaTrackLike[];
  getAudioTracks?: () => NavaiMediaTrackLike[];
};

type NavaiMediaTrackLike = {
  stop?: () => void;
  kind?: string;
  _setVolume?: (volume: number) => void;
};

type NavaiSessionDescriptionLike = {
  type: string;
  sdp?: string;
};

type NavaiTrackEventLike = {
  track?: NavaiMediaTrackLike | null;
  streams?: NavaiMediaStreamLike[];
};

type NavaiRtpReceiverLike = {
  track?: NavaiMediaTrackLike | null;
};

type NavaiFunctionDefinition = {
  name: string;
  description: string;
  source: string;
  run: (
    payload: NavaiFunctionPayload,
    context: NavaiFunctionContext
  ) => Promise<unknown> | unknown;
};

type NavaiFunctionPayload = Record<string, unknown>;

type NavaiFunctionContext = {
  navigate: (path: string) => void;
};

type NavaiFunctionsRegistry = {
  byName: Map<string, NavaiFunctionDefinition>;
  ordered: NavaiFunctionDefinition[];
  warnings: string[];
};

type NavaiFunctionModuleLoaders = Record<string, () => Promise<unknown>>;

type NavaiRoute = {
  name: string;
  path: string;
  description: string;
  synonyms?: string[];
};

type CreateNavaiMobileVoiceSessionOptions = {
  transport: NavaiRealtimeTransport;
  backendClient?: NavaiMobileBackendClient;
  backendClientOptions?: CreateNavaiMobileBackendClientOptions;
  onRealtimeEvent?: (event: unknown) => void;
  onRealtimeError?: (error: unknown) => void;
};

type NavaiMobileVoiceSession = {
  start: (
    input?: StartNavaiMobileVoiceSessionInput
  ) => Promise<StartNavaiMobileVoiceSessionResult>;
  stop: () => Promise<void>;
  listBackendFunctions: (forceReload?: boolean) => Promise<BackendFunctionsResult>;
  executeBackendFunction: (
    input: ExecuteNavaiBackendFunctionInput
  ) => Promise<unknown>;
  sendRealtimeEvent: (event: unknown) => Promise<void>;
  getSnapshot: () => NavaiMobileVoiceSessionSnapshot;
};

type StartNavaiMobileVoiceSessionInput = CreateRealtimeClientSecretInput & {
  preloadBackendFunctions?: boolean;
};

type StartNavaiMobileVoiceSessionResult = {
  clientSecret: string;
  backendFunctions: NavaiBackendFunctionDefinition[];
  warnings: string[];
};

type NavaiMobileVoiceSessionSnapshot = {
  state: NavaiMobileVoiceSessionState;
  transportState: NavaiRealtimeTransportState | 'unknown';
  backendFunctions: NavaiBackendFunctionDefinition[];
  warnings: string[];
};

type NavaiMobileVoiceSessionState = 
  | 'idle' 
  | 'connecting' 
  | 'connected' 
  | 'error';

type NavaiMobileRuntimeEnv = Record<string, string | undefined> & {
  NAVAI_API_URL?: string;
  NAVAI_FUNCTIONS_FOLDERS?: string;
  NAVAI_ROUTES_FILE?: string;
  NAVAI_REALTIME_MODEL?: string;
};

type ResolveNavaiMobileEnvOptions = {
  sources?: Array<Record<string, unknown> | undefined>;
};

type ResolveNavaiMobileRuntimeConfigOptions = {
  moduleLoaders: NavaiFunctionModuleLoaders;
  defaultRoutes: NavaiRoute[];
  env?: Record<string, unknown>;
  routesFile?: string;
  functionsFolders?: string;
  modelOverride?: string;
  defaultRoutesFile?: string;
  defaultFunctionsFolder?: string;
};

type ResolveNavaiMobileRuntimeConfigResult = {
  routes: NavaiRoute[];
  functionModuleLoaders: NavaiFunctionModuleLoaders;
  modelOverride?: string;
  warnings: string[];
};

type ResolveNavaiMobileApplicationRuntimeConfigOptions = 
  ResolveNavaiMobileRuntimeConfigOptions & {
  env?: NavaiMobileRuntimeEnv;
  apiBaseUrl?: string;
  defaultApiBaseUrl?: string;
  emptyModuleLoadersWarning?: string;
};

type ResolveNavaiMobileApplicationRuntimeConfigResult = 
  ResolveNavaiMobileRuntimeConfigResult & {
  apiBaseUrl: string;
  env: NavaiMobileRuntimeEnv;
};

// Check if value is a record
function isRecord(value: unknown): value is Record<string, unknown>;

// Check if value is a class constructor
function isClassConstructor(value: unknown): value is new (...args: any[]) => any;

// Check if value is callable
function isCallable(value: unknown): value is (...args: any[]) => any;

// Normalize function name
function normalizeName(value: string): string;

// Format error to string
function toErrorMessage(error: unknown): string;

import type {
  UseMobileVoiceAgentOptions,
  UseMobileVoiceAgentResult,
  NavaiMobileAgentRuntime,
  NavaiRealtimeTransport,
  NavaiRoute,
  NavaiFunctionDefinition
} from '@navai/voice-mobile';

import {
  useMobileVoiceAgent,
  createNavaiMobileAgentRuntime,
  type UseMobileVoiceAgentOptions,
  type NavaiRoute
} from '@navai/voice-mobile';