TypeScript Types

type UseWebVoiceAgentOptions = {
  navigate: (path: string) => void;
  moduleLoaders: NavaiFunctionModuleLoaders;
  defaultRoutes: NavaiRoute[];
  env?: Record<string, string | undefined>;
  apiBaseUrl?: string;
  routesFile?: string;
  functionsFolders?: string;
  modelOverride?: string;
  defaultRoutesFile?: string;
  defaultFunctionsFolder?: string;
};

type UseWebVoiceAgentResult = {
  status: VoiceStatus;
  error: string | null;
  isConnecting: boolean;
  isConnected: boolean;
  start: () => Promise<void>;
  stop: () => void;
};

type VoiceStatus = "idle" | "connecting" | "connected" | "error";

type BuildNavaiAgentOptions = NavaiFunctionContext & {
  routes: NavaiRoute[];
  functionModuleLoaders?: NavaiFunctionModuleLoaders;
  backendFunctions?: NavaiBackendFunctionDefinition[];
  executeBackendFunction?: ExecuteNavaiBackendFunction;
  agentName?: string;
  baseInstructions?: string;
};

type BuildNavaiAgentResult = {
  agent: RealtimeAgent;
  warnings: string[];
};

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

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

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

type CreateNavaiBackendClientOptions = {
  apiBaseUrl?: string;
  env?: Record<string, string | undefined>;
  fetchImpl?: typeof fetch;
  clientSecretPath?: string;
  functionsListPath?: string;
  functionsExecutePath?: string;
};

type NavaiBackendClient = {
  createClientSecret: (input?: CreateClientSecretInput) => Promise<CreateClientSecretOutput>;
  listFunctions: () => Promise<BackendFunctionsResult>;
  executeFunction: ExecuteNavaiBackendFunction;
};

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

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

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

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

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

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 NavaiRoute = {
  name: string;
  path: string;
  description: string;
  synonyms?: string[];
};

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

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

import type {
  UseWebVoiceAgentOptions,
  UseWebVoiceAgentResult,
  NavaiRoute,
  NavaiFunctionModuleLoaders
} from '@navai/voice-frontend';

const routes: NavaiRoute[] = [
  { name: 'home', path: '/', description: 'Home page' }
];

const moduleLoaders: NavaiFunctionModuleLoaders = {
  './functions/search.ts': () => import('./functions/search')
};

const options: UseWebVoiceAgentOptions = {
  navigate: (path) => router.push(path),
  moduleLoaders,
  defaultRoutes: routes
};

const result: UseWebVoiceAgentResult = useWebVoiceAgent(options);

import type {
  BuildNavaiAgentOptions,
  BuildNavaiAgentResult,
  NavaiBackendFunctionDefinition,
  ExecuteNavaiBackendFunction
} from '@navai/voice-frontend';

const backendFunctions: NavaiBackendFunctionDefinition[] = [
  { name: 'send_email', description: 'Send an email' }
];

const executeBackendFunction: ExecuteNavaiBackendFunction = async ({ functionName, payload }) => {
  return await api.execute(functionName, payload);
};

const options: BuildNavaiAgentOptions = {
  navigate: (path) => router.push(path),
  routes,
  backendFunctions,
  executeBackendFunction
};

const result: BuildNavaiAgentResult = await buildNavaiAgent(options);

import type {
  CreateNavaiBackendClientOptions,
  NavaiBackendClient,
  CreateClientSecretInput,
  CreateClientSecretOutput
} from '@navai/voice-frontend';

const options: CreateNavaiBackendClientOptions = {
  apiBaseUrl: 'https://api.example.com'
};

const client: NavaiBackendClient = createNavaiBackendClient(options);

const input: CreateClientSecretInput = {
  model: 'gpt-4o-realtime-preview-2024-12-17'
};

const output: CreateClientSecretOutput = await client.createClientSecret(input);

import type {
  NavaiFunctionDefinition,
  NavaiFunctionPayload,
  NavaiFunctionContext,
  NavaiFunctionsRegistry
} from '@navai/voice-frontend';

// Define a function
const searchFunction: NavaiFunctionDefinition = {
  name: 'search',
  description: 'Search for content',
  source: './functions/search.ts#search',
  run: async (payload: NavaiFunctionPayload, context: NavaiFunctionContext) => {
    const query = payload.args?.[0] as string;
    return { results: [] };
  }
};

// Use registry
const registry: NavaiFunctionsRegistry = await loadNavaiFunctions(moduleLoaders);
const fn: NavaiFunctionDefinition | undefined = registry.byName.get('search');

import type { VoiceStatus } from '@navai/voice-frontend';

function isConnected(status: VoiceStatus): status is "connected" {
  return status === 'connected';
}

function hasError(status: VoiceStatus): status is "error" {
  return status === 'error';
}

function isActive(status: VoiceStatus): boolean {
  return status === 'connecting' || status === 'connected';
}