@alia.onl/sdk 1.0.0 → 3.0.0

package/src/hooks/useVoiceRoom.ts

@@ -0,0 +1,420 @@
+/**
+ * Hook for real-time voice conversations via LiveKit rooms.
+ *
+ * Connects to a LiveKit room (created by POST /v1/voice/token),
+ * publishes the user's microphone, and receives agent audio + data
+ * messages (transcripts, state, cohost events) over WebRTC.
+ */
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+import {
+  Room,
+  RoomEvent,
+  Track,
+  DisconnectReason,
+  type RemoteTrackPublication,
+  type RemoteParticipant,
+  type DataPublishOptions,
+} from 'livekit-client';
+import { useOxy } from '@oxyhq/services';
+import type { RoomState, AgentState, VoiceMessage, VoiceToolInvocation } from '../types';
+
+const API_URL = process.env.EXPO_PUBLIC_ALIA_API_URL ?? 'https://api.alia.onl';
+
+// ============== OPTIONS ==============
+
+export interface UseVoiceRoomOptions {
+  apiUrl?: string;
+  voicePreference?: 'male' | 'female';
+  accessToken?: string;
+}
+
+// ============== TITLE TAG UTILITIES ==============
+
+const TAG = String.raw`ALIA_TITLE|TITLE|TÍTULO|TITRE|TITOLO|TITEL|ЗАГОЛОВОК`;
+
+const TITLE_STRIP_RE = new RegExp(
+  String.raw`\[(${TAG})\].*?\[\/\1\]|<(${TAG})>.*?<\/\2>`, 'gi',
+);
+
+const TITLE_PARTIAL_RE = new RegExp(
+  String.raw`\[(${TAG})\].*?(\[\/\1\])?$|<(${TAG})>.*?(<\/\3>)?$`, 'si',
+);
+
+function stripTitleTags(content: string): string {
+  return content.replace(TITLE_STRIP_RE, '').trim();
+}
+
+function stripTitleTagsPartial(content: string): string {
+  return content.replace(TITLE_STRIP_RE, '').replace(TITLE_PARTIAL_RE, '').trim();
+}
+
+// ============== INTERNAL DATA MESSAGE TYPES ==============
+
+interface AgentStateMsg { type: 'agent.state'; state: 'listening' | 'thinking' | 'speaking'; speaker: 'primary' | 'cohost' }
+interface TranscriptDeltaMsg { type: 'transcript.delta'; delta: string; speaker: 'primary' | 'cohost' }
+interface TranscriptDoneMsg { type: 'transcript.done'; transcript: string; speaker: 'primary' | 'cohost' }
+interface TranscriptUserMsg { type: 'transcript.user'; transcript: string }
+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 ToolResultMsg { type: 'tool.result'; callId: string; speaker: 'primary' | 'cohost' }
+interface SessionEndedMsg { type: 'session.ended'; reason: string }
+interface ErrorMsg { type: 'error'; code: string; message: string }
+
+type AgentDataMessage =
+  | AgentStateMsg | TranscriptDeltaMsg | TranscriptDoneMsg | TranscriptUserMsg
+  | CohostEnabledMsg | CohostDisabledMsg | CohostTurnMsg | CohostRoundMsg
+  | ToolCallMsg | ToolResultMsg | SessionEndedMsg | ErrorMsg;
+
+// ============== HOOK ==============
+
+export function useVoiceRoom(options: UseVoiceRoomOptions = {}) {
+  const apiUrl = options.apiUrl || API_URL;
+  const voicePref = options.voicePreference ?? 'female';
+
+  const [roomState, setRoomState] = useState<RoomState>('disconnected');
+  const [agentState, setAgentState] = useState<AgentState>('idle');
+  const [isMuted, setIsMuted] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [messages, setMessages] = useState<VoiceMessage[]>([]);
+  const [cohostActive, setCohostActive] = useState(false);
+  const [currentSpeaker, setCurrentSpeaker] = useState<'primary' | 'cohost' | 'user' | null>(null);
+  const [roundComplete, setRoundComplete] = useState(false);
+
+  const roomRef = useRef<Room | null>(null);
+  const sessionIdRef = useRef<string | null>(null);
+  const msgIdRef = useRef(0);
+  const sessionPrefixRef = useRef(`vm-${Date.now().toString(36)}`);
+
+  // Per-speaker streaming transcript refs
+  const primaryTextRef = useRef('');
+  const cohostTextRef = useRef('');
+
+  const { oxyServices } = useOxy();
+
+  // ============== AUTH ==============
+
+  const getToken = useCallback((): string | null => {
+    if (options.accessToken) return options.accessToken;
+    return oxyServices.httpService.getAccessToken();
+  }, [options.accessToken, oxyServices]);
+
+  // ============== CLEANUP ==============
+
+  const cleanup = useCallback(() => {
+    if (roomRef.current) {
+      // Detach all remote audio tracks before disconnecting
+      roomRef.current.remoteParticipants.forEach((p) => {
+        p.trackPublications.forEach((pub) => {
+          pub.track?.detach();
+        });
+      });
+      roomRef.current.disconnect();
+      roomRef.current = null;
+    }
+    sessionIdRef.current = null;
+    primaryTextRef.current = '';
+    cohostTextRef.current = '';
+  }, []);
+
+  // ============== DATA MESSAGE HANDLER ==============
+
+  const handleDataMessage = useCallback((payload: Uint8Array) => {
+    try {
+      const msg: AgentDataMessage = JSON.parse(new TextDecoder().decode(payload));
+
+      switch (msg.type) {
+        case 'agent.state': {
+          // Always update agentState so both primary and cohost drive wave animation
+          setAgentState(msg.state);
+          setCurrentSpeaker(msg.speaker);
+          break;
+        }
+
+        case 'transcript.delta': {
+          const textRef = msg.speaker === 'cohost' ? cohostTextRef : primaryTextRef;
+          textRef.current += msg.delta;
+          const text = stripTitleTagsPartial(textRef.current);
+          setMessages(prev => {
+            const last = prev[prev.length - 1];
+            if (last && last.role === 'assistant' && last.isStreaming && last.speaker === msg.speaker) {
+              return [...prev.slice(0, -1), { ...last, content: text }];
+            }
+            msgIdRef.current++;
+            return [...prev, {
+              id: `${sessionPrefixRef.current}-${msgIdRef.current}`,
+              role: 'assistant',
+              speaker: msg.speaker,
+              content: text,
+              timestamp: Date.now(),
+              isStreaming: true,
+            }];
+          });
+          break;
+        }
+
+        case 'transcript.done': {
+          const textRef = msg.speaker === 'cohost' ? cohostTextRef : primaryTextRef;
+          textRef.current = '';
+          const clean = stripTitleTags(msg.transcript);
+          setMessages(prev => {
+            const last = prev[prev.length - 1];
+            if (last && last.role === 'assistant' && last.isStreaming && last.speaker === msg.speaker) {
+              return [...prev.slice(0, -1), { ...last, content: clean, isStreaming: false }];
+            }
+            return prev;
+          });
+          break;
+        }
+
+        case 'transcript.user': {
+          if (!msg.transcript.trim()) break;
+          const transcript = msg.transcript.trim();
+          setMessages(prev => {
+            const last = prev[prev.length - 1];
+            // Update existing user message instead of creating duplicates
+            if (last && last.role === 'user') {
+              return [...prev.slice(0, -1), { ...last, content: transcript }];
+            }
+            msgIdRef.current++;
+            return [...prev, {
+              id: `${sessionPrefixRef.current}-${msgIdRef.current}`,
+              role: 'user',
+              content: transcript,
+              timestamp: Date.now(),
+              isStreaming: false,
+            }];
+          });
+          break;
+        }
+
+        case 'cohost.enabled':
+          setCohostActive(true);
+          break;
+
+        case 'cohost.disabled':
+          setCohostActive(false);
+          setCurrentSpeaker(null);
+          break;
+
+        case 'cohost.turn_changed':
+          setCurrentSpeaker(msg.speaker);
+          break;
+
+        case 'cohost.round_complete':
+          setRoundComplete(true);
+          break;
+
+        case 'tool.call': {
+          const tool: VoiceToolInvocation = { toolCallId: msg.callId, toolName: msg.toolName, state: 'call', args: msg.args };
+          setMessages(prev => {
+            const last = prev[prev.length - 1];
+            if (last && last.role === 'assistant' && last.speaker === msg.speaker) {
+              return [...prev.slice(0, -1), {
+                ...last,
+                toolInvocations: [...(last.toolInvocations || []), tool],
+              }];
+            }
+            msgIdRef.current++;
+            return [...prev, {
+              id: `${sessionPrefixRef.current}-${msgIdRef.current}`,
+              role: 'assistant' as const,
+              speaker: msg.speaker,
+              content: '',
+              timestamp: Date.now(),
+              isStreaming: true,
+              toolInvocations: [tool],
+            }];
+          });
+          break;
+        }
+
+        case 'tool.result': {
+          setMessages(prev => prev.map(m => {
+            if (!m.toolInvocations) return m;
+            const updated = m.toolInvocations.map(t =>
+              t.toolCallId === msg.callId ? { ...t, state: 'result' as const } : t
+            );
+            return { ...m, toolInvocations: updated };
+          }));
+          break;
+        }
+
+        case 'session.ended': {
+          cleanup();
+          setRoomState('disconnected');
+          setAgentState('idle');
+          const reason = msg.reason;
+          setError(
+            reason === 'user_silent' ? 'Call ended due to inactivity'
+            : reason === 'user_unresponsive' ? 'Call ended — no response'
+            : reason === 'max_duration_exceeded' ? 'Voice minutes limit reached. Upgrade for more.'
+            : reason === 'credits_exhausted' ? 'Not enough credits to continue. Add more or upgrade your plan.'
+            : 'Voice session ended'
+          );
+          break;
+        }
+
+        case 'error':
+          setError(msg.message);
+          break;
+      }
+    } catch {
+      // Ignore non-JSON data
+    }
+  }, [cleanup]);
+
+  // ============== CONNECT ==============
+
+  const connect = useCallback(async () => {
+    try {
+      setError(null);
+      setRoomState('connecting');
+
+      const token = getToken();
+      if (!token) {
+        setError('Not authenticated');
+        setRoomState('error');
+        return;
+      }
+
+      // Request session creation from backend
+      const resp = await fetch(`${apiUrl}/v1/voice/token`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+          model: 'alia-v1-voice',
+          voice: voicePref === 'male' ? 'echo' : 'nova',
+        }),
+      });
+
+      if (!resp.ok) {
+        const body = await resp.json().catch(() => ({}));
+        const errMsg = body?.error?.message || body?.error || `Voice session failed (${resp.status})`;
+        setError(errMsg);
+        setRoomState('error');
+        return;
+      }
+
+      const { token: livekitToken, url, roomName, sessionId } = await resp.json();
+      sessionIdRef.current = sessionId;
+
+      // Create LiveKit room and connect
+      const room = new Room();
+      roomRef.current = room;
+
+      // Event: remote audio tracks (agent speaking) — must attach to play
+      room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
+        if (track.kind === Track.Kind.Audio) {
+          track.attach();
+        }
+      });
+
+      room.on(RoomEvent.TrackUnsubscribed, (track) => {
+        track.detach();
+      });
+
+      // Event: data messages from agent
+      room.on(RoomEvent.DataReceived, (payload: Uint8Array) => {
+        handleDataMessage(payload);
+      });
+
+      // Event: disconnected
+      room.on(RoomEvent.Disconnected, (reason?: DisconnectReason) => {
+        setRoomState('disconnected');
+        setAgentState('idle');
+        setCohostActive(false);
+      });
+
+      // 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);
+
+      setRoomState('connected');
+      setAgentState('listening');
+
+    } catch (e: any) {
+      console.error('[useVoiceRoom] Connection error:', e);
+      setError(e.message || 'Failed to connect');
+      setRoomState('error');
+      cleanup();
+    }
+  }, [getToken, cleanup, handleDataMessage, apiUrl, voicePref]);
+
+  // ============== DISCONNECT ==============
+
+  const disconnect = useCallback(() => {
+    cleanup();
+    setRoomState('disconnected');
+    setAgentState('idle');
+    setError(null);
+    setIsMuted(false);
+    setMessages([]);
+    setCohostActive(false);
+    setCurrentSpeaker(null);
+    setRoundComplete(false);
+  }, [cleanup]);
+
+  // ============== MUTE ==============
+
+  const toggleMute = useCallback(() => {
+    const room = roomRef.current;
+    if (!room) return;
+    const next = !isMuted;
+    room.localParticipant.setMicrophoneEnabled(!next);
+    setIsMuted(next);
+  }, [isMuted]);
+
+  // ============== COHOST CONTROLS ==============
+
+  const sendClientData = useCallback((data: object) => {
+    const room = roomRef.current;
+    if (!room?.localParticipant) return;
+    const encoded = new TextEncoder().encode(JSON.stringify(data));
+    room.localParticipant.publishData(encoded, { reliable: true } as DataPublishOptions);
+  }, []);
+
+  const enableCohost = useCallback(() => {
+    sendClientData({ type: 'cohost.enable' });
+  }, [sendClientData]);
+
+  const disableCohost = useCallback(() => {
+    sendClientData({ type: 'cohost.disable' });
+  }, [sendClientData]);
+
+  const continueCohost = useCallback(() => {
+    setRoundComplete(false);
+    sendClientData({ type: 'cohost.continue' });
+  }, [sendClientData]);
+
+  // ============== CLEANUP ON UNMOUNT ==============
+
+  useEffect(() => cleanup, [cleanup]);
+
+  return {
+    room: roomRef.current,
+    roomState,
+    agentState,
+    isMuted,
+    error,
+    messages,
+    cohostActive,
+    currentSpeaker,
+    roundComplete,
+    connect,
+    disconnect,
+    toggleMute,
+    enableCohost,
+    disableCohost,
+    continueCohost,
+    isConnected: roomState === 'connected',
+  };
+}

package/src/index.ts

@@ -1,17 +1,82 @@
+/// <reference path="./optional-deps.d.ts" />
 // @alia.onl/sdk — Alia AI Chat SDK
-// Reusable bottom sheet chat component for any Oxy ecosystem app
+// Reusable chat UI, voice, and streaming components for Oxy apps
 
-// Main component
+// ── Main components ──
 export { AliaChatSheet } from './components/AliaChatSheet';
 export type { AliaChatSheetProps, AliaChatSheetRef } from './components/AliaChatSheet';
+export { AliaChatScreen } from './components/AliaChatScreen';
+export type { AliaChatScreenProps } from './components/AliaChatScreen';
 
-// Hook (for custom UIs)
+// ── Chat UI components ──
+export { AliaFace } from './components/AliaFace';
+export type { AliaExpression, AliaFaceProps } from './components/AliaFace';
+export { ThinkingIndicator } from './components/ThinkingIndicator';
+export { AliaMarkdown } from './components/Markdown';
+export { Reasoning, ReasoningTrigger, ReasoningContent } from './components/Reasoning';
+
+// ── Voice components ──
+export { AudioWaveVisualizer } from './components/voice/AudioWaveVisualizer';
+export { VoiceOverlay } from './components/voice/VoiceOverlay';
+export { VoiceControls } from './components/voice/VoiceControls';
+
+// ── Chat hook ──
 export { useAliaChat } from './hooks/useAliaChat';
 export type { UseAliaChatOptions, UseAliaChatReturn } from './hooks/useAliaChat';
 
-// Types
-export type { ChatMessage, ToolInvocation, AliaChatSuggestion } from './types';
+// ── Voice hooks ──
+export { useVoiceRoom } from './hooks/useVoiceRoom';
+export { useAudioLevelMonitor } from './hooks/useAudioLevelMonitor';
+export { useAudioLevels } from './hooks/useAudioLevels';
+export { useTTS } from './hooks/useTTS';
+export type { UseTTSOptions } from './hooks/useTTS';
+export { useSpeechToText, useSTTStore } from './hooks/useSpeechToText';
+export type { UseSTTOptions } from './hooks/useSpeechToText';
+export { useSoundEffects, useVoiceSoundEffects } from './hooks/useSoundEffects';
+export type { SoundName, SoundSources } from './hooks/useSoundEffects';
+
+// ── Types ──
+export type {
+  ChatMessage,
+  ToolInvocation,
+  AliaChatSuggestion,
+  ResearchProgress,
+  PendingPlan,
+  RoomState,
+  AgentState,
+  VoiceMessage,
+  VoiceToolInvocation,
+} from './types';
+
+// ── UI Primitives (NativeWind) ──
+export { Button, buttonVariants, buttonTextVariants } from './components/ui/button';
+export type { ButtonProps } from './components/ui/button';
+export { Text, TextClassContext } from './components/ui/text';
+export { ChatTextInput } from './components/ui/chat-text-input';
+export { cn, formatFileSize } from './lib/utils';
+
+// ── PromptInput ──
+export { PromptInput } from './components/ui/prompt-input/prompt-input';
+export type { PromptInputProps } from './components/ui/prompt-input/prompt-input';
+export { usePromptInput, useIsFullscreen, PromptInputContext } from './components/ui/prompt-input/context';
+export type { Attachment, Completion, PromptInputContextType } from './components/ui/prompt-input/context';
+export { PromptInputTextarea } from './components/ui/prompt-input/textarea';
+export { PromptInputActions } from './components/ui/prompt-input/actions';
+export { PromptInputSubmitButton } from './components/ui/prompt-input/submit-button';
+export { PromptInputMicButton } from './components/ui/prompt-input/mic-button';
+export { PromptInputAddMenu } from './components/ui/prompt-input/add-menu';
+export { PromptInputAttachments } from './components/ui/prompt-input/attachments';
+export { PromptInputAutocomplete } from './components/ui/prompt-input/autocomplete';
+
+// ── Picker hooks ──
+export { useImagePicker } from './hooks/useImagePicker';
+export type { ImagePickerAsset } from './hooks/useImagePicker';
+export { useDocumentPicker } from './hooks/useDocumentPicker';
+export type { DocumentPickerResult } from './hooks/useDocumentPicker';
+
+// ── Keyboard ──
+export { KeyboardAwareScrollView, KeyboardAvoidingView, KeyboardProvider } from './lib/keyboard';
 
-// Theme
+// ── Theme ──
 export { useAliaColors } from './theme';
 export type { AliaColors } from './theme';

package/src/lib/keyboard.native.tsx

@@ -0,0 +1,6 @@
+// Native: re-export react-native-keyboard-controller components
+export {
+  KeyboardAwareScrollView,
+  KeyboardAvoidingView,
+  KeyboardProvider,
+} from 'react-native-keyboard-controller';

package/src/lib/keyboard.tsx

@@ -0,0 +1,25 @@
+// Web: re-export React Native built-in components as keyboard-controller substitutes
+import React from 'react';
+import { ScrollView, type ScrollViewProps, KeyboardAvoidingView } from 'react-native';
+
+// Accept native-only props so shared components don't cause TS errors
+type KeyboardAwareScrollViewProps = ScrollViewProps & {
+  bottomOffset?: number;
+  disableScrollOnKeyboardHide?: boolean;
+  enabled?: boolean;
+  extraKeyboardSpace?: number;
+};
+
+const KeyboardAwareScrollView = React.forwardRef<ScrollView, KeyboardAwareScrollViewProps>(
+  ({ bottomOffset, disableScrollOnKeyboardHide, enabled, extraKeyboardSpace, ...props }, ref) => (
+    <ScrollView ref={ref} {...props} />
+  )
+);
+KeyboardAwareScrollView.displayName = 'KeyboardAwareScrollView';
+
+export { KeyboardAwareScrollView, KeyboardAvoidingView };
+
+// No-op provider on web — keyboard-controller is native-only
+export function KeyboardProvider({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}

package/src/lib/utils.ts

@@ -0,0 +1,14 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}

package/src/optional-deps.d.ts

@@ -0,0 +1,86 @@
+// NativeWind types — extends RN components with className prop
+/// <reference types="nativewind/types" />
+
+// Type declarations for optional peer dependencies.
+// These prevent TypeScript errors when the deps aren't installed.
+// At runtime, the host app provides the actual packages.
+//
+// NOTE: Only declare modules for packages NOT installed in the monorepo.
+// Installed packages (lucide-react-native, zeego, expo-image, etc.)
+// have their own real types — ambient declarations here would shadow them.
+
+declare module 'livekit-client' {
+  export class Room {
+    on(event: any, listener: (...args: any[]) => void): this;
+    off(event: any, listener: (...args: any[]) => void): this;
+    localParticipant: LocalParticipant;
+    remoteParticipants: Map<string, RemoteParticipant>;
+    connect(url: string, token: string, options?: any): 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;
+    setMicrophoneEnabled(enabled: boolean): Promise<void>;
+    audioTrackPublications: Map<string, any>;
+    trackPublications: Map<string, any>;
+  }
+  export class RemoteParticipant {
+    getTrackPublications(): Map<string, RemoteTrackPublication>;
+    audioTrackPublications: Map<string, RemoteTrackPublication>;
+    trackPublications: Map<string, RemoteTrackPublication>;
+    identity: string;
+  }
+  export class RemoteTrackPublication {
+    track: any;
+    source: string;
+    kind: string;
+    isSubscribed: boolean;
+    trackSid: string;
+  }
+  export interface DataPublishOptions {
+    reliable?: boolean;
+    topic?: string;
+  }
+  export const RoomEvent: Record<string, string>;
+  export const Track: { Source: Record<string, string>; Kind: Record<string, string> };
+  export const DataPacket_Kind: Record<string, number>;
+  export enum DisconnectReason {
+    UNKNOWN_REASON = 0,
+    CLIENT_INITIATED = 1,
+    DUPLICATE_IDENTITY = 2,
+    SERVER_SHUTDOWN = 3,
+    PARTICIPANT_REMOVED = 4,
+    ROOM_DELETED = 5,
+    STATE_MISMATCH = 6,
+    JOIN_FAILURE = 7,
+  }
+}
+
+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 function requestRecordingPermissionsAsync(): Promise<{ granted: boolean }>;
+  export function setAudioModeAsync(mode: any): Promise<void>;
+  export const RecordingPresets: { HIGH_QUALITY: any };
+  export class AudioRecorder {
+    constructor(preset: any);
+    prepareToRecordAsync(): Promise<void>;
+    record(): void;
+    stop(): Promise<void>;
+    uri: string | null;
+  }
+}
+
+declare module 'expo-clipboard' {
+  export function setStringAsync(text: string): Promise<boolean>;
+  export function getStringAsync(): Promise<string>;
+}
+
+declare module 'expo-image-picker' {
+  export function launchImageLibraryAsync(options?: any): Promise<any>;
+  export const MediaTypeOptions: { Images: string; Videos: string; All: string };
+}

package/src/theme.ts

@@ -11,6 +11,9 @@ const COLORS = {
     secondaryText: '#8E8E93',
     icon: '#687076',
     tint: '#0a7ea4',
+    muted: '#F4F4F5',
+    mutedForeground: '#71717A',
+    primary: '#0a7ea4',
   },
   dark: {
     text: '#ECEDEE',
@@ -21,12 +24,32 @@ const COLORS = {
     secondaryText: '#8E8E93',
     icon: '#9BA1A6',
     tint: '#fff',
+    muted: '#27272A',
+    mutedForeground: '#A1A1AA',
+    primary: '#38BDF8',
   },
 } as const;
 
-export type AliaColors = (typeof COLORS)['light'];
+export interface AliaColors {
+  text: string;
+  background: string;
+  card: string;
+  inputBackground: string;
+  border: string;
+  secondaryText: string;
+  icon: string;
+  tint: string;
+  muted: string;
+  mutedForeground: string;
+  primary: string;
+  isDark: boolean;
+}
 
 export function useAliaColors(): AliaColors {
   const scheme = useColorScheme();
-  return useMemo(() => COLORS[scheme ?? 'light'], [scheme]);
+  const key = scheme === 'dark' ? 'dark' : 'light';
+  return useMemo(() => ({
+    ...COLORS[key],
+    isDark: key === 'dark',
+  }), [key]);
 }