@alia.onl/sdk 3.1.1 → 3.1.3

package/src/components/ui/chat-text-input.tsx

@@ -7,6 +7,7 @@ import {
   type TextInputKeyPressEventData,
   type NativeSyntheticEvent as RNSyntheticEvent,
   type TextInputContentSizeChangeEventData,
+  type TextStyle,
 } from "react-native";
 import { cn } from "../../lib/utils";
 
@@ -144,12 +145,12 @@ const ChatTextInput = React.forwardRef<TextInput, ChatTextInputProps>(
           scrollEnabled={fillContainer || props.multiline}
           style={[
             style,
-            !fillContainer && props.multiline && !disableAutoHeight && {
+            !fillContainer && props.multiline && !disableAutoHeight && ({
               minHeight,
               maxHeight,
-              overflow: 'auto' as any,
+              overflow: 'auto',
               ...(Platform.OS === 'web' ? { fieldSizing: 'content' } : {}),
-            },
+            } as TextStyle & { overflow: 'auto'; fieldSizing?: string }),
             fillContainer && { flex: 1, height: '100%' },
           ]}
           {...props}

package/src/components/ui/dropdown-menu.web.tsx

@@ -4,6 +4,7 @@ import { cn } from "../../lib/utils";
 import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
 import { CheckIcon, ChevronRightIcon } from "@radix-ui/react-icons";
 import * as React from "react";
+import type { LucideIcon } from "lucide-react-native";
 import {
   Star, Pencil, Trash2, Share2, Download, Settings, HelpCircle,
   Image, FileText, Search, ShoppingBag, MoreHorizontal, ExternalLink,
@@ -12,7 +13,7 @@ import {
 } from "lucide-react-native";
 
 // Map iOS SF Symbol names to Lucide icons for web rendering
-const SF_SYMBOL_MAP: Record<string, React.ComponentType<any>> = {
+const SF_SYMBOL_MAP: Record<string, LucideIcon> = {
   "star": Star, "star.fill": Star, "pencil": Pencil, "trash": Trash2,
   "square.and.arrow.up": Share2, "arrow.down.doc": Download,
   "gearshape": Settings, "questionmark.circle": HelpCircle,
@@ -142,8 +143,8 @@ const DropdownMenuSubContent = React.forwardRef<
       )}
       style={{
         boxShadow: '0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -2px rgba(0,0,0,0.1)',
-        border: '1px solid hsl(var(--border))',
-        ...style as any,
+        border: '1px solid var(--border)',
+        ...style,
       }}
       {...props}
     />
@@ -168,8 +169,8 @@ const DropdownMenuContent = React.forwardRef<
       )}
       style={{
         boxShadow: '0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -2px rgba(0,0,0,0.1)',
-        border: '1px solid hsl(var(--border))',
-        ...style as any,
+        border: '1px solid var(--border)',
+        ...style,
       }}
       {...props}
     />
@@ -198,7 +199,7 @@ const DropdownMenuItem = React.forwardRef<
   ) => (
     <DropdownMenuPrimitive.Item
       ref={ref}
-      onSelect={(e: any) => {
+      onSelect={(e: Event) => {
         onSelect?.(e);
         if (shouldDismissMenuOnSelect === false) {
           e.preventDefault();
@@ -244,7 +245,7 @@ const DropdownMenuCheckboxItem = React.forwardRef<
   ) => (
     <DropdownMenuPrimitive.CheckboxItem
       ref={ref}
-      onSelect={(e: any) => {
+      onSelect={(e: Event) => {
         const current =
           value === true ? "on" : value === false ? "off" : value;
         const next = current === "on" ? "off" : "on";
@@ -305,7 +306,7 @@ DropdownMenuSeparator.displayName =
 
 export const ItemIcon = React.forwardRef<
   HTMLSpanElement,
-  React.HTMLProps<HTMLSpanElement> & { ios?: { name?: string; [key: string]: any }; androidIconName?: string }
+  React.HTMLProps<HTMLSpanElement> & { ios?: { name?: string; [key: string]: unknown }; androidIconName?: string }
 >(({ className, ios, androidIconName, children, ...props }, ref) => {
   const IconComponent = ios?.name ? SF_SYMBOL_MAP[ios.name] : null;
   return (

package/src/components/ui/prompt-input/autocomplete.tsx

@@ -122,7 +122,7 @@ export function PromptInputAutocomplete({
   // Register/unregister the key handler based on completions
   useEffect(() => {
     if (completions.length > 0) {
-      (setHandleCompletionKey as any)(() => handleKey);
+      setHandleCompletionKey(() => handleKey);
     } else {
       setHandleCompletionKey(null);
     }

package/src/components/ui/prompt-input/context.tsx

@@ -35,7 +35,7 @@ export type PromptInputContextType = {
   removeAttachment: (id: string) => void;
   updateAttachment: (id: string, updates: Partial<Attachment>) => void;
   handleCompletionKey: ((key: string) => boolean) | null;
-  setHandleCompletionKey: (fn: ((key: string) => boolean) | null) => void;
+  setHandleCompletionKey: React.Dispatch<React.SetStateAction<((key: string) => boolean) | null>>;
   // Injectable autocomplete hooks
   useSuggestions?: (query: string) => { data: Completion[] | undefined; isLoading: boolean };
   onSuggestionUsed?: (suggestionId: string) => void;

package/src/components/ui/prompt-input/prompt-input.tsx

@@ -3,6 +3,7 @@ import {
   View,
   Pressable,
   type TextInput as RNTextInput,
+  type ViewStyle,
 } from "react-native";
 import { KeyboardAvoidingView } from "../../../lib/keyboard";
 import { Maximize2, Minimize2 } from "lucide-react-native";
@@ -253,7 +254,8 @@ export function PromptInput({
       {showFullscreen && (
         <View
           style={{
-            position: "fixed" as any,
+            // `position: 'fixed'` is a web-only value (NativeWind) not in RN's ViewStyle union.
+            position: "fixed" as unknown as ViewStyle["position"],
             top: 0,
             left: 0,
             right: 0,

package/src/components/voice/AudioWaveVisualizer.tsx

@@ -16,10 +16,14 @@ import type { AgentState } from '../../types';
 const AnimatedPath = Animated.createAnimatedComponent(Path);
 
 /** Cross-platform blur: CSS string on web, RN array syntax on native */
-function blurStyle(radius: number) {
+type BlurStyle =
+  | { filter: string; WebkitFilter: string }
+  | { filter: Array<{ blur: number }> };
+
+function blurStyle(radius: number): BlurStyle {
   return Platform.OS === 'web'
-    ? ({ filter: `blur(${radius}px)`, WebkitFilter: `blur(${radius}px)` } as any)
-    : ({ filter: [{ blur: radius }] } as any);
+    ? { filter: `blur(${radius}px)`, WebkitFilter: `blur(${radius}px)` }
+    : { filter: [{ blur: radius }] };
 }
 
 const GLOW_HEIGHT = 350;
@@ -175,9 +179,21 @@ const BLOB_COLORS: Record<AgentState, string[]> = {
 };
 
 // Derive wave & blob palettes from a hex color
-function hexToRgb(hex: string): [number, number, number] {
-  const h = hex.replace('#', '');
-  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+/** Parse a CSS color string (#rgb, #rrggbb, rgb(...), rgba(...)) to [r,g,b]; null if unrecognized. */
+function parseColor(input: string): [number, number, number] | null {
+  const s = input.trim();
+  if (s.startsWith('#')) {
+    const h = s.slice(1);
+    const expanded = h.length === 3 ? h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : h;
+    if (expanded.length !== 6) return null;
+    const r = parseInt(expanded.slice(0, 2), 16);
+    const g = parseInt(expanded.slice(2, 4), 16);
+    const b = parseInt(expanded.slice(4, 6), 16);
+    return Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) ? null : [r, g, b];
+  }
+  // rgb()/rgba() — comma OR space separated (rgb(r, g, b) and modern rgb(r g b / a)); alpha ignored
+  const match = s.match(/^rgba?\(\s*(\d+)[\s,]+(\d+)[\s,]+(\d+)/i);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
 }
 
 function darken(rgb: [number, number, number], factor: number): [number, number, number] {
@@ -192,8 +208,9 @@ function lighten(rgb: [number, number, number], factor: number): [number, number
   ];
 }
 
-function deriveWavePalette(hex: string, isDark: boolean): { waves: string[]; blobs: string[] } {
-  const rgb = hexToRgb(hex);
+function deriveWavePalette(color: string, isDark: boolean): { waves: string[]; blobs: string[] } | null {
+  const rgb = parseColor(color);
+  if (!rgb) return null;
   // Dark mode: lighter/brighter waves visible against dark bg
   // Light mode: darker waves visible against light bg
   const layer0 = isDark ? darken(rgb, 0.55) : darken(rgb, 0.3);
@@ -219,7 +236,7 @@ function deriveWavePalette(hex: string, isDark: boolean): { waves: string[]; blo
 interface AudioWaveVisualizerProps {
   waveAmplitude: SharedValue<number>;
   agentState: AgentState;
-  isConnected: boolean;
+  isConnected?: boolean;
   /** Theme primary color hex — derives idle/listening wave palette */
   primaryColor?: string;
   /** Whether the app is in dark mode (affects wave brightness) */
@@ -229,7 +246,7 @@ interface AudioWaveVisualizerProps {
 export function AudioWaveVisualizer({
   waveAmplitude,
   agentState = 'idle',
-  isConnected,
+  isConnected = true,
   primaryColor,
   isDarkMode,
 }: AudioWaveVisualizerProps) {

package/src/components/voice/VoiceOverlay.tsx

@@ -1,11 +1,17 @@
 /**
- * Subtle voice mode overlay that renders the AudioWaveVisualizer
- * behind the conversation message list. Preserves the normal chat theme
- * with waves at reduced opacity for a seamless visual experience.
+ * Subtle wave overlay that renders the AudioWaveVisualizer behind the
+ * conversation message list. Always mounted; `intensity` ramps the opacity
+ * between a barely-there idle ambient and a prominent speaking state.
  */
 
-import { View } from 'react-native';
-import Animated, { FadeIn, FadeOut } from 'react-native-reanimated';
+import Animated, {
+  FadeIn,
+  FadeOut,
+  useSharedValue,
+  useAnimatedReaction,
+  useAnimatedStyle,
+  withTiming,
+} from 'react-native-reanimated';
 import { AudioWaveVisualizer } from './AudioWaveVisualizer';
 import type { SharedValue } from 'react-native-reanimated';
 import type { AgentState } from '../../types';
@@ -13,12 +19,34 @@ import type { AgentState } from '../../types';
 interface VoiceOverlayProps {
   waveAmplitude: SharedValue<number>;
   agentState: AgentState;
-  isConnected: boolean;
+  /** Overlay opacity target (default 0.35); ramps over 500ms when it changes. */
+  intensity?: number;
+  isConnected?: boolean;
   primaryColor?: string;
   isDarkMode?: boolean;
 }
 
-export function VoiceOverlay({ waveAmplitude, agentState, isConnected, primaryColor, isDarkMode }: VoiceOverlayProps) {
+export function VoiceOverlay({
+  waveAmplitude,
+  agentState,
+  intensity = 0.35,
+  isConnected = true,
+  primaryColor,
+  isDarkMode,
+}: VoiceOverlayProps) {
+  // Imperative opacity ramp (web-safe): mapper-started style animations don't
+  // tick on reanimated-web, so drive a shared value via useAnimatedReaction.
+  const opacity = useSharedValue(intensity);
+  useAnimatedReaction(
+    () => intensity,
+    (target, previous) => {
+      if (target === previous) return;
+      opacity.value = withTiming(target, { duration: 500 });
+    },
+    [intensity],
+  );
+  const animatedStyle = useAnimatedStyle(() => ({ opacity: opacity.value }));
+
   return (
     <Animated.View
       entering={FadeIn.duration(400)}
@@ -33,7 +61,7 @@ export function VoiceOverlay({ waveAmplitude, agentState, isConnected, primaryCo
         pointerEvents: 'none',
       }}
     >
-      <View style={{ opacity: 0.35 }}>
+      <Animated.View style={animatedStyle}>
         <AudioWaveVisualizer
           waveAmplitude={waveAmplitude}
           agentState={agentState}
@@ -41,7 +69,7 @@ export function VoiceOverlay({ waveAmplitude, agentState, isConnected, primaryCo
           primaryColor={primaryColor}
           isDarkMode={isDarkMode}
         />
-      </View>
+      </Animated.View>
     </Animated.View>
   );
 }

package/src/hooks/useAliaChat.ts

@@ -128,7 +128,7 @@ export function useAliaChat(options: UseAliaChatOptions = {}): UseAliaChatReturn
 
   /** Apply a tool result to the last assistant message and sync the ref */
   const applyToolResult = useCallback(
-    (toolCallId: string, name: string | undefined, output: any) => {
+    (toolCallId: string, name: string | undefined, output: unknown) => {
       updateAssistant((last) => {
         const invocations = [...(last.toolInvocations || [])];
         const idx = invocations.findIndex((t) => t.toolCallId === toolCallId);
@@ -380,9 +380,9 @@ export function useAliaChat(options: UseAliaChatOptions = {}): UseAliaChatReturn
                     const toolName = tc.function?.name;
                     if (!toolCallId || !toolName) continue;
 
-                    let args: any;
+                    let args: Record<string, unknown> | undefined;
                     if (tc.function?.arguments) {
-                      try { args = JSON.parse(tc.function.arguments); } catch { args = { _raw: tc.function.arguments }; }
+                      try { args = JSON.parse(tc.function.arguments) as Record<string, unknown>; } catch { args = { _raw: tc.function.arguments }; }
                     }
 
                     const invocation: ToolInvocation = { toolCallId, toolName, state: 'call', args };
@@ -411,9 +411,9 @@ export function useAliaChat(options: UseAliaChatOptions = {}): UseAliaChatReturn
         } finally {
           reader.releaseLock();
         }
-      } catch (err: any) {
-        if (err?.name === 'AbortError') return;
-        const errorMessage = err?.message || 'Something went wrong';
+      } catch (err: unknown) {
+        if (err instanceof Error && err.name === 'AbortError') return;
+        const errorMessage = err instanceof Error ? err.message : 'Something went wrong';
         setError(errorMessage);
         updateAssistant((last) =>
           !last.content ? { content: "I'm having trouble connecting right now. Please try again." } : {}

package/src/hooks/useAmbientWave.ts

@@ -0,0 +1,142 @@
+import { useMemo } from 'react';
+import {
+  useSharedValue,
+  useDerivedValue,
+  useAnimatedReaction,
+  withTiming,
+  withRepeat,
+  withSequence,
+  cancelAnimation,
+  Easing,
+  type SharedValue,
+} from 'react-native-reanimated';
+import { useSTTStore } from './useSpeechToText';
+import type { AgentState } from '../types';
+
+export type AmbientWaveMode = 'voice' | 'tts' | 'stt' | 'thinking' | 'idle';
+
+export interface AmbientWaveVoice {
+  isActive: boolean;
+  isConnected: boolean;
+  agentState: AgentState;
+  waveAmplitude: SharedValue<number>;
+}
+
+export interface UseAmbientWaveOptions {
+  /** Live voice-call amplitude + state (present only while a call is being set up / active). */
+  voice?: AmbientWaveVoice;
+  /** Whether TTS ("read aloud") is currently playing. */
+  isTTSPlaying: boolean;
+  /** Simulated TTS amplitude SharedValue (glides to 0 when not playing). */
+  ttsWaveAmplitude: SharedValue<number>;
+  /** Text-chat generation in flight (thinking or streaming) — gentle wave motion. */
+  isGenerating?: boolean;
+}
+
+export interface UseAmbientWaveResult {
+  /** Combined amplitude — max of idle breath, voice, TTS, and STT sources. */
+  waveAmplitude: SharedValue<number>;
+  /** Palette-driving state for the visualizer. */
+  agentState: AgentState;
+  /** Overlay opacity target — subtle at idle, prominent while there is speech. */
+  intensity: number;
+  /** Semantic label for the active source. */
+  mode: AmbientWaveMode;
+}
+
+const IDLE_INTENSITY = 0.13;
+const THINKING_INTENSITY = 0.2;
+const ACTIVE_INTENSITY = 0.35;
+
+/**
+ * Combines every wave-amplitude source into one always-on ambient signal for a
+ * single persistent overlay. Idle chat breathes subtly; a voice call, TTS
+ * playback, or STT recording intensify it. Because every source glides to 0 when
+ * inactive, `max(idleBreath, voice, tts, stt)` gives seamless cross-mode handoffs
+ * with no remounts.
+ *
+ * All animation starts are imperative (via `useAnimatedReaction`) so they tick on
+ * reanimated-web; the combiner is a pure-read `useDerivedValue`. Effect-free — no
+ * React `useEffect`.
+ */
+export function useAmbientWave({ voice, isTTSPlaying, ttsWaveAmplitude, isGenerating }: UseAmbientWaveOptions): UseAmbientWaveResult {
+  // ── Idle breath: subtle 0.04↔0.09 swell (~7s), started once on mount ──
+  const idleBreath = useSharedValue(0.04);
+  useAnimatedReaction(
+    () => true,
+    (_current, previous) => {
+      if (previous !== null) return; // fire only on the initial run
+      idleBreath.value = withRepeat(
+        withSequence(
+          withTiming(0.09, { duration: 3500, easing: Easing.inOut(Easing.sin) }),
+          withTiming(0.04, { duration: 3500, easing: Easing.inOut(Easing.sin) }),
+        ),
+        -1,
+      );
+    },
+    [],
+  );
+
+  // ── STT metering smoothing (floor 0.08, fast attack / slow decay, →0 on stop) ──
+  const sttIsRecording = useSTTStore((s) => s.isRecording);
+  const sttMetering = useSTTStore((s) => s.metering);
+  const stt = useSharedValue(0);
+  useAnimatedReaction(
+    () => (sttIsRecording ? Math.max(0.08, sttMetering) : -1),
+    (target) => {
+      if (target < 0) {
+        stt.value = withTiming(0, { duration: 300 });
+        return;
+      }
+      const duration = target > stt.value ? 60 : 200;
+      stt.value = withTiming(target, { duration, easing: Easing.bezier(0.33, 1, 0.68, 1) });
+    },
+    [sttIsRecording, sttMetering],
+  );
+
+  // ── Thinking/generating motion (text chat, no voice) — gentle oscillation ──
+  const thinkingAmp = useSharedValue(0);
+  useAnimatedReaction(
+    () => isGenerating ?? false,
+    (generating, previous) => {
+      if (generating === previous) return;
+      if (generating) {
+        thinkingAmp.value = withRepeat(
+          withSequence(
+            withTiming(0.18, { duration: 1200, easing: Easing.inOut(Easing.sin) }),
+            withTiming(0.08, { duration: 1200, easing: Easing.inOut(Easing.sin) }),
+          ),
+          -1,
+        );
+      } else {
+        cancelAnimation(thinkingAmp);
+        thinkingAmp.value = withTiming(0, { duration: 300 });
+      }
+    },
+    [isGenerating],
+  );
+
+  // ── Combined amplitude — pure reads only (ticks on web) ──
+  const voiceAmplitude = voice?.waveAmplitude;
+  const waveAmplitude = useDerivedValue(
+    () => Math.max(idleBreath.value, voiceAmplitude ? voiceAmplitude.value : 0, ttsWaveAmplitude.value, stt.value, thinkingAmp.value),
+    [voiceAmplitude, ttsWaveAmplitude],
+  );
+
+  // ── Mode → palette state + overlay intensity (plain derived) ──
+  return useMemo<UseAmbientWaveResult>(() => {
+    if (voice?.isActive && voice.isConnected) {
+      return { waveAmplitude, agentState: voice.agentState, intensity: ACTIVE_INTENSITY, mode: 'voice' };
+    }
+    if (isTTSPlaying) {
+      return { waveAmplitude, agentState: 'speaking', intensity: ACTIVE_INTENSITY, mode: 'tts' };
+    }
+    if (sttIsRecording) {
+      return { waveAmplitude, agentState: 'listening', intensity: ACTIVE_INTENSITY, mode: 'stt' };
+    }
+    if (isGenerating) {
+      return { waveAmplitude, agentState: 'thinking', intensity: THINKING_INTENSITY, mode: 'thinking' };
+    }
+    return { waveAmplitude, agentState: 'idle', intensity: IDLE_INTENSITY, mode: 'idle' };
+  }, [waveAmplitude, voice?.isActive, voice?.isConnected, voice?.agentState, isTTSPlaying, sttIsRecording, isGenerating]);
+}

package/src/hooks/useAudioLevelMonitor.ts

@@ -9,10 +9,10 @@
  */
 
 import { useState, useEffect, useRef } from 'react';
-import { Room, RoomEvent, Track } from 'livekit-client';
+import { Room, RoomEvent, Track, type RemoteTrack, type RemoteTrackPublication, type RemoteParticipant } from 'livekit-client';
 
 /** Compute RMS (root mean square) amplitude from an AnalyserNode. Returns 0-1. */
-function getRMS(analyser: AnalyserNode, buffer: any): number {
+function getRMS(analyser: AnalyserNode, buffer: Float32Array<ArrayBuffer>): number {
   analyser.getFloatTimeDomainData(buffer);
   let sum = 0;
   for (let i = 0; i < buffer.length; i++) sum += buffer[i] * buffer[i];
@@ -45,8 +45,8 @@ export function useAudioLevelMonitor(room: Room | null, isConnected: boolean) {
     }
 
     let localAnalyser: AnalyserNode | null = null;
-    let localBuffer: Float32Array | null = null;
-    const remoteAnalysers = new Map<string, { analyser: AnalyserNode; buffer: Float32Array }>();
+    let localBuffer: Float32Array<ArrayBuffer> | null = null;
+    const remoteAnalysers = new Map<string, { analyser: AnalyserNode; buffer: Float32Array<ArrayBuffer> }>();
     let rafId = 0;
     let disposed = false;
 
@@ -89,7 +89,7 @@ export function useAudioLevelMonitor(room: Room | null, isConnected: boolean) {
     }
 
     // Listen for new remote audio tracks
-    const onTrackSubscribed = (track: any, publication: any, participant: any) => {
+    const onTrackSubscribed = (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => {
       if (track.kind === Track.Kind.Audio && track.mediaStreamTrack) {
         setupRemoteAnalyser(track.mediaStreamTrack, `${participant.identity}-${publication.trackSid}`);
       }
@@ -97,7 +97,7 @@ export function useAudioLevelMonitor(room: Room | null, isConnected: boolean) {
     room.on(RoomEvent.TrackSubscribed, onTrackSubscribed);
 
     // Clean up stale analysers when tracks are unsubscribed
-    const onTrackUnsubscribed = (track: any, publication: any, participant: any) => {
+    const onTrackUnsubscribed = (_track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => {
       const key = `${participant.identity}-${publication.trackSid}`;
       remoteAnalysers.delete(key);
     };

package/src/hooks/useDocumentPicker.ts

@@ -21,7 +21,7 @@ export function useDocumentPicker(): UseDocumentPickerResult {
       });
 
       if (result.canceled === false && result.assets && result.assets.length > 0) {
-        return result.assets.map((asset: any) => ({
+        return result.assets.map((asset) => ({
           uri: asset.uri,
           name: asset.name,
           size: asset.size || 0,

package/src/hooks/useImagePicker.ts

@@ -22,7 +22,7 @@ export function useImagePicker(): ImagePickerResult {
       });
 
       if (!result.canceled && result.assets.length > 0) {
-        return result.assets.map((asset: any) => ({
+        return result.assets.map((asset) => ({
           uri: asset.uri,
           name: asset.fileName || `image-${Date.now()}.jpg`,
           size: asset.fileSize || 0,

package/src/hooks/useSoundEffects.ts

@@ -8,21 +8,22 @@
  */
 
 import { useEffect, useRef, useCallback } from 'react';
+import type { AudioPlayer, AudioSource } from 'expo-audio';
 import type { AgentState } from '../types';
 
 export type SoundName = 'thinking' | 'toolCall' | 'voiceConnect' | 'voiceDisconnect';
 
 export interface SoundSources {
-  thinking?: any;
-  toolCall?: any;
-  voiceConnect?: any;
-  voiceDisconnect?: any;
+  thinking?: AudioSource;
+  toolCall?: AudioSource;
+  voiceConnect?: AudioSource;
+  voiceDisconnect?: AudioSource;
 }
 
 const SOUND_NAMES: SoundName[] = ['thinking', 'toolCall', 'voiceConnect', 'voiceDisconnect'];
 
 export function useSoundEffects(enabled: boolean = false, sounds: SoundSources = {}) {
-  const playersRef = useRef<Map<SoundName, any>>(new Map());
+  const playersRef = useRef<Map<SoundName, AudioPlayer>>(new Map());
   const loadedRef = useRef(false);
 
   useEffect(() => {

package/src/hooks/useSpeechToText.ts

@@ -1,9 +1,10 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
+import { errorMessage } from '../lib/utils';
 import {
   useAudioRecorder,
   useAudioRecorderState,
   RecordingPresets,
-  requestRecordingPermissionsAsync,
+  getRecordingPermissionsAsync,
   setAudioModeAsync,
 } from 'expo-audio';
 import { useOxy } from '@oxyhq/services';
@@ -92,7 +93,12 @@ export function useSpeechToText(options: UseSTTOptions = {}) {
     try {
       setError(null);
 
-      const permStatus = await requestRecordingPermissionsAsync();
+      // getRecordingPermissionsAsync consults the Permissions API first (and
+      // only falls back to a real getUserMedia prompt when undetermined), so an
+      // already-granted permission never gets misreported as denied when the
+      // device itself is missing/busy — that failure surfaces from
+      // prepareToRecordAsync below with an accurate message.
+      const permStatus = await getRecordingPermissionsAsync();
       if (!permStatus.granted) {
         setError('Microphone permission required');
         return;
@@ -108,9 +114,17 @@ export function useSpeechToText(options: UseSTTOptions = {}) {
       await audioRecorder.prepareToRecordAsync();
       audioRecorder.record();
       isRecordingRef.current = true;
-    } catch (e: any) {
-      console.error('[STT] Recording error:', e);
-      setError('Failed to start recording');
+    } catch (e: unknown) {
+      const name = e instanceof Error ? e.name : '';
+      if (name === 'NotFoundError' || name === 'OverconstrainedError') {
+        setError('No microphone found — check your input devices');
+      } else if (name === 'NotAllowedError') {
+        setError('Microphone permission required');
+      } else if (name === 'NotReadableError') {
+        setError('Microphone is in use by another application');
+      } else {
+        setError('Failed to start recording');
+      }
       setState('idle');
       isRecordingRef.current = false;
     }
@@ -167,9 +181,9 @@ export function useSpeechToText(options: UseSTTOptions = {}) {
       const result = await transcribeResponse.json() as { text: string };
       setState('idle');
       return result.text || null;
-    } catch (e: any) {
+    } catch (e: unknown) {
       console.error('[STT] Transcription error:', e);
-      setError(e.message || 'Transcription failed');
+      setError(errorMessage(e, 'Transcription failed'));
       setState('idle');
       return null;
     }

package/src/hooks/useTTS.ts

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef } from 'react';
+import type { AudioPlayer, AudioPlaybackStatus } from 'expo-audio';
 import {
   useSharedValue,
   withRepeat,
@@ -8,6 +9,7 @@ import {
   Easing,
 } from 'react-native-reanimated';
 import { useOxy } from '@oxyhq/services';
+import { errorMessage } from '../lib/utils';
 import { create } from 'zustand';
 
 const API_URL = process.env.EXPO_PUBLIC_ALIA_API_URL ?? 'https://api.alia.onl';
@@ -63,7 +65,7 @@ export function useTTS(options: UseTTSOptions = {}) {
     reset,
   } = useTTSStore();
 
-  const playerRef = useRef<any>(null);
+  const playerRef = useRef<AudioPlayer | null>(null);
 
   // Simulated wave amplitude for visualization
   const ttsWaveAmplitude = useSharedValue(0);
@@ -124,7 +126,7 @@ export function useTTS(options: UseTTSOptions = {}) {
         const player = createAudioPlayer({ uri: audioUrl });
         playerRef.current = player;
 
-        player.addListener('playbackStatusUpdate', (status: any) => {
+        player.addListener('playbackStatusUpdate', (status: AudioPlaybackStatus) => {
           if (status.didJustFinish) {
             releasePlayer();
             reset();
@@ -206,9 +208,9 @@ export function useTTS(options: UseTTSOptions = {}) {
 
       const data = await response.json();
       playFromUrl(data.audioUrl, messageId);
-    } catch (e: any) {
+    } catch (e: unknown) {
       console.error('[TTS] Error:', e);
-      setError(e.message || 'Failed to read aloud');
+      setError(errorMessage(e, 'Failed to read aloud'));
     }
   }, [activeMessageId, playbackState, getToken, apiUrl, getTTSVoice, getTTSSpeed, stop, playFromUrl, setActiveMessage, setPlaybackState, setError]);