@alia.onl/sdk 3.1.2 → 3.1.4

package/src/hooks/useVoiceRoom.ts

@@ -12,11 +12,13 @@ import {
   RoomEvent,
   Track,
   DisconnectReason,
+  type RemoteTrack,
   type RemoteTrackPublication,
   type RemoteParticipant,
   type DataPublishOptions,
 } from 'livekit-client';
 import { useOxy } from '@oxyhq/services';
+import { errorMessage } from '../lib/utils';
 import type { RoomState, AgentState, VoiceMessage, VoiceToolInvocation } from '../types';
 
 const API_URL = process.env.EXPO_PUBLIC_ALIA_API_URL ?? 'https://api.alia.onl';
@@ -63,7 +65,7 @@ interface CohostEnabledMsg { type: 'cohost.enabled' }
 interface CohostDisabledMsg { type: 'cohost.disabled' }
 interface CohostTurnMsg { type: 'cohost.turn_changed'; speaker: 'primary' | 'cohost' | 'user' }
 interface CohostRoundMsg { type: 'cohost.round_complete'; turns: number }
-interface ToolCallMsg { type: 'tool.call'; toolName: string; callId: string; args?: any; speaker: 'primary' | 'cohost' }
+interface ToolCallMsg { type: 'tool.call'; toolName: string; callId: string; args?: Record<string, unknown>; speaker: 'primary' | 'cohost' }
 interface ToolResultMsg { type: 'tool.result'; callId: string; speaker: 'primary' | 'cohost' }
 interface SessionEndedMsg { type: 'session.ended'; reason: string }
 interface ErrorMsg { type: 'error'; code: string; message: string }
@@ -73,6 +75,31 @@ type AgentDataMessage =
   | CohostEnabledMsg | CohostDisabledMsg | CohostTurnMsg | CohostRoundMsg
   | ToolCallMsg | ToolResultMsg | SessionEndedMsg | ErrorMsg;
 
+// ============== MIC DEVICE ERRORS ==============
+
+/**
+ * Map a microphone-acquisition failure to actionable copy. When
+ * `setMicrophoneEnabled(true)` calls getUserMedia and the device is missing,
+ * blocked, or busy, it surfaces a DOMException whose `.name` identifies the
+ * cause (legacy aliases included). Returns null for anything that isn't a known
+ * device error so the caller can fall back to generic handling.
+ */
+function micDeviceErrorMessage(name: string): string | null {
+  switch (name) {
+    case 'NotFoundError':
+    case 'DevicesNotFoundError':
+      return 'No microphone found — connect one and try again';
+    case 'NotAllowedError':
+    case 'PermissionDeniedError':
+      return 'Microphone access denied — allow it in your browser';
+    case 'NotReadableError':
+    case 'TrackStartError':
+      return 'Microphone is in use by another app';
+    default:
+      return null;
+  }
+}
+
 // ============== HOOK ==============
 
 export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
@@ -324,13 +351,13 @@ export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
 
       // Event: remote audio tracks (agent speaking)
       // On web, must attach to a DOM element to play. On native, WebRTC plays audio automatically.
-      room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
+      room.on(RoomEvent.TrackSubscribed, (track: RemoteTrack) => {
         if (track.kind === Track.Kind.Audio && hasDOM) {
           track.attach();
         }
       });
 
-      room.on(RoomEvent.TrackUnsubscribed, (track) => {
+      room.on(RoomEvent.TrackUnsubscribed, (track: RemoteTrack) => {
         if (hasDOM && track.kind === Track.Kind.Audio) {
           track.detach();
         }
@@ -351,15 +378,33 @@ export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
       // Connect to the room
       await room.connect(url, livekitToken, { autoSubscribe: true });
 
-      // Enable microphone — audio goes to LiveKit, agent picks it up server-side
-      await room.localParticipant.setMicrophoneEnabled(true);
+      // Enable microphone — audio goes to LiveKit, agent picks it up server-side.
+      // getUserMedia device failures (no mic, permission blocked, hardware busy)
+      // surface here; map them to actionable copy instead of a generic failure.
+      try {
+        await room.localParticipant.setMicrophoneEnabled(true);
+      } catch (micError: unknown) {
+        // DOMException is not `instanceof Error`, so read `.name` off the object.
+        const name =
+          typeof micError === 'object' && micError !== null && 'name' in micError &&
+          typeof micError.name === 'string'
+            ? micError.name
+            : '';
+        const friendly = micDeviceErrorMessage(name);
+        if (!friendly) throw micError; // unknown failure — let the generic handler report it
+        console.error(`[useVoiceRoom] Microphone error (${name || 'unknown'}):`, micError);
+        setError(friendly);
+        setRoomState('error');
+        cleanup();
+        return;
+      }
 
       setRoomState('connected');
       setAgentState('listening');
 
-    } catch (e: any) {
+    } catch (e: unknown) {
       console.error('[useVoiceRoom] Connection error:', e);
-      setError(e.message || 'Failed to connect');
+      setError(errorMessage(e, 'Failed to connect'));
       setRoomState('error');
       cleanup();
     }

package/src/index.ts

@@ -9,8 +9,8 @@ export { AliaChatScreen } from './components/AliaChatScreen';
 export type { AliaChatScreenProps } from './components/AliaChatScreen';
 
 // ── Chat UI components ──
-export { AliaFace } from './components/AliaFace';
-export type { AliaAccessory, AliaExpression, AliaFaceProps } from './components/AliaFace';
+export { AliaMark } from './components/AliaMark';
+export type { AliaMarkProps, AliaMarkState } from './components/AliaMark';
 export { ThinkingIndicator } from './components/ThinkingIndicator';
 export { AliaMarkdown } from './components/Markdown';
 export type { AliaMarkdownProps } from './components/Markdown';
@@ -36,6 +36,8 @@ export { useTTS } from './hooks/useTTS';
 export type { UseTTSOptions } from './hooks/useTTS';
 export { useSpeechToText, useSTTStore } from './hooks/useSpeechToText';
 export type { UseSTTOptions } from './hooks/useSpeechToText';
+export { useAmbientWave } from './hooks/useAmbientWave';
+export type { UseAmbientWaveOptions, UseAmbientWaveResult, AmbientWaveVoice, AmbientWaveMode } from './hooks/useAmbientWave';
 export { useSoundEffects, useVoiceSoundEffects } from './hooks/useSoundEffects';
 export type { SoundName, SoundSources } from './hooks/useSoundEffects';
 

package/src/lib/content-utils.ts

@@ -1,12 +1,22 @@
+/** A single part of a multi-part chat message content array. */
+export interface ContentPart {
+  type: string;
+  text?: string;
+  image_url?: { url?: string };
+  [key: string]: unknown;
+}
+
+export type MessageContent = string | ContentPart[];
+
 /**
  * Extract text from message content, whether it's a string or multi-part array.
  */
-export function getTextFromContent(content: string | Array<{ type: string; [key: string]: any }> | any): string {
+export function getTextFromContent(content: MessageContent | null | undefined): string {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) {
     return content
-      .filter((p: any) => p.type === 'text')
-      .map((p: any) => p.text || '')
+      .filter((p) => p.type === 'text')
+      .map((p) => p.text || '')
       .join('');
   }
   return String(content || '');
@@ -15,9 +25,11 @@ export function getTextFromContent(content: string | Array<{ type: string; [key:
 /**
  * Extract image URLs from multi-part message content.
  */
-export function getImagesFromContent(content: string | Array<{ type: string; [key: string]: any }> | any): string[] {
+export function getImagesFromContent(content: MessageContent | null | undefined): string[] {
   if (!Array.isArray(content)) return [];
   return content
-    .filter((p: any) => p.type === 'image_url' && p.image_url?.url)
-    .map((p: any) => p.image_url.url);
+    .filter((p): p is ContentPart & { image_url: { url: string } } =>
+      p.type === 'image_url' && typeof p.image_url?.url === 'string',
+    )
+    .map((p) => p.image_url.url);
 }

package/src/lib/utils.ts

@@ -5,6 +5,17 @@ export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
 
+/** Extract a human-readable message from an unknown caught error. */
+export function errorMessage(err: unknown, fallback = 'Something went wrong'): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === 'object' && err !== null) {
+    const maybe = err as { message?: string };
+    if (maybe.message) return maybe.message;
+  }
+  if (typeof err === 'string') return err;
+  return fallback;
+}
+
 export function formatFileSize(bytes: number): string {
   if (bytes === 0) return '0 B';
   const k = 1024;

package/src/optional-deps.d.ts

@@ -10,22 +10,28 @@
 // have their own real types — ambient declarations here would shadow them.
 
 declare module 'livekit-client' {
+  export interface RemoteTrack {
+    kind?: string;
+    mediaStreamTrack?: MediaStreamTrack;
+    attach(): HTMLMediaElement;
+    detach(): HTMLMediaElement[];
+  }
   export class Room {
-    on(event: any, listener: (...args: any[]) => void): this;
-    off(event: any, listener: (...args: any[]) => void): this;
+    on<Args extends unknown[]>(event: string, listener: (...args: Args) => void): this;
+    off<Args extends unknown[]>(event: string, listener: (...args: Args) => void): this;
     localParticipant: LocalParticipant;
     remoteParticipants: Map<string, RemoteParticipant>;
-    connect(url: string, token: string, options?: any): Promise<void>;
+    connect(url: string, token: string, options?: Record<string, unknown>): Promise<void>;
     disconnect(): Promise<void>;
     state: string;
   }
   export class LocalParticipant {
     publishData(data: Uint8Array, options?: DataPublishOptions): Promise<void>;
-    getTrackPublications(): Map<string, any>;
-    getTrackPublication(source: string): any;
+    getTrackPublications(): Map<string, RemoteTrackPublication>;
+    getTrackPublication(source: string): RemoteTrackPublication | undefined;
     setMicrophoneEnabled(enabled: boolean): Promise<void>;
-    audioTrackPublications: Map<string, any>;
-    trackPublications: Map<string, any>;
+    audioTrackPublications: Map<string, RemoteTrackPublication>;
+    trackPublications: Map<string, RemoteTrackPublication>;
   }
   export class RemoteParticipant {
     getTrackPublications(): Map<string, RemoteTrackPublication>;
@@ -34,7 +40,7 @@ declare module 'livekit-client' {
     identity: string;
   }
   export class RemoteTrackPublication {
-    track: any;
+    track: RemoteTrack | null;
     source: string;
     kind: string;
     isSubscribed: boolean;
@@ -59,15 +65,54 @@ declare module 'livekit-client' {
   }
 }
 
+declare module 'expo-haptics' {
+  export enum ImpactFeedbackStyle {
+    Light = 'light',
+    Medium = 'medium',
+    Heavy = 'heavy',
+    Soft = 'soft',
+    Rigid = 'rigid',
+  }
+  export function impactAsync(style?: ImpactFeedbackStyle): Promise<void>;
+}
+
 declare module 'expo-audio' {
-  export function createAudioPlayer(source: any): any;
-  export function useAudioRecorder(preset: any): any;
-  export function useAudioRecorderState(recorder: any, interval: number): any;
+  export interface AudioPlaybackStatus {
+    didJustFinish?: boolean;
+    isLoaded?: boolean;
+    playing?: boolean;
+  }
+  export interface AudioPlayer {
+    addListener(event: 'playbackStatusUpdate', listener: (status: AudioPlaybackStatus) => void): { remove(): void };
+    play(): void;
+    pause(): void;
+    seekTo(seconds: number): void;
+    remove(): void;
+    release(): void;
+  }
+  /** A URI object, a bundled asset module id (number), or a required asset. */
+  export type AudioSource = { uri: string } | number;
+  export interface RecordingPreset {
+    isMeteringEnabled?: boolean;
+    [key: string]: unknown;
+  }
+  export interface AudioMode {
+    [key: string]: unknown;
+  }
+  export interface AudioRecorderState {
+    metering?: number;
+    isRecording?: boolean;
+    durationMillis?: number;
+  }
+  export function createAudioPlayer(source: AudioSource): AudioPlayer;
+  export function useAudioRecorder(preset: RecordingPreset): AudioRecorder;
+  export function useAudioRecorderState(recorder: AudioRecorder, interval: number): AudioRecorderState;
   export function requestRecordingPermissionsAsync(): Promise<{ granted: boolean }>;
-  export function setAudioModeAsync(mode: any): Promise<void>;
-  export const RecordingPresets: { HIGH_QUALITY: any };
+  export function getRecordingPermissionsAsync(): Promise<{ granted: boolean }>;
+  export function setAudioModeAsync(mode: AudioMode): Promise<void>;
+  export const RecordingPresets: { HIGH_QUALITY: RecordingPreset };
   export class AudioRecorder {
-    constructor(preset: any);
+    constructor(preset: RecordingPreset);
     prepareToRecordAsync(): Promise<void>;
     record(): void;
     stop(): Promise<void>;
@@ -81,6 +126,22 @@ declare module 'expo-clipboard' {
 }
 
 declare module 'expo-image-picker' {
-  export function launchImageLibraryAsync(options?: any): Promise<any>;
+  export interface ImagePickerAsset {
+    uri: string;
+    fileName?: string | null;
+    fileSize?: number;
+    mimeType?: string;
+  }
+  export interface ImagePickerOptions {
+    allowsMultipleSelection?: boolean;
+    mediaTypes?: string;
+    aspect?: [number, number];
+    quality?: number;
+  }
+  export interface ImagePickerResult {
+    canceled: boolean;
+    assets: ImagePickerAsset[];
+  }
+  export function launchImageLibraryAsync(options?: ImagePickerOptions): Promise<ImagePickerResult>;
   export const MediaTypeOptions: { Images: string; Videos: string; All: string };
 }

package/src/types.ts

@@ -42,7 +42,7 @@ export interface PendingPlan {
 export interface ChatMessage {
   id: string;
   role: 'user' | 'assistant' | 'system';
-  content: string | Array<{ type: string; [key: string]: any }>;
+  content: string | Array<{ type: string; [key: string]: unknown }>;
   toolInvocations?: ToolInvocation[];
   createdAt: number;
   /** Extended thinking / reasoning content */
@@ -66,8 +66,8 @@ export interface ChatMessage {
 export interface ToolInvocation {
   toolName: string;
   state: 'call' | 'partial-call' | 'result';
-  args?: Record<string, any>;
-  result?: any;
+  args?: Record<string, unknown>;
+  result?: unknown;
   /** OpenAI-format tool call ID for matching calls to results */
   toolCallId?: string;
 }
@@ -81,7 +81,7 @@ export interface VoiceToolInvocation {
   toolCallId: string;
   toolName: string;
   state: 'call' | 'result';
-  args?: any;
+  args?: Record<string, unknown>;
 }
 
 export interface VoiceMessage {